Simplify std lib injection
This commit is contained in:
parent
e552840e79
commit
3f3fc52bfa
6 changed files with 52 additions and 126 deletions
|
@ -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);
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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()
|
||||
}
|
||||
|
|
|
@ -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))
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue