1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
use crate::ast;
use crate::attr;
use crate::edition::Edition;
use crate::ext::hygiene::{Mark, SyntaxContext};
use crate::symbol::{Symbol, keywords, sym};
use crate::source_map::{ExpnInfo, MacroAttribute, dummy_spanned, hygiene, respan};
use crate::ptr::P;
use crate::tokenstream::TokenStream;
use std::cell::Cell;
use std::iter;
use syntax_pos::{DUMMY_SP, Span};
fn ignored_span(sp: Span) -> Span {
let mark = Mark::fresh(Mark::root());
mark.set_expn_info(ExpnInfo {
call_site: DUMMY_SP,
def_site: None,
format: MacroAttribute(Symbol::intern("std_inject")),
allow_internal_unstable: Some(vec![
Symbol::intern("prelude_import"),
].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
});
sp.with_ctxt(SyntaxContext::empty().apply_mark(mark))
}
pub fn injected_crate_name() -> Option<&'static str> {
INJECTED_CRATE_NAME.with(|name| name.get())
}
thread_local! {
static INJECTED_CRATE_NAME: Cell<Option<&'static str>> = Cell::new(None);
}
pub fn maybe_inject_crates_ref(
mut krate: ast::Crate,
alt_std_name: Option<&str>,
edition: Edition,
) -> ast::Crate {
let rust_2018 = edition >= Edition::Edition2018;
let names: &[&str] = if attr::contains_name(&krate.attrs, sym::no_core) {
return krate;
} else if attr::contains_name(&krate.attrs, sym::no_std) {
if attr::contains_name(&krate.attrs, sym::compiler_builtins) {
&["core"]
} else {
&["core", "compiler_builtins"]
}
} else {
&["std"]
};
let alt_std_name = alt_std_name.map(Symbol::intern);
for orig_name in names.iter().rev() {
let orig_name = Symbol::intern(orig_name);
let mut rename = orig_name;
if rust_2018 {
rename = orig_name.gensymed();
}
let orig_name = if rename != orig_name {
Some(orig_name)
} else {
None
};
krate.module.items.insert(0, P(ast::Item {
attrs: vec![attr::mk_attr_outer(
DUMMY_SP,
attr::mk_attr_id(),
attr::mk_word_item(ast::Ident::with_empty_ctxt(sym::macro_use))
)],
vis: dummy_spanned(ast::VisibilityKind::Inherited),
node: ast::ItemKind::ExternCrate(alt_std_name.or(orig_name)),
ident: ast::Ident::with_empty_ctxt(rename),
id: ast::DUMMY_NODE_ID,
span: DUMMY_SP,
tokens: None,
}));
}
let name = names[0];
INJECTED_CRATE_NAME.with(|opt_name| opt_name.set(Some(name)));
let span = ignored_span(DUMMY_SP);
krate.module.items.insert(0, P(ast::Item {
attrs: vec![ast::Attribute {
style: ast::AttrStyle::Outer,
path: ast::Path::from_ident(ast::Ident::new(Symbol::intern("prelude_import"), span)),
tokens: TokenStream::empty(),
id: attr::mk_attr_id(),
is_sugared_doc: false,
span,
}],
vis: respan(span.shrink_to_lo(), ast::VisibilityKind::Inherited),
node: ast::ItemKind::Use(P(ast::UseTree {
prefix: ast::Path {
segments: iter::once(keywords::PathRoot.ident())
.chain(
[name, "prelude", "v1"].iter().cloned()
.map(ast::Ident::from_str)
).map(ast::PathSegment::from_ident).collect(),
span,
},
kind: ast::UseTreeKind::Glob,
span,
})),
id: ast::DUMMY_NODE_ID,
ident: keywords::Invalid.ident(),
span,
tokens: None,
}));
krate
}