Fix order-dependent visibility diagnostics

SynapLink · SynapLink · commit 21b1458aceb8 · 2026-04-29T01:08:08.000+02:00
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -35,9 +35,10 @@ use crate::imports::{ImportData, ImportKind, OnUnknownData};
 use crate::macros::{MacroRulesDecl, MacroRulesScope, MacroRulesScopeRef};
 use crate::ref_mut::CmCell;
 use crate::{
-    BindingKey, Decl, DeclData, DeclKind, ExternModule, ExternPreludeEntry, Finalize, IdentKey,
-    LocalModule, MacroData, Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, Res,
-    Resolver, Segment, Used, VisResolutionError, errors,
+    BindingKey, Decl, DeclData, DeclKind, DelayedVisResolutionError, ExternModule,
+    ExternPreludeEntry, Finalize, IdentKey, LocalModule, MacroData, Module, ModuleKind,
+    ModuleOrUniformRoot, ParentScope, PathResult, Res, Resolver, Segment, Used, VisResolutionError,
+    errors,
 };
 
 impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
@@ -362,10 +363,54 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
     }
 
     fn resolve_visibility(&mut self, vis: &ast::Visibility) -> Visibility {
-        self.try_resolve_visibility(vis, true).unwrap_or_else(|err| {
-            self.r.report_vis_error(err);
-            Visibility::Public
-        })
+        match self.try_resolve_visibility(vis, true) {
+            Ok(vis) => vis,
+            Err(err) => {
+                if !self.delay_vis_resolution(vis) {
+                    self.r.report_vis_error(err);
+                }
+                Visibility::Public
+            }
+        }
+    }
+
+    fn visibility_path_segments<'ast>(
+        &self,
+        path: &'ast ast::Path,
+    ) -> Result<Vec<Segment>, VisResolutionError<'ast>> {
+        let ident = path.segments.get(0).expect("empty path in visibility").ident;
+        let crate_root = if ident.is_path_segment_keyword() {
+            None
+        } else if ident.span.is_rust_2015() {
+            Some(Segment::from_ident(Ident::new(
+                kw::PathRoot,
+                path.span.shrink_to_lo().with_ctxt(ident.span.ctxt()),
+            )))
+        } else {
+            return Err(VisResolutionError::Relative2018(ident.span, path));
+        };
+
+        Ok(crate_root
+            .into_iter()
+            .chain(path.segments.iter().map(|seg| seg.into()))
+            .collect::<Vec<_>>())
+    }
+
+    fn delay_vis_resolution(&mut self, vis: &ast::Visibility) -> bool {
+        let ast::VisibilityKind::Restricted { ref path, id, .. } = vis.kind else {
+            return false;
+        };
+        let Ok(segments) = self.visibility_path_segments(path) else {
+            return false;
+        };
+
+        self.r.delayed_vis_resolution_errors.push(DelayedVisResolutionError {
+            path: segments,
+            parent_scope: self.parent_scope,
+            id,
+            span: path.span,
+        });
+        true
     }
 
     fn try_resolve_visibility<'ast>(
@@ -395,22 +440,7 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
                 // paths" right now, so on 2018 edition we only allow module-relative paths for now.
                 // On 2015 edition visibilities are resolved as crate-relative by default,
                 // so we are prepending a root segment if necessary.
