mirror of
https://github.com/rust-lang/rust.git
synced 2025-11-18 23:56:35 +00:00
ba1751a201
There is code for converting `Attribute` (syntactic) to `MetaItem`
(semantic). There is also code for the reverse direction. The reverse
direction isn't really necessary; it's currently only used when
generating attributes, e.g. in `derive` code.
This commit adds some new functions for creating `Attributes`s directly,
without involving `MetaItem`s: `mk_attr_word`, `mk_attr_name_value_str`,
`mk_attr_nested_word`, and
`ExtCtxt::attr_{word,name_value_str,nested_word}`.
These new methods replace the old functions for creating `Attribute`s:
`mk_attr_inner`, `mk_attr_outer`, and `ExtCtxt::attribute`. Those
functions took `MetaItem`s as input, and relied on many other functions
that created `MetaItems`, which are also removed: `mk_name_value_item`,
`mk_list_item`, `mk_word_item`, `mk_nested_word_item`,
`{MetaItem,MetaItemKind,NestedMetaItem}::token_trees`,
`MetaItemKind::attr_args`, `MetaItemLit::{from_lit_kind,to_token}`,
`ExtCtxt::meta_word`.
Overall this cuts more than 100 lines of code and makes thing simpler.
94 lines
2.7 KiB
Rust
94 lines
2.7 KiB
Rust
use rustc_ast as ast;
|
|
use rustc_expand::base::{ExtCtxt, ResolverExpand};
|
|
use rustc_expand::expand::ExpansionConfig;
|
|
use rustc_session::Session;
|
|
use rustc_span::edition::Edition::*;
|
|
use rustc_span::hygiene::AstPass;
|
|
use rustc_span::symbol::{kw, sym, Ident, Symbol};
|
|
use rustc_span::DUMMY_SP;
|
|
use thin_vec::thin_vec;
|
|
|
|
pub fn inject(
|
|
mut krate: ast::Crate,
|
|
resolver: &mut dyn ResolverExpand,
|
|
sess: &Session,
|
|
) -> ast::Crate {
|
|
let edition = sess.parse_sess.edition;
|
|
|
|
// the first name in this list is the crate name of the crate with the prelude
|
|
let names: &[Symbol] = if sess.contains_name(&krate.attrs, sym::no_core) {
|
|
return krate;
|
|
} else if sess.contains_name(&krate.attrs, sym::no_std) {
|
|
if sess.contains_name(&krate.attrs, sym::compiler_builtins) {
|
|
&[sym::core]
|
|
} else {
|
|
&[sym::core, sym::compiler_builtins]
|
|
}
|
|
} else {
|
|
&[sym::std]
|
|
};
|
|
|
|
let expn_id = resolver.expansion_for_ast_pass(
|
|
DUMMY_SP,
|
|
AstPass::StdImports,
|
|
&[sym::prelude_import],
|
|
None,
|
|
);
|
|
let span = DUMMY_SP.with_def_site_ctxt(expn_id.to_expn_id());
|
|
let call_site = DUMMY_SP.with_call_site_ctxt(expn_id.to_expn_id());
|
|
|
|
let ecfg = ExpansionConfig::default("std_lib_injection".to_string());
|
|
let cx = ExtCtxt::new(sess, ecfg, resolver, None);
|
|
|
|
// .rev() to preserve ordering above in combination with insert(0, ...)
|
|
for &name in names.iter().rev() {
|
|
let ident = if edition >= Edition2018 {
|
|
Ident::new(name, span)
|
|
} else {
|
|
Ident::new(name, call_site)
|
|
};
|
|
krate.items.insert(
|
|
0,
|
|
cx.item(
|
|
span,
|
|
ident,
|
|
thin_vec![cx.attr_word(sym::macro_use, span)],
|
|
ast::ItemKind::ExternCrate(None),
|
|
),
|
|
);
|
|
}
|
|
|
|
// The crates have been injected, the assumption is that the first one is
|
|
// the one with the prelude.
|
|
let name = names[0];
|
|
|
|
let root = (edition == Edition2015).then(|| kw::PathRoot);
|
|
|
|
let import_path = root
|
|
.iter()
|
|
.chain(&[name, sym::prelude])
|
|
.chain(&[match edition {
|
|
Edition2015 => sym::rust_2015,
|
|
Edition2018 => sym::rust_2018,
|
|
Edition2021 => sym::rust_2021,
|
|
Edition2024 => sym::rust_2024,
|
|
}])
|
|
.map(|&symbol| Ident::new(symbol, span))
|
|
.collect();
|
|
|
|
let use_item = cx.item(
|
|
span,
|
|
Ident::empty(),
|
|
thin_vec![cx.attr_word(sym::prelude_import, span)],
|
|
ast::ItemKind::Use(ast::UseTree {
|
|
prefix: cx.path(span, import_path),
|
|
kind: ast::UseTreeKind::Glob,
|
|
span,
|
|
}),
|
|
);
|
|
|
|
krate.items.insert(0, use_item);
|
|
|
|
krate
|
|
}
|