Merge redundant error codes E0412 and E0425

E0412 ("type name is not in scope") and E0425 ("unresolved name")
convey essentially the same information to users - that an identifier
cannot be found in the current scope. The only difference was that
E0412 was used for type positions while E0425 was used for value/
expression positions. This distinction was not meaningful to users.

This commit merges E0412 into E0425, making E0425 the unified error
code for all unresolved name errors regardless of position.

Changes made:
- Updated error code mapping in rustc_resolve to use E0425 for both
  type and expression positions
- Updated diagnostic handling code and comments to reflect the merge
- Marked E0412 documentation as no longer emitted, noting it has been
  merged into E0425
- Enhanced E0425 documentation to include type resolution examples
- Updated all test files and expected outputs to use E0425 instead of
  E0412

Author: politikl

compiler/rustc_error_codes/src/error_codes/E0412.md

@@ -1,8 +1,12 @@
+#### Note: this error code is no longer emitted by the compiler.
+
+This error has been merged into E0425.
+
 A used type name is not in scope.
 
 Erroneous code examples:
 
-```compile_fail,E0412
+```compile_fail,E0425
 impl Something {} // error: type name `Something` is not in scope
 
 // or:
@@ -42,7 +46,7 @@ module. To fix this, you can follow the suggestion and use File directly or
 `use super::File;` which will import the types from the parent namespace. An
 example that causes this error is below:
 
