Simplify std lib injection

Author: matthewjasper

src/librustc_interface/passes.rs

@@ -366,8 +366,8 @@ fn configure_and_expand_inner<'a>(
         let (krate, name) = syntax_ext::standard_library_imports::inject(
             krate,
             &mut resolver,
+            &sess.parse_sess,
             alt_std_name,
-            sess.edition(),
         );
         if let Some(name) = name {
             sess.parse_sess.injected_crate_name.set(name);

src/librustc_resolve/diagnostics.rs

@@ -604,6 +604,14 @@ impl<'a> Resolver<'a> {
         if lookup_ident.span.rust_2018() {
             let extern_prelude_names = self.extern_prelude.clone();
             for (ident, _) in extern_prelude_names.into_iter() {
+                if ident.span.from_expansion() {
+                    // Idents are adjusted to the root context before being
+                    // resolved in the extern prelude, so reporting this to the
+                    // user is no help. This skips the injected
+                    // `extern crate std` in the 2018 edition, which would
+                    // otherwise cause duplicate suggestions.
+                    continue;
+                }
                 if let Some(crate_id) = self.crate_loader.maybe_process_path_extern(ident.name,
                                                                                     ident.span) {
                     let crate_root = self.get_module(DefId {

src/librustc_resolve/macros.rs

@@ -128,9 +128,8 @@ impl<'a> base::Resolver for Resolver<'a> {
         }
     }
 
-    // Create a Span with modern hygiene with a definition site of the provided
-    // module, or a fake empty `#[no_implicit_prelude]` module if no module is
-    // provided.
+    // Create a new Expansion with a definition site of the provided module, or
+    // a fake empty `#[no_implicit_prelude]` module if no module is provided.
     fn expansion_for_ast_pass(
         &mut self,
         call_site: Span,

src/librustc_resolve/resolve_imports.rs

@@ -1307,8 +1307,11 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
                 None => continue,
             };
 
-            // Filter away ambiguous imports.
-            let is_good_import = binding.is_import() && !binding.is_ambiguity();
+            // Filter away ambiguous imports and anything that has def-site
+            // hygiene.
+            // FIXME: Implement actual cross-crate hygiene.
+            let is_good_import = binding.is_import() && !binding.is_ambiguity()
+                && !ident.span.modern().from_expansion();
             if is_good_import || binding.is_macro_def() {
                 let res = binding.res();
                 if res != Res::Err {

src/libsyntax_ext/proc_macro_harness.rs

@@ -392,41 +392,19 @@ fn mk_decls(
         i
     });
 
-    let block = P(ast::Expr {
-        id: ast::DUMMY_NODE_ID,
-        attrs: syntax::ThinVec::new(),
-        node: ast::ExprKind::Block(P(ast::Block {
-            id: ast::DUMMY_NODE_ID,
-            rules: ast::BlockCheckMode::Default,
-            stmts: vec![
-                ast::Stmt {
-                    id: ast::DUMMY_NODE_ID,
-                    node: ast::StmtKind::Item(krate),
-                    span,
-                },
-                ast::Stmt {
-                    id: ast::DUMMY_NODE_ID,
-                    node: ast::StmtKind::Item(decls_static),
-                    span,
-                }
-            ],
-            span,
-        }), None),
+    let block = cx.expr_block(cx.block(
         span,
-    });
+        vec![cx.stmt_item(span, krate), cx.stmt_item(span, decls_static)],
+    ));
 
     let anon_constant = cx.item_const(
         span,
         ast::Ident::new(kw::Underscore, span),
-        P(ast::Ty {
-            id: ast::DUMMY_NODE_ID,
-            node: ast::TyKind::Tup(Vec::new()),
-            span,
-        }),
+        cx.ty(span, ast::TyKind::Tup(Vec::new())),
         block,
     );
 
-    // Integrate the new module into existing module structures.
+    // Integrate the new item into existing module structures.
     let items = AstFragment::Items(smallvec![anon_constant]);
     cx.monotonic_expander().fully_expand_fragment(items).make_items().pop().unwrap()
 }

src/libsyntax_ext/standard_library_imports.rs

@@ -1,19 +1,20 @@
 use syntax::{ast, attr};
 use syntax::edition::Edition;
+use syntax::ext::expand::ExpansionConfig;
 use syntax::ext::hygiene::AstPass;
-use syntax::ext::base::Resolver;
+use syntax::ext::base::{ExtCtxt, Resolver};
+use syntax::parse::ParseSess;
 use syntax::ptr::P;
-use syntax::source_map::respan;
 use syntax::symbol::{Ident, Symbol, kw, sym};
 use syntax_pos::DUMMY_SP;
 
 pub fn inject(
     mut krate: ast::Crate,
     resolver: &mut dyn Resolver,
+    sess: &ParseSess,
     alt_std_name: Option<Symbol>,
-    edition: Edition,
 ) -> (ast::Crate, Option<Symbol>) {
-    let rust_2018 = edition >= Edition::Edition2018;
+    let rust_2018 = sess.edition >= Edition::Edition2018;
 
     // the first name in this list is the crate name of the crate with the prelude
     let names: &[Symbol] = if attr::contains_name(&krate.attrs, sym::no_core) {
@@ -37,112 +38,49 @@ pub fn inject(
     let span = DUMMY_SP.with_def_site_ctxt(expn_id);
     let call_site = DUMMY_SP.with_call_site_ctxt(expn_id);
 
+    let ecfg = ExpansionConfig::default("std_lib_injection".to_string());
+    let cx = ExtCtxt::new(sess, ecfg, resolver);
+
+
     // .rev() to preserve ordering above in combination with insert(0, ...)
-    for &orig_name_sym in names.iter().rev() {
-        let (rename, orig_name) = if rust_2018 {
-            (Ident::new(kw::Underscore, span), Some(orig_name_sym))
+    for &name in names.iter().rev() {
+        let ident = if rust_2018 {
+            Ident::new(name, span)
         } else {
-            (Ident::new(orig_name_sym, call_site), None)
+            Ident::new(name, call_site)
         };
-        krate.module.items.insert(0, P(ast::Item {
-            attrs: vec![attr::mk_attr_outer(
-                attr::mk_word_item(ast::Ident::new(sym::macro_use, span))
-            )],
-            vis: respan(span, ast::VisibilityKind::Inherited),
-            node: ast::ItemKind::ExternCrate(alt_std_name.or(orig_name)),
-            ident: rename,
-            id: ast::DUMMY_NODE_ID,
+        krate.module.items.insert(0, cx.item(
             span,
-            tokens: None,
-        }));
+            ident,
+            vec![cx.attribute(cx.meta_word(span, sym::macro_use))],
+            ast::ItemKind::ExternCrate(alt_std_name),
+        ));
     }
 
-    // the crates have been injected, the assumption is that the first one is the one with
-    // the prelude.
+    // The crates have been injected, the assumption is that the first one is
+    // the one with the prelude.
     let name = names[0];
 
-    let segments = if rust_2018 {
+    let import_path = if rust_2018 {
         [name, sym::prelude, sym::v1].iter()
-            .map(|symbol| ast::PathSegment::from_ident(ast::Ident::new(*symbol, span)))
-            .collect()
+            .map(|symbol| ast::Ident::new(*symbol, span)).collect()
     } else {
         [kw::PathRoot, name, sym::prelude, sym::v1].iter()
-            .map(|symbol| ast::PathSegment::from_ident(ast::Ident::new(*symbol, call_site)))
-            .collect()
+            .map(|symbol| ast::Ident::new(*symbol, span)).collect()
     };
 
-    let use_item = P(ast::Item {
-        attrs: vec![attr::mk_attr_outer(
-            attr::mk_word_item(ast::Ident::new(sym::prelude_import, span)))],
-        vis: respan(span.shrink_to_lo(), ast::VisibilityKind::Inherited),
-        node: ast::ItemKind::Use(P(ast::UseTree {
-            prefix: ast::Path { segments, span },
+    let use_item = cx.item(
+        span,
+        ast::Ident::invalid(),
+        vec![cx.attribute(cx.meta_word(span, sym::prelude_import))],
+        ast::ItemKind::Use(P(ast::UseTree {
+            prefix: cx.path(span, import_path),
             kind: ast::UseTreeKind::Glob,
             span,
         })),
-        id: ast::DUMMY_NODE_ID,
-        ident: ast::Ident::invalid(),
-        span,
-        tokens: None,
-    });
-
-    let prelude_import_item = if rust_2018 {
-        let hygienic_extern_crate = P(ast::Item {
-            attrs: vec![],
-            vis: respan(span, ast::VisibilityKind::Inherited),
-            node: ast::ItemKind::ExternCrate(alt_std_name),
-            ident: ast::Ident::new(name, span),
-            id: ast::DUMMY_NODE_ID,
-            span,
-            tokens: None,
-        });
-
-        // Use an anonymous const to hide `extern crate std as hygienic_std`
-        // FIXME: Once inter-crate hygiene exists, this can just be `use_item`.
-        P(ast::Item {
-            attrs: Vec::new(),
-            vis: respan(span.shrink_to_lo(), ast::VisibilityKind::Inherited),
-            node: ast::ItemKind::Const(
-                P(ast::Ty {
-                    id: ast::DUMMY_NODE_ID,
-                    node: ast::TyKind::Tup(Vec::new()),
-                    span,
-                }),
-                P(ast::Expr {
-                    id: ast::DUMMY_NODE_ID,
-                    attrs: syntax::ThinVec::new(),
-                    node: ast::ExprKind::Block(P(ast::Block {
-                        id: ast::DUMMY_NODE_ID,
-                        rules: ast::BlockCheckMode::Default,
-                        stmts: vec![
-                            ast::Stmt {
-                                id: ast::DUMMY_NODE_ID,
-                                node: ast::StmtKind::Item(use_item),
-                                span,
-                            },
-                            ast::Stmt {
-                                id: ast::DUMMY_NODE_ID,
-                                node: ast::StmtKind::Item(hygienic_extern_crate),
-                                span,
-                            }
-                        ],
-                        span,
-                    }), None),
-                    span,
-                })
-            ),
-            id: ast::DUMMY_NODE_ID,
-            ident: ast::Ident::new(kw::Underscore, span),
-            span,
-            tokens: None,
-        })
-    } else {
-        // Have `extern crate std` at the root, so don't need to create a named
-        // extern crate item.
-        use_item
-    };
+    );
 
-    krate.module.items.insert(0, prelude_import_item);
+    krate.module.items.insert(0, use_item);
 
     (krate, Some(name))
 }