Add field module.unresolved_invocations.

Author: jseyfried

src/librustc_resolve/build_reduced_graph.rs

@@ -638,7 +638,9 @@ pub struct BuildReducedGraphVisitor<'a, 'b: 'a> {
 
 impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
     fn visit_invoc(&mut self, id: ast::NodeId) -> &'b InvocationData<'b> {
-        let invocation = self.resolver.invocations[&Mark::from_placeholder_id(id)];
+        let mark = Mark::from_placeholder_id(id);
+        self.resolver.current_module.unresolved_invocations.borrow_mut().insert(mark);
+        let invocation = self.resolver.invocations[&mark];
         invocation.module.set(self.resolver.current_module);
         invocation.legacy_scope.set(self.legacy_scope);
         invocation

src/librustc_resolve/lib.rs

@@ -799,6 +799,9 @@ pub struct ModuleS<'a> {
 
     resolutions: RefCell<FxHashMap<(Name, Namespace), &'a RefCell<NameResolution<'a>>>>,
 
+    // Macro invocations that can expand into items in this module.
+    unresolved_invocations: RefCell<FxHashSet<Mark>>,
+
     no_implicit_prelude: bool,
 
     glob_importers: RefCell<Vec<&'a ImportDirective<'a>>>,
@@ -822,6 +825,7 @@ impl<'a> ModuleS<'a> {
             kind: kind,
             normal_ancestor_id: None,
             resolutions: RefCell::new(FxHashMap()),
+            unresolved_invocations: RefCell::new(FxHashSet()),
             no_implicit_prelude: false,
             glob_importers: RefCell::new(Vec::new()),
             globs: RefCell::new((Vec::new())),

src/librustc_resolve/macros.rs

@@ -131,6 +131,7 @@ impl<'a> base::Resolver for Resolver<'a> {
         self.collect_def_ids(invocation, expansion);
 
         self.current_module = invocation.module.get();
+        self.current_module.unresolved_invocations.borrow_mut().remove(&mark);
         let mut visitor = BuildReducedGraphVisitor {
             resolver: self,
             legacy_scope: LegacyScope::Invocation(invocation),

src/librustc_resolve/resolve_imports.rs

@@ -192,7 +192,7 @@ impl<'a> Resolver<'a> {
         }
 
         // If the resolution doesn't depend on glob definability, check privacy and return.
-        if let Some(result) = self.try_result(&resolution, ns) {
+        if let Some(result) = self.try_result(&resolution, module, ns) {
             return result.and_then(|binding| {
                 if self.is_accessible(binding.vis) && !is_disallowed_private_import(binding) ||
                    binding.is_extern_crate() { // c.f. issue #37020
@@ -222,7 +222,7 @@ impl<'a> Resolver<'a> {
 
     // Returns Some(the resolution of the name), or None if the resolution depends
     // on whether more globs can define the name.
-    fn try_result(&mut self, resolution: &NameResolution<'a>, ns: Namespace)
+    fn try_result(&mut self, resolution: &NameResolution<'a>, module: Module<'a>, ns: Namespace)
                   -> Option<ResolveResult<&'a NameBinding<'a>>> {
         match resolution.binding {
             Some(binding) if !binding.is_glob_import() =>
@@ -250,6 +250,10 @@ impl<'a> Resolver<'a> {
             SingleImports::MaybeOne(_) | SingleImports::None => {},
         }
 
+        if !module.unresolved_invocations.borrow().is_empty() {
+            return Some(Indeterminate);
+        }
+
         resolution.binding.map(Success)
     }