bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Simplify std lib injection

Browse source
This commit is contained in:
Matthew Jasper 2019-09-05 15:05:58 +01:00
parent e552840e79
commit 3f3fc52bfa
6 changed files with 52 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc_interface/passes.rs
View file

@ -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);

8
src/librustc_resolve/diagnostics.rs
View file

@ -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 {

5
src/librustc_resolve/macros.rs
View file

@ -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,

7
src/librustc_resolve/resolve_imports.rs
View file

@ -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 {

32
src/libsyntax_ext/proc_macro_harness.rs
View file

@ -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()
}

124
src/libsyntax_ext/standard_library_imports.rs
View file

@ -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))
}