resolve: Support resolving macros without leaving traces

src/librustc_resolve/macros.rs

@@ -327,7 +327,7 @@ impl<'a, 'crateloader: 'a> base::Resolver for Resolver<'a, 'crateloader> {
         };
 
         let parent_scope = self.invoc_parent_scope(invoc_id, derives_in_scope);
-        let (def, ext) = self.resolve_macro_to_def(path, kind, &parent_scope, force)?;
+        let (def, ext) = self.resolve_macro_to_def(path, kind, &parent_scope, true, force)?;
 
         if let Def::Macro(def_id, _) = def {
             if after_derive {
@@ -350,7 +350,7 @@ impl<'a, 'crateloader: 'a> base::Resolver for Resolver<'a, 'crateloader> {
                           derives_in_scope: Vec<ast::Path>, force: bool)
                           -> Result<Lrc<SyntaxExtension>, Determinacy> {
         let parent_scope = self.invoc_parent_scope(invoc_id, derives_in_scope);
-        Ok(self.resolve_macro_to_def(path, kind, &parent_scope, force)?.1)
+        Ok(self.resolve_macro_to_def(path, kind, &parent_scope, false, force)?.1)
     }
 
     fn check_unused_macros(&self) {
@@ -391,9 +391,10 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         path: &ast::Path,
         kind: MacroKind,
         parent_scope: &ParentScope<'a>,
+        trace: bool,
         force: bool,
     ) -> Result<(Def, Lrc<SyntaxExtension>), Determinacy> {
-        let def = self.resolve_macro_to_def_inner(path, kind, parent_scope, force);
+        let def = self.resolve_macro_to_def_inner(path, kind, parent_scope, trace, force);
 
         // Report errors and enforce feature gates for the resolved macro.
         if def != Err(Determinacy::Undetermined) {
@@ -465,6 +466,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         path: &ast::Path,
         kind: MacroKind,
         parent_scope: &ParentScope<'a>,
+        trace: bool,
         force: bool,
     ) -> Result<Def, Determinacy> {
         let path_span = path.span;
@@ -492,8 +494,10 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                 PathResult::Module(..) => unreachable!(),
             };
 
-            parent_scope.module.multi_segment_macro_resolutions.borrow_mut()
-                .push((path, path_span, kind, parent_scope.clone(), def.ok()));
+            if trace {
+                parent_scope.module.multi_segment_macro_resolutions.borrow_mut()
+                    .push((path, path_span, kind, parent_scope.clone(), def.ok()));
+            }
 
             def
         } else {
@@ -506,8 +510,10 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                 Err(Determinacy::Undetermined) => return Err(Determinacy::Undetermined),
             }
 
-            parent_scope.module.single_segment_macro_resolutions.borrow_mut()
-                .push((path[0].ident, kind, parent_scope.clone(), binding.ok()));
+            if trace {
+                parent_scope.module.single_segment_macro_resolutions.borrow_mut()
+                    .push((path[0].ident, kind, parent_scope.clone(), binding.ok()));
+            }
 
             binding.map(|binding| binding.def_ignoring_ambiguity())
         }
@@ -634,7 +640,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     for derive in &parent_scope.derives {
                         let parent_scope = ParentScope { derives: Vec::new(), ..*parent_scope };
                         match self.resolve_macro_to_def(derive, MacroKind::Derive,
-                                                        &parent_scope, force) {
+                                                        &parent_scope, true, force) {
                             Ok((_, ext)) => {
                                 if let SyntaxExtension::ProcMacroDerive(_, helpers, _) = &*ext {
                                     if helpers.contains(&ident.name) {

src/librustdoc/passes/collect_intra_doc_links.rs

@@ -477,7 +477,7 @@ fn macro_resolve(cx: &DocContext, path_str: &str) -> Option<Def> {
     let mut resolver = cx.resolver.borrow_mut();
     let parent_scope = resolver.dummy_parent_scope();
     if let Ok(def) = resolver.resolve_macro_to_def_inner(&path, MacroKind::Bang,
-                                                         &parent_scope, false) {
+                                                         &parent_scope, false, false) {
         if let SyntaxExtension::DeclMacro { .. } = *resolver.get_macro(def) {
             return Some(def);
         }

src/test/ui-fulldeps/custom-derive/derive-in-mod.rs

@@ -0,0 +1,13 @@
+// compile-pass
+// aux-build:plugin.rs
+
+extern crate plugin;
+
+mod inner {
+    use plugin::WithHelper;
+
+    #[derive(WithHelper)]
+    struct S;
+}
+
+fn main() {}