update unimpl diagnostics, clippy lints

This adds a diagnostic name `string_in_global` so that clippy can easily
check for the alloc::string::String type alias.

Author: shua

compiler/rustc_span/src/symbol.rs

@@ -2192,6 +2192,7 @@ symbols! {
         string_as_str,
         string_deref_patterns,
         string_from_utf8,
+        string_in_global,
         string_insert_str,
         string_new,
         string_push_str,

library/core/src/convert/mod.rs

@@ -579,7 +579,7 @@ pub const trait Into<T>: Sized {
 #[rustc_diagnostic_item = "From"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_on_unimplemented(on(
-    all(Self = "&str", T = "alloc::string::String"),
+    all(Self = "&str", T = "alloc::string::generic::String<A>"),
     note = "to coerce a `{T}` into a `{Self}`, use `&*` as a prefix",
 ))]
 #[doc(search_unbox)]

library/core/src/iter/traits/collect.rs

@@ -261,7 +261,7 @@ pub trait FromIterator<A>: Sized {
     ),
     on(Self = "&str", label = "`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`"),
     on(
-        Self = "alloc::string::String",
+        Self = "alloc::string::generic::String<A>",
         label = "`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`"
     ),
     on(

library/core/src/ops/index.rs

@@ -155,7 +155,7 @@ see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#ind
 see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
     ),
     on(
-        Self = "alloc::string::String",
+        Self = "alloc::string::generic::String<A>",
         note = "you can use `.chars().nth()` or `.bytes().nth()`
 see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
     ),

library/core/src/slice/index.rs

@@ -151,7 +151,10 @@ mod private_slice_index {
 #[rustc_on_unimplemented(
     on(T = "str", label = "string indices are ranges of `usize`",),
     on(
-        all(any(T = "str", T = "&str", T = "alloc::string::String"), Self = "{integer}"),
+        all(
+            any(T = "str", T = "&str", T = "alloc::string::generic::String<A>"),
+            Self = "{integer}"
+        ),
         note = "you can use `.chars().nth()` or `.bytes().nth()`\n\
                 for more information, see chapter 8 in The Book: \
                 <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"

src/doc/rustc-dev-guide/src/diagnostics.md

@@ -955,7 +955,7 @@ You can match on the following names and values, using `name = "value"`:
  - `from_desugaring`: Match against a particular variant of the `DesugaringKind`
    enum. The desugaring is identified by its variant name, for example
    `"QuestionMark"` for `?` desugaring or `"TryBlock"` for `try` blocks.
- - `Self` and any generic arguments of the trait, like `Self = "alloc::string::String"`
+ - `Self` and any generic arguments of the trait, like `Self = "alloc::string::generic::String<A>"`
    or `Rhs="i32"`.
 
 The compiler can provide several values to match on, for example:
@@ -1007,7 +1007,7 @@ The `on` filter accepts `all`, `any` and `not` predicates similar to the `cfg` a
 
 ```rust,ignore
 #[rustc_on_unimplemented(on(
-    all(Self = "&str", T = "alloc::string::String"),
+    all(Self = "&str", T = "alloc::string::generic::String<A>"),
     note = "you can coerce a `{T}` into a `{Self}` by writing `&*variable`"
 ))]
 pub trait From<T>: Sized {

src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs

@@ -33,7 +33,7 @@ impl ArithmeticSideEffects {
         allowed_binary.extend([
             ("f32", FxHashSet::from_iter(["f32"])),
             ("f64", FxHashSet::from_iter(["f64"])),
-            ("std::string::String", FxHashSet::from_iter(["str"])),
+            ("std::string::generic::String", FxHashSet::from_iter(["str"])),
         ]);
         for (lhs, rhs) in &conf.arithmetic_side_effects_allowed_binary {
             allowed_binary.entry(lhs).or_default().insert(rhs);

src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs

@@ -25,11 +25,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// let foo: String = String::new();
+    /// let foo: u64 = u64::MAX;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let foo = String::new();
+    /// let foo = u64::MAX;
     /// ```
     #[clippy::version = "1.72.0"]
     pub REDUNDANT_TYPE_ANNOTATIONS,

src/tools/clippy/clippy_lints/src/types/box_collection.rs

@@ -13,9 +13,13 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         && let Some(item_type) = get_std_collection(cx, qpath)
     {
         let generic = match item_type {
-            sym::String => "",
+            sym::string_in_global => "",
             _ => "<..>",
         };
+        let item_type = match item_type {
+            sym::string_in_global => sym::String,
+            _ => item_type,
+        };
 
         let box_content = format!("{item_type}{generic}");
         span_lint_and_help(
@@ -48,6 +52,7 @@ fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Symbol>
                     | sym::BTreeMap
                     | sym::BTreeSet
                     | sym::BinaryHeap
+                    | sym::string_in_global,
             )
         })
         .or_else(|| {

src/tools/clippy/clippy_lints/src/types/owned_cow.rs

@@ -31,7 +31,9 @@ pub(super) fn check(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, def_id: DefId)
 }
 
 fn replacement(cx: &LateContext<'_>, cty: &hir::Ty<'_>) -> Option<(Span, String)> {
-    if cty.basic_res().is_lang_item(cx, hir::LangItem::String) {
+    if cty.basic_res().is_lang_item(cx, hir::LangItem::String)
+        || cty.basic_res().is_diag_item(cx, sym::string_in_global)
+    {
         return Some((cty.span, "str".into()));
     }
     if cty.basic_res().is_diag_item(cx, sym::Vec) {