Don't use gensym_if_underscore to resolve _ bindings

Instead generate unique `SyntaxContexts`

Author: matthewjasper

src/librustc/ich/impls_syntax.rs

@@ -373,6 +373,7 @@ impl_stable_hash_for!(enum ::syntax_pos::hygiene::ExpnKind {
     Root,
     Macro(kind, descr),
     AstPass(kind),
+    Underscore,
     Desugaring(kind)
 });
 

src/librustc/lint/mod.rs

@@ -871,7 +871,9 @@ pub fn provide(providers: &mut Providers<'_>) {
 pub fn in_external_macro(sess: &Session, span: Span) -> bool {
     let expn_data = span.ctxt().outer_expn_data();
     match expn_data.kind {
-        ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop) => false,
+        ExpnKind::Root
+        | ExpnKind::Underscore
+        | ExpnKind::Desugaring(DesugaringKind::ForLoop) => false,
         ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => true, // well, it's "external"
         ExpnKind::Macro(MacroKind::Bang, _) => {
             if expn_data.def_site.is_dummy() {

src/librustc_resolve/build_reduced_graph.rs

@@ -406,7 +406,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
         };
         match use_tree.kind {
             ast::UseTreeKind::Simple(rename, ..) => {
-                let mut ident = use_tree.ident().gensym_if_underscore();
+                let mut ident = use_tree.ident().unique_if_underscore();
                 let mut module_path = prefix;
                 let mut source = module_path.pop().unwrap();
                 let mut type_ns_only = false;
@@ -584,7 +584,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
         let parent_scope = &self.parent_scope;
         let parent = parent_scope.module;
         let expansion = parent_scope.expansion;
-        let ident = item.ident.gensym_if_underscore();
+        let ident = item.ident.unique_if_underscore();
         let sp = item.span;
         let vis = self.resolve_visibility(&item.vis);
 
@@ -849,10 +849,10 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
     fn build_reduced_graph_for_external_crate_res(&mut self, child: Export<NodeId>) {
         let parent = self.parent_scope.module;
         let Export { ident, res, vis, span } = child;
-        // FIXME: We shouldn't create the gensym here, it should come from metadata,
-        // but metadata cannot encode gensyms currently, so we create it here.
-        // This is only a guess, two equivalent idents may incorrectly get different gensyms here.
-        let ident = ident.gensym_if_underscore();
+        // FIXME: We shouldn't create the SyntaxContext here, it should come from metadata,
+        // but metadata doesn't encode hygiene information currently, so we create it here.
+        // This is only a guess, two equivalent idents will get different SyntaxContexts here.
+        let ident = ident.unique_if_underscore();
         let expansion = ExpnId::root(); // FIXME(jseyfried) intercrate hygiene
         // Record primary definitions.
         match res {

src/librustc_resolve/resolve_imports.rs

@@ -1340,7 +1340,7 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
             // hygiene.
             // FIXME: Implement actual cross-crate hygiene.
             let is_good_import = binding.is_import() && !binding.is_ambiguity()
-                && !ident.span.modern().from_expansion();
+                && (!ident.span.from_expansion() || ident.name == kw::Underscore);
             if is_good_import || binding.is_macro_def() {
                 let res = binding.res();
                 if res != Res::Err {
@@ -1350,8 +1350,8 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
                         }
                     }
                     reexports.push(Export {
-                        ident: ident.modern(),
-                        res: res,
+                        ident,
+                        res,
                         span: binding.span,
                         vis: binding.vis,
                     });
@@ -1418,6 +1418,10 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
         }
 
         if reexports.len() > 0 {
+            // Type pretty printing will prefer reexports that appear earlier
+            // in this map, so sort them to ensure that diagnostic output is
+            // stable.
+            reexports.sort_by_cached_key(|export| export.ident.as_str());
             if let Some(def_id) = module.def_id() {
                 self.r.export_map.insert(def_id, reexports);
             }

src/libsyntax_pos/hygiene.rs

@@ -217,8 +217,14 @@ impl HygieneData {
 
     fn adjust(&self, ctxt: &mut SyntaxContext, expn_id: ExpnId) -> Option<ExpnId> {
         let mut scope = None;
-        while !self.is_descendant_of(expn_id, self.outer_expn(*ctxt)) {
-            scope = Some(self.remove_mark(ctxt).0);
+        let mut outer = self.outer_expn(*ctxt);
+        while !self.is_descendant_of(expn_id, outer) {
+            if let ExpnData { kind: ExpnKind::Underscore, call_site, .. } = *self.expn_data(outer) {
+                *ctxt = call_site.ctxt();
+            } else {
+                scope = Some(self.remove_mark(ctxt).0);
+            }
+            outer = self.outer_expn(*ctxt);
         }
         scope
     }
@@ -420,6 +426,21 @@ impl SyntaxContext {
         HygieneData::with(|data| data.marks(self))
     }
 
+    crate fn unique(base_span: Span) -> Self {
+        HygieneData::with(|data| {
+            // We store the original span as the call-site so that we can
+            // recover it. We call `modern` here to save us calling it when we
+            // access `call_site`.
+            let modern = base_span.with_ctxt(data.modern(base_span.ctxt()));
+            let expn_id = data.fresh_expn(Some(ExpnData::default(
+                ExpnKind::Underscore,
+                modern,
+                data.expn_data(data.outer_expn(modern.ctxt())).edition,
+            )));
+            data.apply_mark(SyntaxContext::root(), expn_id, Transparency::Opaque)
+        })
+    }
+
     /// Adjust this context for resolution in a scope created by the given expansion.
     /// For example, consider the following three resolutions of `f`:
     ///
@@ -508,7 +529,7 @@ impl SyntaxContext {
     pub fn reverse_glob_adjust(&mut self, expn_id: ExpnId, glob_span: Span)
                                -> Option<Option<ExpnId>> {
         HygieneData::with(|data| {
-            if data.adjust(self, expn_id).is_some() {
+            if data.adjust(&mut {*self}, expn_id).is_some() {
                 return None;
             }
 
@@ -674,6 +695,8 @@ pub enum ExpnKind {
     Macro(MacroKind, Symbol),
     /// Transform done by the compiler on the AST.
     AstPass(AstPass),
+    /// Generated by name resolution to give underscores unique identifiers.
+    Underscore,
     /// Desugaring done by the compiler during HIR lowering.
     Desugaring(DesugaringKind)
 }
@@ -684,6 +707,7 @@ impl ExpnKind {
             ExpnKind::Root => kw::PathRoot,
             ExpnKind::Macro(_, descr) => descr,
             ExpnKind::AstPass(kind) => Symbol::intern(kind.descr()),
+            ExpnKind::Underscore => kw::Underscore,
             ExpnKind::Desugaring(kind) => Symbol::intern(kind.descr()),
         }
     }

src/libsyntax_pos/lib.rs

@@ -443,6 +443,7 @@ impl Span {
                     ExpnKind::Root => break,
                     ExpnKind::Desugaring(..) => ("desugaring of ", ""),
                     ExpnKind::AstPass(..) => ("", ""),
+                    ExpnKind::Underscore => ("", ""),
                     ExpnKind::Macro(macro_kind, _) => match macro_kind {
                         MacroKind::Bang => ("", "!"),
                         MacroKind::Attr => ("#[", "]"),

src/libsyntax_pos/symbol.rs

@@ -15,7 +15,7 @@ use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::str;
 
-use crate::{Span, DUMMY_SP, GLOBALS};
+use crate::{Span, SyntaxContext, DUMMY_SP, GLOBALS};
 
 #[cfg(test)]
 mod tests;
@@ -814,6 +814,16 @@ impl Ident {
         }
     }
 
+    /// If the name of this ident is "_", then return a new unique identifier.
+    /// Otherwise returns `self` unmodified
+    #[inline]
+    pub fn unique_if_underscore(mut self) -> Ident {
+        if self.name == kw::Underscore {
+            self.span = self.span.with_ctxt(SyntaxContext::unique(self.span));
+        }
+        self
+    }
+
     /// Convert the name to a `LocalInternedString`. This is a slowish
     /// operation because it requires locking the symbol interner.
     pub fn as_str(self) -> LocalInternedString {