diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs index 649cc8a2fb5..48c3ddf39a2 100644 --- a/src/librustc_interface/passes.rs +++ b/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); diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index b79e0c2bd3b..c479912b4ef 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/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 { diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index 02022c98c35..cf99663beaf 100644 --- a/src/librustc_resolve/macros.rs +++ b/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, diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 4e33ea018a0..ca189e71800 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/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 { diff --git a/src/libsyntax_ext/proc_macro_harness.rs b/src/libsyntax_ext/proc_macro_harness.rs index 8a4b78a3efa..31d32d23a64 100644 --- a/src/libsyntax_ext/proc_macro_harness.rs +++ b/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() } diff --git a/src/libsyntax_ext/standard_library_imports.rs b/src/libsyntax_ext/standard_library_imports.rs index e5dded9ea53..c577b1e33cf 100644 --- a/src/libsyntax_ext/standard_library_imports.rs +++ b/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, - edition: Edition, ) -> (ast::Crate, Option) { - 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)) }