-                let ident = path.segments.get(0).expect("empty path in visibility").ident;
-                let crate_root = if ident.is_path_segment_keyword() {
-                    None
-                } else if ident.span.is_rust_2015() {
-                    Some(Segment::from_ident(Ident::new(
-                        kw::PathRoot,
-                        path.span.shrink_to_lo().with_ctxt(ident.span.ctxt()),
-                    )))
-                } else {
-                    return Err(VisResolutionError::Relative2018(ident.span, path));
-                };
-
-                let segments = crate_root
-                    .into_iter()
-                    .chain(path.segments.iter().map(|seg| seg.into()))
-                    .collect::<Vec<_>>();
+                let segments = self.visibility_path_segments(path)?;
                 let expected_found_error = |res| {
                     Err(VisResolutionError::ExpectedFound(
                         path.span,
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
@@ -48,10 +48,10 @@ use crate::imports::{Import, ImportKind};
 use crate::late::{DiagMetadata, PatternSource, Rib};
 use crate::{
     AmbiguityError, AmbiguityKind, AmbiguityWarning, BindingError, BindingKey, Decl, DeclKind,
-    Finalize, ForwardGenericParamBanReason, HasGenericParams, IdentKey, LateDecl, MacroRulesScope,
-    Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, PrivacyError, Res,
-    ResolutionError, Resolver, Scope, ScopeSet, Segment, UseError, Used, VisResolutionError,
-    errors as errs, path_names_to_string,
+    DelayedVisResolutionError, Finalize, ForwardGenericParamBanReason, HasGenericParams, IdentKey,
+    LateDecl, MacroRulesScope, Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult,
+    PrivacyError, Res, ResolutionError, Resolver, Scope, ScopeSet, Segment, UseError, Used,
+    VisResolutionError, errors as errs, path_names_to_string,
 };
 
 /// A vector of spans and replacements, a message and applicability.
@@ -137,6 +137,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     pub(crate) fn report_errors(&mut self, krate: &Crate) {
+        self.report_delayed_vis_resolution_errors();
         self.report_with_use_injections(krate);
 
         for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
@@ -178,6 +179,65 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
+    fn report_delayed_vis_resolution_errors(&mut self) {
+        for DelayedVisResolutionError { path, parent_scope, id, span } in
+            std::mem::take(&mut self.delayed_vis_resolution_errors)
+        {
+            let path_result = self.cm().resolve_path(
+                &path,
+                None,
+                &parent_scope,
+                Some(Finalize::new(id, span)),
+                None,
+                None,
+            );
+            match path_result {
+                PathResult::Module(ModuleOrUniformRoot::Module(module)) => {
+                    let res = module.res().expect("visibility resolved to unnamed block");
+                    if module.is_normal() {
+                        match res {
+                            Res::Err => {}
+                            _ => {
+                                let vis = Visibility::Restricted(res.def_id());
+                                if !self.is_accessible_from(vis, parent_scope.module) {
+                                    self.report_vis_error(VisResolutionError::AncestorOnly(span));
+                                }
+                            }
+                        }
+                    } else {
+                        self.report_vis_error(VisResolutionError::ExpectedFound(
+                            span,
+                            Segment::names_to_string(&path),
+                            res,
+                        ));
+                    }
+                }
+                PathResult::Module(..) => {
+                    self.report_vis_error(VisResolutionError::ModuleOnly(span));
+                }
+                PathResult::NonModule(partial_res) => {
+                    self.report_vis_error(VisResolutionError::ExpectedFound(
+                        span,
+                        Segment::names_to_string(&path),
+                        partial_res.expect_full_res(),
+                    ));
+                }
+                PathResult::Failed { span, segment_name, label, suggestion, message, .. } => {
+                    self.report_vis_error(VisResolutionError::FailedToResolve(
+                        span,
+                        segment_name,
+                        label,
+                        suggestion,
+                        message,
+                    ));
+                }
+                PathResult::Indeterminate => {
+                    self.report_vis_error(VisResolutionError::Indeterminate(span));
+                }
+            }
+        }
+    }
+
     fn report_with_use_injections(&mut self, krate: &Crate) {
         for UseError { mut err, candidates, def_id, instead, suggestion, path, is_call } in
             std::mem::take(&mut self.use_injections)
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -997,6 +997,14 @@ struct UseError<'a> {
     is_call: bool,
 }
 
+#[derive(Debug)]
+struct DelayedVisResolutionError<'ra> {
+    path: Vec<Segment>,
+    parent_scope: ParentScope<'ra>,
+    id: NodeId,
+    span: Span,
+}
+
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum AmbiguityKind {
     BuiltinAttr,
@@ -1351,6 +1359,8 @@ pub struct Resolver<'ra, 'tcx> {
     issue_145575_hack_applied: bool = false,
     /// `use` injections are delayed for better placement and deduplication.
     use_injections: Vec<UseError<'tcx>> = Vec::new(),
+    /// Visibility path resolution failures are delayed until all modules are collected.
+    delayed_vis_resolution_errors: Vec<DelayedVisResolutionError<'ra>> = Vec::new(),
     /// Crate-local macro expanded `macro_export` referred to by a module-relative path.
     macro_expanded_macro_export_errors: BTreeSet<(Span, Span)> = BTreeSet::new(),
 
diff --git a/tests/ui/privacy/restricted/relative-2018.stderr b/tests/ui/privacy/restricted/relative-2018.stderr
@@ -1,9 +1,3 @@
-error[E0742]: visibilities can only be restricted to ancestor modules
-  --> $DIR/relative-2018.rs:7:12
-   |
-LL |     pub(in ::core) struct S4;
-   |            ^^^^^^
-
 error: relative paths are not supported in visibilities in 2018 edition or later
   --> $DIR/relative-2018.rs:9:12
    |
@@ -12,6 +6,12 @@ LL |     pub(in a::b) struct S5;
    |            |
    |            help: try: `crate::a::b`
 
+error[E0742]: visibilities can only be restricted to ancestor modules
+  --> $DIR/relative-2018.rs:7:12
+   |
+LL |     pub(in ::core) struct S4;
+   |            ^^^^^^
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0742`.
diff --git a/tests/ui/privacy/restricted/test.stderr b/tests/ui/privacy/restricted/test.stderr
@@ -1,3 +1,15 @@
+error[E0364]: `f` is private, and cannot be re-exported
+  --> $DIR/test.rs:22:24
+   |
+LL |         pub(super) use foo::bar::f as g;
+   |                        ^^^^^^^^^^^^^^^^
+   |
+note: consider marking `f` as `pub` in the imported module
+  --> $DIR/test.rs:22:24
+   |
+LL |         pub(super) use foo::bar::f as g;
+   |                        ^^^^^^^^^^^^^^^^
+
 error[E0433]: cannot find module or crate `bad` in the crate root
   --> $DIR/test.rs:51:12
    |
@@ -15,18 +27,6 @@ error[E0742]: visibilities can only be restricted to ancestor modules
 LL |     pub(in foo) mod m2 {}
    |            ^^^
 
-error[E0364]: `f` is private, and cannot be re-exported
-  --> $DIR/test.rs:22:24
-   |
-LL |         pub(super) use foo::bar::f as g;
-   |                        ^^^^^^^^^^^^^^^^
-   |
-note: consider marking `f` as `pub` in the imported module
-  --> $DIR/test.rs:22:24
-   |
-LL |         pub(super) use foo::bar::f as g;
-   |                        ^^^^^^^^^^^^^^^^
-
 error[E0603]: struct `Crate` is private
   --> $DIR/test.rs:39:25
    |
diff --git a/tests/ui/resolve/resolve-bad-visibility.rs b/tests/ui/resolve/resolve-bad-visibility.rs
@@ -6,11 +6,9 @@ pub(in E) struct S; //~ ERROR expected module, found enum `::E`
 pub(in Tr) struct Z; //~ ERROR expected module, found trait `::Tr`
 pub(in std::vec) struct F; //~ ERROR visibilities can only be restricted to ancestor modules
 pub(in nonexistent) struct G; //~ ERROR cannot find
-pub(in too_soon) struct H; //~ ERROR cannot find
+pub(in too_soon) struct H; //~ ERROR visibilities can only be restricted
 
-// Visibilities are resolved eagerly without waiting for modules becoming fully populated.
-// Visibilities can only use ancestor modules legally which are always available in time,
-// so the worst thing that can happen due to eager resolution is a suboptimal error message.
+// The module exists, but it is not an ancestor module.
 mod too_soon {}
 
 fn main () {}
diff --git a/tests/ui/resolve/resolve-bad-visibility.stderr b/tests/ui/resolve/resolve-bad-visibility.stderr
@@ -27,16 +27,11 @@ help: you might be missing a crate named `nonexistent`, add it to your project a
 LL + extern crate nonexistent;
    |
 
-error[E0433]: cannot find module or crate `too_soon` in the crate root
+error[E0742]: visibilities can only be restricted to ancestor modules
   --> $DIR/resolve-bad-visibility.rs:9:8
    |
 LL | pub(in too_soon) struct H;
-   |        ^^^^^^^^ use of unresolved module or unlinked crate `too_soon`
-   |
-help: you might be missing a crate named `too_soon`, add it to your project and import it in your code
-   |
-LL + extern crate too_soon;
-   |
+   |        ^^^^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/resolve/visibility-indeterminate.stderr b/tests/ui/resolve/visibility-indeterminate.stderr
@@ -1,15 +1,15 @@
-error[E0433]: cannot find `bar` in the crate root
-  --> $DIR/visibility-indeterminate.rs:5:10
-   |
-LL | pub(in ::bar) struct Baz {}
-   |          ^^^ could not find `bar` in the list of imported crates
-
 error: cannot find macro `foo` in this scope
   --> $DIR/visibility-indeterminate.rs:3:1
    |
 LL | foo!();
    | ^^^
 
+error[E0433]: cannot find `bar` in the crate root
+  --> $DIR/visibility-indeterminate.rs:5:10
+   |
+LL | pub(in ::bar) struct Baz {}
+   |          ^^^ could not find `bar` in the list of imported crates
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/visibility-order-dependent.rs b/tests/ui/resolve/visibility-order-dependent.rs
@@ -0,0 +1,14 @@
+//@ edition: 2021
+// Regression test for <https://github.com/rust-lang/rust/issues/40066>.
+
+mod foo {
+    pub(in crate::bar) struct Foo;
+    //~^ ERROR visibilities can only be restricted to ancestor modules
+}
+
+mod bar {
+    pub(in crate::foo) struct Bar;
+    //~^ ERROR visibilities can only be restricted to ancestor modules
+}
+
+fn main() {}
diff --git a/tests/ui/resolve/visibility-order-dependent.stderr b/tests/ui/resolve/visibility-order-dependent.stderr
@@ -0,0 +1,15 @@
+error[E0742]: visibilities can only be restricted to ancestor modules
+  --> $DIR/visibility-order-dependent.rs:5:12
+   |
+LL |     pub(in crate::bar) struct Foo;
+   |            ^^^^^^^^^^
+
+error[E0742]: visibilities can only be restricted to ancestor modules
+  --> $DIR/visibility-order-dependent.rs:10:12
+   |
+LL |     pub(in crate::foo) struct Bar;
+   |            ^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0742`.
diff --git a/tests/ui/span/visibility-ty-params.stderr b/tests/ui/span/visibility-ty-params.stderr
@@ -4,18 +4,18 @@ error: unexpected generic arguments in path
 LL | m!{ crate::S<u8> }
    |             ^^^^
 
-error[E0433]: cannot find module `S` in `crate`
-  --> $DIR/visibility-ty-params.rs:6:12
-   |
-LL | m!{ crate::S<u8> }
-   |            ^ `S` is a struct, not a module
-
 error: unexpected generic arguments in path
   --> $DIR/visibility-ty-params.rs:10:17
    |
 LL |     m!{ crate::m<> }
    |                 ^^
 
+error[E0433]: cannot find module `S` in `crate`
+  --> $DIR/visibility-ty-params.rs:6:12
+   |
+LL | m!{ crate::S<u8> }
+   |            ^ `S` is a struct, not a module
+
 error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/use/use-self-type.stderr b/tests/ui/use/use-self-type.stderr
