Avoid naming variables str

This renames variables named `str` to other names, to make sure `str`
always refers to a type.

It's confusing to read code where `str` (or another standard type name)
is used as an identifier. It also produces misleading syntax
highlighting.

Author: joshtriplett

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -544,12 +544,12 @@ fn pretty_print_region_elements(elements: impl IntoIterator<Item = RegionElement
 
     return result;
 
-    fn push_location_range(str: &mut String, location1: Location, location2: Location) {
+    fn push_location_range(s: &mut String, location1: Location, location2: Location) {
         if location1 == location2 {
-            str.push_str(&format!("{location1:?}"));
+            s.push_str(&format!("{location1:?}"));
         } else {
             assert_eq!(location1.block, location2.block);
-            str.push_str(&format!(
+            s.push_str(&format!(
                 "{:?}[{}..={}]",
                 location1.block, location1.statement_index, location2.statement_index
             ));

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -704,8 +704,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     pub fn read_str(&self, mplace: &MPlaceTy<'tcx, M::Provenance>) -> InterpResult<'tcx, &str> {
         let len = mplace.len(self)?;
         let bytes = self.read_bytes_ptr_strip_provenance(mplace.ptr(), Size::from_bytes(len))?;
-        let str = std::str::from_utf8(bytes).map_err(|err| err_ub!(InvalidStr(err)))?;
-        interp_ok(str)
+        let s = std::str::from_utf8(bytes).map_err(|err| err_ub!(InvalidStr(err)))?;
+        interp_ok(s)
     }
 
     /// Read from a local of the current frame. Convenience method for [`InterpCx::local_at_frame_to_op`].

compiler/rustc_const_eval/src/interpret/place.rs

@@ -1017,9 +1017,9 @@ where
     /// This is allocated in immutable global memory and deduplicated.
     pub fn allocate_str_dedup(
         &mut self,
-        str: &str,
+        s: &str,
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
-        let bytes = str.as_bytes();
+        let bytes = s.as_bytes();
         let ptr = self.allocate_bytes_dedup(bytes)?;
 
         // Create length metadata for the string.

compiler/rustc_lint/src/nonstandard_style.rs

@@ -234,18 +234,18 @@ declare_lint! {
 declare_lint_pass!(NonSnakeCase => [NON_SNAKE_CASE]);
 
 impl NonSnakeCase {
-    fn to_snake_case(mut str: &str) -> String {
+    fn to_snake_case(mut name: &str) -> String {
         let mut words = vec![];
         // Preserve leading underscores
-        str = str.trim_start_matches(|c: char| {
+        name = name.trim_start_matches(|c: char| {
             if c == '_' {
                 words.push(String::new());
                 true
             } else {
                 false
             }
         });
-        for s in str.split('_') {
+        for s in name.split('_') {
             let mut last_upper = false;
             let mut buf = String::new();
             if s.is_empty() {

compiler/rustc_log/src/lib.rs

@@ -130,11 +130,11 @@ pub fn init_logger(cfg: LoggerConfig) -> Result<(), Error> {
 
     let subscriber = tracing_subscriber::Registry::default().with(filter).with(layer);
     match cfg.backtrace {
-        Ok(str) => {
+        Ok(backtrace_target) => {
             let fmt_layer = tracing_subscriber::fmt::layer()
                 .with_writer(io::stderr)
                 .without_time()
-                .event_format(BacktraceFormatter { backtrace_target: str });
+                .event_format(BacktraceFormatter { backtrace_target });
             let subscriber = subscriber.with(fmt_layer);
             tracing::subscriber::set_global_default(subscriber).unwrap();
         }

compiler/rustc_macros/src/symbols.rs

@@ -156,14 +156,14 @@ impl Entries {
         Entries { map: HashMap::with_capacity(capacity) }
     }
 
-    fn insert(&mut self, span: Span, str: &str, errors: &mut Errors) -> u32 {
-        if let Some(prev) = self.map.get(str) {
-            errors.error(span, format!("Symbol `{str}` is duplicated"));
+    fn insert(&mut self, span: Span, s: &str, errors: &mut Errors) -> u32 {
+        if let Some(prev) = self.map.get(s) {
+            errors.error(span, format!("Symbol `{s}` is duplicated"));
             errors.error(prev.span_of_name, "location of previous definition".to_string());
             prev.idx
         } else {
             let idx = self.len();
-            self.map.insert(str.to_string(), Preinterned { idx, span_of_name: span });
+            self.map.insert(s.to_string(), Preinterned { idx, span_of_name: span });
             idx
         }
     }
@@ -192,14 +192,14 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
     let mut entries = Entries::with_capacity(input.keywords.len() + input.symbols.len() + 10);
     let mut prev_key: Option<(Span, String)> = None;
 
-    let mut check_order = |span: Span, str: &str, errors: &mut Errors| {
+    let mut check_order = |span: Span, s: &str, errors: &mut Errors| {
         if let Some((prev_span, ref prev_str)) = prev_key {
-            if str < prev_str {
-                errors.error(span, format!("Symbol `{str}` must precede `{prev_str}`"));
+            if s < prev_str {
+                errors.error(span, format!("Symbol `{s}` must precede `{prev_str}`"));
                 errors.error(prev_span, format!("location of previous symbol `{prev_str}`"));
             }
         }
-        prev_key = Some((span, str.to_string()));
+        prev_key = Some((span, s.to_string()));
     };
 
     // Generate the listed keywords.

library/std/src/process.rs

@@ -1283,13 +1283,13 @@ impl fmt::Debug for Output {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let stdout_utf8 = str::from_utf8(&self.stdout);
         let stdout_debug: &dyn fmt::Debug = match stdout_utf8 {
-            Ok(ref str) => str,
+            Ok(ref s) => s,
             Err(_) => &self.stdout,
         };
 
         let stderr_utf8 = str::from_utf8(&self.stderr);
         let stderr_debug: &dyn fmt::Debug = match stderr_utf8 {
-            Ok(ref str) => str,
+            Ok(ref s) => s,
             Err(_) => &self.stderr,
         };
 

library/std/src/sys/pal/windows/process.rs

@@ -142,11 +142,11 @@ impl AsRef<OsStr> for EnvKey {
     }
 }
 
-pub(crate) fn ensure_no_nuls<T: AsRef<OsStr>>(str: T) -> io::Result<T> {
-    if str.as_ref().encode_wide().any(|b| b == 0) {
+pub(crate) fn ensure_no_nuls<T: AsRef<OsStr>>(s: T) -> io::Result<T> {
+    if s.as_ref().encode_wide().any(|b| b == 0) {
         Err(io::const_error!(ErrorKind::InvalidInput, "nul byte found in provided data"))
     } else {
-        Ok(str)
+        Ok(s)
     }
 }
 

library/std/src/sys_common/wtf8.rs

@@ -204,8 +204,8 @@ impl Wtf8Buf {
     ///
     /// Since WTF-8 is a superset of UTF-8, this always succeeds.
     #[inline]
-    pub fn from_str(str: &str) -> Wtf8Buf {
-        Wtf8Buf { bytes: <[_]>::to_vec(str.as_bytes()), is_known_utf8: true }
+    pub fn from_str(s: &str) -> Wtf8Buf {
+        Wtf8Buf { bytes: <[_]>::to_vec(s.as_bytes()), is_known_utf8: true }
     }
 
     pub fn clear(&mut self) {

src/tools/clippy/clippy_lints/src/booleans.rs

@@ -349,8 +349,8 @@ impl SuggestContext<'_, '_, '_> {
                 },
                 Term(n) => {
                     let terminal = self.terminals[n as usize];
-                    if let Some(str) = simplify_not(self.cx, self.msrv, terminal) {
-                        self.output.push_str(&str);
+                    if let Some(s) = simplify_not(self.cx, self.msrv, terminal) {
+                        self.output.push_str(&s);
                     } else {
                         self.output.push('!');
                         self.output.push_str(&terminal.span.get_source_text(self.cx)?);

src/tools/clippy/clippy_lints/src/methods/mod.rs

@@ -2241,14 +2241,14 @@ declare_clippy_lint! {
     /// that both functions return a lazy iterator.
     /// ### Example
     /// ```no_run
-    /// let str = "key=value=add";
-    /// let _ = str.splitn(3, '=').next().unwrap();
+    /// let s = "key=value=add";
+    /// let _ = s.splitn(3, '=').next().unwrap();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let str = "key=value=add";
-    /// let _ = str.split('=').next().unwrap();
+    /// let s = "key=value=add";
+    /// let _ = s.split('=').next().unwrap();
     /// ```
     #[clippy::version = "1.59.0"]
     pub NEEDLESS_SPLITN,

src/tools/clippy/clippy_lints/src/min_ident_chars.rs

@@ -54,12 +54,12 @@ impl MinIdentChars {
     }
 
     #[expect(clippy::cast_possible_truncation)]
-    fn is_ident_too_short(&self, cx: &LateContext<'_>, str: &str, span: Span) -> bool {
+    fn is_ident_too_short(&self, cx: &LateContext<'_>, s: &str, span: Span) -> bool {
         !in_external_macro(cx.sess(), span)
-            && str.len() <= self.min_ident_chars_threshold as usize
-            && !str.starts_with('_')
-            && !str.is_empty()
-            && !self.allowed_idents_below_min_chars.contains(str)
+            && s.len() <= self.min_ident_chars_threshold as usize
+            && !s.starts_with('_')
+            && !s.is_empty()
+            && !self.allowed_idents_below_min_chars.contains(s)
     }
 }
 
@@ -83,10 +83,10 @@ impl LateLintPass<'_> for MinIdentChars {
     // This is necessary as `Node::Pat`s are not visited in `visit_id`. :/
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if let PatKind::Binding(_, _, ident, ..) = pat.kind
-            && let str = ident.as_str()
-            && self.is_ident_too_short(cx, str, ident.span)
+            && let s = ident.as_str()
+            && self.is_ident_too_short(cx, s, ident.span)
         {
-            emit_min_ident_chars(self, cx, str, ident.span);
+            emit_min_ident_chars(self, cx, s, ident.span);
         }
     }
 }
@@ -117,8 +117,8 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
             return;
         };
 
-        let str = ident.as_str();
-        if conf.is_ident_too_short(cx, str, ident.span) {
+        let s = ident.as_str();
+        if conf.is_ident_too_short(cx, s, ident.span) {
             // Check whether the node is part of a `use` statement. We don't want to emit a warning if the user
             // has no control over the type.
             let usenode = opt_as_use_node(node).or_else(|| {
@@ -134,7 +134,7 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
             // this case, we need to emit the warning for `baz`.
             if let Some(imported_item_path) = usenode
                 && let Some(Res::Def(_, imported_item_defid)) = imported_item_path.res.first()
-                && cx.tcx.item_name(*imported_item_defid).as_str() == str
+                && cx.tcx.item_name(*imported_item_defid).as_str() == s
             {
                 return;
             }
@@ -172,7 +172,7 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
                 return;
             }
 
-            emit_min_ident_chars(conf, cx, str, ident.span);
+            emit_min_ident_chars(conf, cx, s, ident.span);
         }
     }
 }

src/tools/clippy/clippy_lints/src/raw_strings.rs

@@ -74,9 +74,9 @@ impl EarlyLintPass for RawStrings {
         if let ExprKind::FormatArgs(format_args) = &expr.kind
             && !in_external_macro(cx.sess(), format_args.span)
             && format_args.span.check_source_text(cx, |src| src.starts_with('r'))
-            && let Some(str) = snippet_opt(cx.sess(), format_args.span)
-            && let count_hash = str.bytes().skip(1).take_while(|b| *b == b'#').count()
-            && let Some(str) = str.get(count_hash + 2..str.len() - count_hash - 1)
+            && let Some(s) = snippet_opt(cx.sess(), format_args.span)
+            && let count_hash = s.bytes().skip(1).take_while(|b| *b == b'#').count()
+            && let Some(s) = s.get(count_hash + 2..s.len() - count_hash - 1)
         {
             self.check_raw_string(
                 cx,
@@ -107,13 +107,13 @@ impl RawStrings {
     fn check_raw_string(
         &mut self,
         cx: &EarlyContext<'_>,
-        str: &str,
+        s: &str,
         lit_span: Span,
         prefix: &str,
         max: u8,
         descr: &str,
     ) {
-        if !str.contains(['\\', '"']) {
+        if !s.contains(['\\', '"']) {
             span_lint_and_then(
                 cx,
                 NEEDLESS_RAW_STRINGS,
@@ -148,7 +148,7 @@ impl RawStrings {
             let mut following_quote = false;
             let mut req = 0;
             // `once` so a raw string ending in hashes is still checked
-            let num = str.as_bytes().iter().chain(once(&0)).try_fold(0u8, |acc, &b| {
+            let num = s.as_bytes().iter().chain(once(&0)).try_fold(0u8, |acc, &b| {
                 match b {
                     b'"' if !following_quote => (following_quote, req) = (true, 1),
                     b'#' => req += u8::from(following_quote),

src/tools/compiletest/src/compute_diff.rs

@@ -31,7 +31,7 @@ pub fn make_diff(expected: &str, actual: &str, context_size: usize) -> Vec<Misma
 
     for result in diff::lines(expected, actual) {
         match result {
-            diff::Result::Left(str) => {
+            diff::Result::Left(s) => {
                 if lines_since_mismatch >= context_size && lines_since_mismatch > 0 {
                     results.push(mismatch);
                     mismatch = Mismatch::new(line_number - context_queue.len() as u32);
@@ -41,11 +41,11 @@ pub fn make_diff(expected: &str, actual: &str, context_size: usize) -> Vec<Misma
                     mismatch.lines.push(DiffLine::Context(line.to_owned()));
                 }
 
-                mismatch.lines.push(DiffLine::Expected(str.to_owned()));
+                mismatch.lines.push(DiffLine::Expected(s.to_owned()));
                 line_number += 1;
                 lines_since_mismatch = 0;
             }
-            diff::Result::Right(str) => {
+            diff::Result::Right(s) => {
                 if lines_since_mismatch >= context_size && lines_since_mismatch > 0 {
                     results.push(mismatch);
                     mismatch = Mismatch::new(line_number - context_queue.len() as u32);
@@ -55,18 +55,18 @@ pub fn make_diff(expected: &str, actual: &str, context_size: usize) -> Vec<Misma
                     mismatch.lines.push(DiffLine::Context(line.to_owned()));
                 }
 
-                mismatch.lines.push(DiffLine::Resulting(str.to_owned()));
+                mismatch.lines.push(DiffLine::Resulting(s.to_owned()));
                 lines_since_mismatch = 0;
             }
-            diff::Result::Both(str, _) => {
+            diff::Result::Both(s, _) => {
                 if context_queue.len() >= context_size {
                     let _ = context_queue.pop_front();
                 }
 
                 if lines_since_mismatch < context_size {
-                    mismatch.lines.push(DiffLine::Context(str.to_owned()));
+                    mismatch.lines.push(DiffLine::Context(s.to_owned()));
                 } else if context_size > 0 {
-                    context_queue.push_back(str);
+                    context_queue.push_back(s);
                 }
 
                 line_number += 1;

src/tools/rust-analyzer/crates/base-db/src/input.rs

@@ -262,11 +262,11 @@ impl ReleaseChannel {
     }
 
     #[allow(clippy::should_implement_trait)]
-    pub fn from_str(str: &str) -> Option<Self> {
-        Some(match str {
+    pub fn from_str(s: &str) -> Option<Self> {
+        Some(match s {
             "" | "stable" => ReleaseChannel::Stable,
             "nightly" => ReleaseChannel::Nightly,
-            _ if str.starts_with("beta") => ReleaseChannel::Beta,
+            _ if s.starts_with("beta") => ReleaseChannel::Beta,
             _ => return None,
         })
     }

src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs

@@ -173,7 +173,7 @@ fn is_argument_expr_similar_to_param_name(argument: &ast::Expr, param_name: &str
 /// whether param_name is a prefix/suffix of argument(split at `_`).
 pub(super) fn is_argument_similar_to_param_name(argument: &str, param_name: &str) -> bool {
     // std is honestly too panic happy...
-    let str_split_at = |str: &str, at| str.is_char_boundary(at).then(|| argument.split_at(at));
+    let str_split_at = |s: &str, at| s.is_char_boundary(at).then(|| argument.split_at(at));
 
     let param_name = param_name.trim_start_matches('_');
     let argument = argument.trim_start_matches('_');

src/tools/rust-analyzer/crates/vfs/src/vfs_path.rs

@@ -270,9 +270,9 @@ mod windows_paths {
     }
 
     #[cfg(test)]
-    fn vfs(str: &str) -> super::VfsPath {
+    fn vfs(s: &str) -> super::VfsPath {
         use super::{AbsPathBuf, VfsPath};
-        VfsPath::from(AbsPathBuf::try_from(str).unwrap())
+        VfsPath::from(AbsPathBuf::try_from(s).unwrap())
     }
 }