Convert impossible cases in macro resolution into assertions

Author: yaahc

compiler/rustc_resolve/src/ident.rs

@@ -3,7 +3,7 @@ use Namespace::*;
 use rustc_ast::{self as ast, NodeId};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, MacroKinds, Namespace, NonMacroAttrKind, PartialRes, PerNS};
-use rustc_middle::bug;
+use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK;
 use rustc_session::parse::feature_err;
 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext};
@@ -677,14 +677,21 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                         innermost_binding,
                                         binding,
                                     )
-                                    || flags.contains(Flags::MACRO_RULES)
-                                        && innermost_flags.contains(Flags::MODULE)
-                                        && !this.disambiguate_macro_rules_vs_modularized(
-                                            binding,
-                                            innermost_binding,
-                                        )
                                 {
                                     Some(AmbiguityKind::MacroRulesVsModularized)
+                                } else if flags.contains(Flags::MACRO_RULES)
+                                    && innermost_flags.contains(Flags::MODULE)
+                                {
+                                    // should be impossible because of visitation order in
+                                    // visit_scopes
+                                    //
+                                    // we visit all macro_rules scopes (e.g. textual scope macros)
+                                    // before we visit any modules (e.g. path-based scope macros)
+                                    span_bug!(
+                                        orig_ident.span,
+                                        "ambiguous scoped macro resolutions with path-based \
+                                        scope resolution as first candidate"
+                                    )
                                 } else if innermost_binding.is_glob_import() {
                                     Some(AmbiguityKind::GlobVsOuter)
                                 } else if innermost_binding

compiler/rustc_resolve/src/lib.rs

@@ -1198,28 +1198,28 @@ pub struct Resolver<'ra, 'tcx> {
     // FIXME: Remove interior mutability when speculative resolution produces these as outputs.
     single_segment_macro_resolutions:
         RefCell<Vec<(Ident, MacroKind, ParentScope<'ra>, Option<NameBinding<'ra>>, Option<Span>)>>,
-    multi_segment_macro_resolutions:
-        RefCell<Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'ra>, Option<Res>, Namespace)>>,
-    builtin_attrs: Vec<(Ident, ParentScope<'ra>)>,
-    /// `derive(Copy)` marks items they are applied to so they are treated specially later.
-    /// Derive macros cannot modify the item themselves and have to store the markers in the global
-    /// context, so they attach the markers to derive container IDs using this resolver table.
-    containers_deriving_copy: FxHashSet<LocalExpnId>,
-    /// Parent scopes in which the macros were invoked.
-    /// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere.
-    invocation_parent_scopes: FxHashMap<LocalExpnId, ParentScope<'ra>>,
-    /// `macro_rules` scopes *produced* by expanding the macro invocations,
-    /// include all the `macro_rules` items and other invocations generated by them.
-    output_macro_rules_scopes: FxHashMap<LocalExpnId, MacroRulesScopeRef<'ra>>,
-    /// `macro_rules` scopes produced by `macro_rules` item definitions.
-    macro_rules_scopes: FxHashMap<LocalDefId, MacroRulesScopeRef<'ra>>,
-    /// Helper attributes that are in scope for the given expansion.
-    helper_attrs: FxHashMap<LocalExpnId, Vec<(Ident, NameBinding<'ra>)>>,
-    /// Ready or in-progress results of resolving paths inside the `#[derive(...)]` attribute
-    /// with the given `ExpnId`.
-    derive_data: FxHashMap<LocalExpnId, DeriveData>,
-
-    /// Avoid duplicated errors for "name already defined".
+        multi_segment_macro_resolutions:
+            RefCell<Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'ra>, Option<Res>, Namespace)>>,
+            builtin_attrs: Vec<(Ident, ParentScope<'ra>)>,
+            /// `derive(Copy)` marks items they are applied to so they are treated specially later.
+            /// Derive macros cannot modify the item themselves and have to store the markers in the global
+            /// context, so they attach the markers to derive container IDs using this resolver table.
+            containers_deriving_copy: FxHashSet<LocalExpnId>,
+            /// Parent scopes in which the macros were invoked.
+            /// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere.
+            invocation_parent_scopes: FxHashMap<LocalExpnId, ParentScope<'ra>>,
+            /// `macro_rules` scopes *produced* by expanding the macro invocations,
+            /// include all the `macro_rules` items and other invocations generated by them.
+            output_macro_rules_scopes: FxHashMap<LocalExpnId, MacroRulesScopeRef<'ra>>,
+            /// `macro_rules` scopes produced by `macro_rules` item definitions.
+            macro_rules_scopes: FxHashMap<LocalDefId, MacroRulesScopeRef<'ra>>,
+            /// Helper attributes that are in scope for the given expansion.
+            helper_attrs: FxHashMap<LocalExpnId, Vec<(Ident, NameBinding<'ra>)>>,
+            /// Ready or in-progress results of resolving paths inside the `#[derive(...)]` attribute
+            /// with the given `ExpnId`.
+            derive_data: FxHashMap<LocalExpnId, DeriveData>,
+
+            /// Avoid duplicated errors for "name already defined".
     name_already_seen: FxHashMap<Symbol, Span>,
 
     potentially_unused_imports: Vec<Import<'ra>> = Vec::new(),
@@ -2226,16 +2226,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Some non-controversial subset of ambiguities "modularized macro name" vs "macro_rules"
         // is disambiguated to mitigate regressions from macro modularization.
         // Scoping for `macro_rules` behaves like scoping for `let` at module level, in general.
-        match (
-            self.binding_parent_modules.get(&macro_rules),
-            self.binding_parent_modules.get(&modularized),
-        ) {
-            (Some(macro_rules), Some(modularized)) => {
-                macro_rules.nearest_parent_mod() == modularized.nearest_parent_mod()
-                    && modularized.is_ancestor_of(*macro_rules)
-            }
-            _ => false,
-        }
+        //
+        // panic on index should be impossible, the only name_bindings passed in should be from
+        // `resolve_ident_in_scope_set` which will always refer to a local binding from an
+        // import or macro definition
+        let macro_rules = &self.binding_parent_modules[&macro_rules];
+        let modularized = &self.binding_parent_modules[&modularized];
+        macro_rules.nearest_parent_mod() == modularized.nearest_parent_mod()
+            && modularized.is_ancestor_of(*macro_rules)
     }
 
     fn extern_prelude_get_item<'r>(