rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki 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

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