Unify wording of resolve error

Remove "failed to resolve" and use the same format we use in other resolution errors "cannot find `name`".

```
error[E0433]: cannot find `nonexistent` in `existent`
  --> $DIR/custom_attr_multisegment_error.rs:5:13
   |
LL | #[existent::nonexistent]
   |             ^^^^^^^^^^^ could not find `nonexistent` in `existent`
```

Author: estebank

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -406,8 +406,14 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     PathResult::NonModule(partial_res) => {
                         expected_found_error(partial_res.expect_full_res())
                     }
-                    PathResult::Failed { span, label, suggestion, .. } => {
-                        Err(VisResolutionError::FailedToResolve(span, label, suggestion))
+                    PathResult::Failed { span, label, suggestion, scope, segment_name, .. } => {
+                        Err(VisResolutionError::FailedToResolve(
+                            span,
+                            segment_name,
+                            label,
+                            suggestion,
+                            scope,
+                        ))
                     }
                     PathResult::Indeterminate => Err(VisResolutionError::Indeterminate(path.span)),
                 }

compiler/rustc_resolve/src/diagnostics.rs

@@ -788,9 +788,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ResolutionError::SelfImportOnlyInImportListWithNonEmptyPrefix => {
                 self.dcx().create_err(errs::SelfImportOnlyInImportListWithNonEmptyPrefix { span })
             }
-            ResolutionError::FailedToResolve { segment, label, suggestion, module } => {
-                let mut err =
-                    struct_span_code_err!(self.dcx(), span, E0433, "failed to resolve: {label}");
+            ResolutionError::FailedToResolve { segment, label, suggestion, module, scope } => {
+                let mut err = struct_span_code_err!(
+                    self.dcx(),
+                    span,
+                    E0433,
+                    "cannot find `{segment}` in {scope}"
+                );
                 err.span_label(span, label);
 
                 if let Some((suggestions, msg, applicability)) = suggestion {
@@ -801,13 +805,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     err.multipart_suggestion(msg, suggestions, applicability);
                 }
 
-                if let Some(segment) = segment {
-                    let module = match module {
-                        Some(ModuleOrUniformRoot::Module(m)) if let Some(id) = m.opt_def_id() => id,
-                        _ => CRATE_DEF_ID.to_def_id(),
-                    };
-                    self.find_cfg_stripped(&mut err, &segment, module);
-                }
+                let module = match module {
+                    Some(ModuleOrUniformRoot::Module(m)) if let Some(id) = m.opt_def_id() => id,
+                    _ => CRATE_DEF_ID.to_def_id(),
+                };
+                self.find_cfg_stripped(&mut err, &segment, module);
 
                 err
             }
@@ -1001,10 +1003,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             VisResolutionError::AncestorOnly(span) => {
                 self.dcx().create_err(errs::AncestorOnly(span))
             }
-            VisResolutionError::FailedToResolve(span, label, suggestion) => self.into_struct_error(
-                span,
-                ResolutionError::FailedToResolve { segment: None, label, suggestion, module: None },
-            ),
+            VisResolutionError::FailedToResolve(span, segment, label, suggestion, scope) => self
+                .into_struct_error(
+                    span,
+                    ResolutionError::FailedToResolve {
+                        segment,
+                        label,
+                        suggestion,
+                        module: None,
+                        scope,
+                    },
+                ),
             VisResolutionError::ExpectedFound(span, path_str, res) => {
                 self.dcx().create_err(errs::ExpectedModuleFound { span, res, path_str })
             }

compiler/rustc_resolve/src/ident.rs

@@ -1515,6 +1515,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             allow_super &= ns == TypeNS && (name == kw::SelfLower || name == kw::Super);
 
+            let scope = match &path[..segment_idx] {
+                [.., prev] => {
+                    if prev.ident.name == kw::PathRoot {
+                        format!("the crate root")
+                    } else {
+                        format!("`{}`", prev.ident)
+                    }
+                }
+                _ => format!("this scope"),
+            };
             if ns == TypeNS {
                 if allow_super && name == kw::Super {
                     let mut ctxt = ident.span.ctxt().normalize_to_macros_2_0();
@@ -1538,6 +1548,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         finalize.is_some(),
                         module_had_parse_errors,
                         module,
+                        scope,
                         || ("there are too many leading `super` keywords".to_string(), None),
                     );
                 }
@@ -1584,6 +1595,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     finalize.is_some(),
                     module_had_parse_errors,
                     module,
+                    scope,
                     || {
                         let name_str = if name == kw::PathRoot {
                             "crate root".to_string()
@@ -1707,6 +1719,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             finalize.is_some(),
                             module_had_parse_errors,
                             module,
+                            scope,
                             || {
                                 let label = format!(
                                     "`{ident}` is {} {}, not a module",
@@ -1737,6 +1750,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         finalize.is_some(),
                         module_had_parse_errors,
                         module,
+                        scope,
                         || {
                             this.get_mut().report_path_resolution_error(
                                 path,

compiler/rustc_resolve/src/imports.rs

@@ -997,16 +997,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 suggestion,
                 module,
                 error_implied_by_parse_error: _,
+                scope,
             } => {
                 if no_ambiguity {
                     assert!(import.imported_module.get().is_none());
                     self.report_error(
                         span,
                         ResolutionError::FailedToResolve {
-                            segment: Some(segment_name),
+                            segment: segment_name,
                             label,
                             suggestion,
                             module,
+                            scope,
                         },
                     );
                 }

compiler/rustc_resolve/src/late.rs

@@ -4606,14 +4606,16 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 module,
                 segment_name,
                 error_implied_by_parse_error: _,
+                scope,
             } => {
                 return Err(respan(
                     span,
                     ResolutionError::FailedToResolve {
-                        segment: Some(segment_name),
+                        segment: segment_name,
                         label,
                         suggestion,
                         module,
+                        scope,
                     },
                 ));
             }

compiler/rustc_resolve/src/lib.rs

@@ -268,10 +268,11 @@ enum ResolutionError<'ra> {
     SelfImportOnlyInImportListWithNonEmptyPrefix,
     /// Error E0433: failed to resolve.
     FailedToResolve {
-        segment: Option<Symbol>,
+        segment: Symbol,
         label: String,
         suggestion: Option<Suggestion>,
         module: Option<ModuleOrUniformRoot<'ra>>,
+        scope: String,
     },
     /// Error E0434: can't capture dynamic environment in a fn item.
     CannotCaptureDynamicEnvironmentInFnItem,
@@ -330,7 +331,7 @@ enum ResolutionError<'ra> {
 enum VisResolutionError<'a> {
     Relative2018(Span, &'a ast::Path),
     AncestorOnly(Span),
-    FailedToResolve(Span, String, Option<Suggestion>),
+    FailedToResolve(Span, Symbol, String, Option<Suggestion>, String),
     ExpectedFound(Span, String, Res),
     Indeterminate(Span),
     ModuleOnly(Span),
@@ -475,6 +476,7 @@ enum PathResult<'ra> {
         /// The segment name of target
         segment_name: Symbol,
         error_implied_by_parse_error: bool,
+        scope: String,
     },
 }
 
@@ -485,6 +487,7 @@ impl<'ra> PathResult<'ra> {
         finalize: bool,
         error_implied_by_parse_error: bool,
         module: Option<ModuleOrUniformRoot<'ra>>,
+        scope: String,
         label_and_suggestion: impl FnOnce() -> (String, Option<Suggestion>),
     ) -> PathResult<'ra> {
         let (label, suggestion) =
@@ -497,6 +500,7 @@ impl<'ra> PathResult<'ra> {
             is_error_from_last_segment,
             module,
             error_implied_by_parse_error,
+            scope,
         }
     }
 }

compiler/rustc_resolve/src/macros.rs

@@ -899,6 +899,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 ),
                 path_res @ (PathResult::NonModule(..) | PathResult::Failed { .. }) => {
                     let mut suggestion = None;
+                    let scope = match path_res {
+                        PathResult::Failed { ref scope, .. } => scope.clone(),
+                        PathResult::NonModule(partial_res) => {
+                            match &path[..partial_res.unresolved_segments()] {
+                                [.., prev] => format!("`{}`", prev.ident),
+                                _ => "this scope".to_string(),
+                            }
+                        }
+                        _ => "this scope".to_string(),
+                    };
                     let (span, label, module, segment) =
                         if let PathResult::Failed { span, label, module, segment_name, .. } =
                             path_res
@@ -937,10 +947,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     self.report_error(
                         span,
                         ResolutionError::FailedToResolve {
-                            segment: Some(segment),
+                            segment,
                             label,
                             suggestion,
                             module,
+                            scope,
                         },
                     );
                 }

tests/rustdoc-ui/issues/issue-61732.rs

@@ -1,4 +1,4 @@
 // This previously triggered an ICE.
 
 pub(in crate::r#mod) fn main() {}
-//~^ ERROR failed to resolve: use of unresolved module or unlinked crate `r#mod`
+//~^ ERROR cannot find `mod` in `crate`

tests/rustdoc-ui/issues/issue-61732.stderr

@@ -1,4 +1,4 @@
-error[E0433]: failed to resolve: use of unresolved module or unlinked crate `r#mod`
+error[E0433]: cannot find `mod` in `crate`
   --> $DIR/issue-61732.rs:3:15
    |
 LL | pub(in crate::r#mod) fn main() {}

tests/ui/asm/naked-invalid-attr.rs

@@ -55,7 +55,7 @@ fn main() {
 // Check that the path of an attribute without a name is printed correctly (issue #140082)
 #[::a]
 //~^ ERROR attribute incompatible with `#[unsafe(naked)]`
-//~| ERROR failed to resolve: use of unresolved module or unlinked crate `a`
+//~| ERROR cannot find `a` in the crate root
 #[unsafe(naked)]
 extern "C" fn issue_140082() {
     naked_asm!("")