-```compile_fail,E0412
+```compile_fail,E0425
 use std::fs::File;
 
 mod foo {

compiler/rustc_error_codes/src/error_codes/E0425.md

@@ -17,6 +17,14 @@ trait Foo {
 // or:
 
 let x = unknown_variable;  // error: unresolved name `unknown_variable`
+
+// or:
+
+impl Something {} // error: type name `Something` is not in scope
+
+// or:
+
+fn foo(x: T) {} // error: type name `T` is not in scope
 ```
 
 Please verify that the name wasn't misspelled and ensure that the
@@ -45,6 +53,18 @@ let unknown_variable = 12u32;
 let x = unknown_variable; // ok!
 ```
 
+Or for types:
+
+```
+struct Something;
+
+impl Something {} // ok!
+
+// or:
+
+fn foo<T>(x: T) {} // ok!
+```
+
 If the item is not defined in the current module, it must be imported using a
 `use` statement, like so:
 

compiler/rustc_error_codes/src/lib.rs

@@ -607,7 +607,7 @@ E0805: 0805,
 //  E0246, // invalid recursive type
 //  E0247,
 //  E0248, // value used as a type, now reported earlier during resolution
-//         // as E0412
+//         // as E0425
 //  E0249,
 //  E0257,
 //  E0258,

compiler/rustc_resolve/src/late.rs

@@ -622,7 +622,7 @@ impl PathSource<'_, '_, '_> {
             (PathSource::Trait(_), true) => E0404,
             (PathSource::Trait(_), false) => E0405,
             (PathSource::Type | PathSource::DefineOpaques, true) => E0573,
-            (PathSource::Type | PathSource::DefineOpaques, false) => E0412,
+            (PathSource::Type | PathSource::DefineOpaques, false) => E0425,
             (PathSource::Struct(_), true) => E0574,
             (PathSource::Struct(_), false) => E0422,
             (PathSource::Expr(..), true) | (PathSource::Delegation, true) => E0423,
@@ -3161,7 +3161,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         result
     }
 
-    /// When evaluating a `trait` use its associated types' idents for suggestions in E0412.
+    /// When evaluating a `trait` use its associated types' idents for suggestions in E0425.
     fn resolve_trait_items(&mut self, trait_items: &'ast [Box<AssocItem>]) {
         let trait_assoc_items =
             replace(&mut self.diag_metadata.current_trait_assoc_items, Some(trait_items));
@@ -4362,15 +4362,15 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
                 // There are two different error messages user might receive at
                 // this point:
-                // - E0412 cannot find type `{}` in this scope
+                // - E0425 cannot find value `{}` in this scope
                 // - E0433 failed to resolve: use of undeclared type or module `{}`
                 //
-                // The first one is emitted for paths in type-position, and the
-                // latter one - for paths in expression-position.
+                // The first one is emitted for unresolved names, and the
+                // latter one - for paths in use statements.
                 //
                 // Thus (since we're in expression-position at this point), not to
                 // confuse the user, we want to keep the *message* from E0433 (so
-                // `parent_err`), but we want *hints* from E0412 (so `err`).
+                // `parent_err`), but we want *hints* from E0425 (so `err`).
                 //
                 // And that's what happens below - we're just mixing both messages
                 // into a single one.

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -705,7 +705,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             if !enum_candidates.is_empty() {
                 enum_candidates.sort();
 
-                // Contextualize for E0412 "cannot find type", but don't belabor the point
+                // Contextualize for E0425 "cannot find value", but don't belabor the point
                 // (that it's a variant) for E0573 "expected type, found variant".
                 let preamble = if res.is_none() {
                     let others = match enum_candidates.len() {
@@ -1127,7 +1127,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 }
 
                 self.suggest_ident_hidden_by_hygiene(err, path, span);
-            } else if err_code == E0412 {
+            } else if err_code == E0425 {
                 if let Some(correct) = Self::likely_rust_type(path) {
                     err.span_suggestion(
                         span,

tests/rustdoc-ui/impl-fn-nesting.stderr

@@ -10,7 +10,7 @@ error[E0405]: cannot find trait `UnknownBound` in this scope
 LL | pub fn f<B: UnknownBound>(a: UnknownType, b: B) {
    |             ^^^^^^^^^^^^ not found in this scope
 
-error[E0412]: cannot find type `UnknownType` in this scope
+error[E0425]: cannot find type `UnknownType` in this scope
   --> $DIR/impl-fn-nesting.rs:11:30
    |
 LL | pub fn f<B: UnknownBound>(a: UnknownType, b: B) {
@@ -34,7 +34,7 @@ error[E0405]: cannot find trait `UnknownBound` in this scope
 LL |     impl<T: UnknownBound> UnknownTrait for T {}
    |             ^^^^^^^^^^^^ not found in this scope
 
-error[E0412]: cannot find type `UnknownType` in this scope
+error[E0425]: cannot find type `UnknownType` in this scope
   --> $DIR/impl-fn-nesting.rs:18:25
    |
 LL |     impl ValidTrait for UnknownType {}
@@ -46,19 +46,19 @@ error[E0405]: cannot find trait `UnknownBound` in this scope
 LL |     impl ValidTrait for ValidType where ValidTrait: UnknownBound {}
    |                                                     ^^^^^^^^^^^^ not found in this scope
 
-error[E0412]: cannot find type `UnknownType` in this scope
+error[E0425]: cannot find type `UnknownType` in this scope
   --> $DIR/impl-fn-nesting.rs:25:21
    |
 LL |         type Item = UnknownType;
    |                     ^^^^^^^^^^^ not found in this scope
 
-error[E0412]: cannot find type `UnknownType` in this scope
+error[E0425]: cannot find type `UnknownType` in this scope
   --> $DIR/impl-fn-nesting.rs:44:37
    |
 LL |             pub fn doubly_nested(c: UnknownType) {
    |                                     ^^^^^^^^^^^ not found in this scope
 
 error: aborting due to 10 previous errors
 
-Some errors have detailed explanations: E0405, E0412.
+Some errors have detailed explanations: E0405, E0425.
 For more information about an error, try `rustc --explain E0405`.

tests/ui/annotate-snippet/missing-type.stderr

@@ -1,4 +1,4 @@
-error[E0412]: cannot find type `Iter` in this scope
+error[E0425]: cannot find type `Iter` in this scope
   --> $DIR/missing-type.rs:4:12
    |
 LL |     let x: Iter;
@@ -18,4 +18,4 @@ LL + use std::collections::hash_map::Iter;
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0412`.
+For more information about this error, try `rustc --explain E0425`.

tests/ui/argument-suggestions/extern-fn-arg-names.stderr

@@ -1,4 +1,4 @@
-error[E0412]: cannot find type `err` in this scope
+error[E0425]: cannot find type `err` in this scope
   --> $DIR/extern-fn-arg-names.rs:2:29
    |
 LL |     fn dstfn(src: i32, dst: err);
@@ -22,5 +22,5 @@ LL |     dstfn(1, /* dst */);
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0061, E0412.
+Some errors have detailed explanations: E0061, E0425.
 For more information about an error, try `rustc --explain E0061`.

tests/ui/argument-suggestions/issue-109831.rs

@@ -1,7 +1,7 @@
 struct A;
 struct B;
 
-fn f(b1: B, b2: B, a2: C) {} //~ ERROR E0412
+fn f(b1: B, b2: B, a2: C) {} //~ ERROR E0425
 
 fn main() {
     f(A, A, B, C); //~ ERROR E0425

tests/ui/argument-suggestions/issue-109831.stderr

@@ -1,4 +1,4 @@
-error[E0412]: cannot find type `C` in this scope
+error[E0425]: cannot find type `C` in this scope
   --> $DIR/issue-109831.rs:4:24
    |
 LL | struct A;
@@ -48,5 +48,5 @@ LL +     f(/* B */, /* B */, B);
 
 error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0061, E0412, E0425.
+Some errors have detailed explanations: E0061, E0425, E0425.
 For more information about an error, try `rustc --explain E0061`.