Skip to content

Commit 34eae07

Browse files
ShE3pyShE3py
committed
Remove ast:: & base:: prefixes from some builtin macros
1 parent c440a5b commit 34eae07

File tree

7 files changed

+116
-118
lines changed

7 files changed

+116
-118
lines changed

‎compiler/rustc_builtin_macros/src/cfg.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -8,14 +8,14 @@ use rustc_ast::token;
88
use rustc_ast::tokenstream::TokenStream;
99
use rustc_attr as attr;
1010
use rustc_errors::PResult;
11-
use rustc_expand::base::{self, *};
11+
use rustc_expand::base::{DummyResult, ExtCtxt, MacEager, MacResult};
1212
use rustc_span::Span;
1313

1414
pub fn expand_cfg(
1515
cx: &mut ExtCtxt<'_>,
1616
sp: Span,
1717
tts: TokenStream,
18-
) -> Box<dyn base::MacResult + 'static> {
18+
) -> Box<dyn MacResult + 'static> {
1919
let sp = cx.with_def_site_ctxt(sp);
2020

2121
match parse_cfg(cx, sp, tts) {

‎compiler/rustc_builtin_macros/src/compile_error.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
11
// The compiler code necessary to support the compile_error! extension.
22

33
use rustc_ast::tokenstream::TokenStream;
4-
use rustc_expand::base::{self, *};
4+
use rustc_expand::base::{get_single_str_from_tts, DummyResult, ExtCtxt, MacResult};
55
use rustc_span::Span;
66

77
pub fn expand_compile_error<'cx>(
88
cx: &'cx mut ExtCtxt<'_>,
99
sp: Span,
1010
tts: TokenStream,
11-
) -> Box<dyn base::MacResult + 'cx> {
11+
) -> Box<dyn MacResult + 'cx> {
1212
let var = match get_single_str_from_tts(cx, sp, tts, "compile_error!") {
1313
Ok(var) => var,
1414
Err(guar) => return DummyResult::any(sp, guar),

‎compiler/rustc_builtin_macros/src/concat.rs

+21-23
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,17 @@
1-
use rustc_ast as ast;
21
use rustc_ast::tokenstream::TokenStream;
3-
use rustc_expand::base::{self, DummyResult};
2+
use rustc_ast::{ExprKind, LitKind, UnOp};
3+
use rustc_expand::base::{get_exprs_from_tts, DummyResult, ExtCtxt, MacEager, MacResult};
44
use rustc_session::errors::report_lit_error;
55
use rustc_span::symbol::Symbol;
66

77
use crate::errors;
88

99
pub fn expand_concat(
10-
cx: &mut base::ExtCtxt<'_>,
10+
cx: &mut ExtCtxt<'_>,
1111
sp: rustc_span::Span,
1212
tts: TokenStream,
13-
) -> Box<dyn base::MacResult + 'static> {
14-
let es = match base::get_exprs_from_tts(cx, tts) {
13+
) -> Box<dyn MacResult + 'static> {
14+
let es = match get_exprs_from_tts(cx, tts) {
1515
Ok(es) => es,
1616
Err(guar) => return DummyResult::any(sp, guar),
1717
};
@@ -20,52 +20,50 @@ pub fn expand_concat(
2020
let mut guar = None;
2121
for e in es {
2222
match e.kind {
23-
ast::ExprKind::Lit(token_lit) => match ast::LitKind::from_token_lit(token_lit) {
24-
Ok(ast::LitKind::Str(s, _) | ast::LitKind::Float(s, _)) => {
23+
ExprKind::Lit(token_lit) => match LitKind::from_token_lit(token_lit) {
24+
Ok(LitKind::Str(s, _) | LitKind::Float(s, _)) => {
2525
accumulator.push_str(s.as_str());
2626
}
27-
Ok(ast::LitKind::Char(c)) => {
27+
Ok(LitKind::Char(c)) => {
2828
accumulator.push(c);
2929
}
30-
Ok(ast::LitKind::Int(i, _)) => {
30+
Ok(LitKind::Int(i, _)) => {
3131
accumulator.push_str(&i.to_string());
3232
}
33-
Ok(ast::LitKind::Bool(b)) => {
33+
Ok(LitKind::Bool(b)) => {
3434
accumulator.push_str(&b.to_string());
3535
}
36-
Ok(ast::LitKind::CStr(..)) => {
36+
Ok(LitKind::CStr(..)) => {
3737
guar = Some(cx.dcx().emit_err(errors::ConcatCStrLit { span: e.span }));
3838
}
39-
Ok(ast::LitKind::Byte(..) | ast::LitKind::ByteStr(..)) => {
39+
Ok(LitKind::Byte(..) | LitKind::ByteStr(..)) => {
4040
guar = Some(cx.dcx().emit_err(errors::ConcatBytestr { span: e.span }));
4141
}
42-
Ok(ast::LitKind::Err(guarantee)) => {
42+
Ok(LitKind::Err(guarantee)) => {
4343
guar = Some(guarantee);
4444
}
4545
Err(err) => {
4646
guar = Some(report_lit_error(&cx.sess.parse_sess, err, token_lit, e.span));
4747
}
4848
},
4949
// We also want to allow negative numeric literals.
50-
ast::ExprKind::Unary(ast::UnOp::Neg, ref expr)
51-
if let ast::ExprKind::Lit(token_lit) = expr.kind =>
52-
{
53-
match ast::LitKind::from_token_lit(token_lit) {
54-
Ok(ast::LitKind::Int(i, _)) => accumulator.push_str(&format!("-{i}")),
55-
Ok(ast::LitKind::Float(f, _)) => accumulator.push_str(&format!("-{f}")),
50+
ExprKind::Unary(UnOp::Neg, ref expr) if let ExprKind::Lit(token_lit) = expr.kind => {
51+
match LitKind::from_token_lit(token_lit) {
52+
Ok(LitKind::Int(i, _)) => accumulator.push_str(&format!("-{i}")),
53+
Ok(LitKind::Float(f, _)) => accumulator.push_str(&format!("-{f}")),
5654
Err(err) => {
5755
guar = Some(report_lit_error(&cx.sess.parse_sess, err, token_lit, e.span));
5856
}
5957
_ => missing_literal.push(e.span),
6058
}
6159
}
62-
ast::ExprKind::IncludedBytes(..) => {
60+
ExprKind::IncludedBytes(..) => {
6361
cx.dcx().emit_err(errors::ConcatBytestr { span: e.span });
6462
}
65-
ast::ExprKind::Err(guarantee) => {
63+
ExprKind::Err(guarantee) => {
6664
guar = Some(guarantee);
6765
}
68-
ast::ExprKind::Dummy => cx.dcx().span_bug(e.span, "concatenating `ExprKind::Dummy`"),
66+
ExprKind::Dummy => cx.dcx().span_bug(e.span, "concatenating `ExprKind::Dummy`"),
6967
_ => {
7068
missing_literal.push(e.span);
7169
}
@@ -79,5 +77,5 @@ pub fn expand_concat(
7977
return DummyResult::any(sp, guar);
8078
}
8179
let sp = cx.with_def_site_ctxt(sp);
82-
base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&accumulator)))
80+
MacEager::expr(cx.expr_str(sp, Symbol::intern(&accumulator)))
8381
}

‎compiler/rustc_builtin_macros/src/concat_bytes.rs

+42-47
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,14 @@
1-
use rustc_ast as ast;
2-
use rustc_ast::{ptr::P, tokenstream::TokenStream};
3-
use rustc_expand::base::{self, DummyResult};
1+
use rustc_ast::{ptr::P, token, tokenstream::TokenStream, ExprKind, LitIntType, LitKind, UintTy};
2+
use rustc_expand::base::{get_exprs_from_tts, DummyResult, ExtCtxt, MacEager, MacResult};
43
use rustc_session::errors::report_lit_error;
54
use rustc_span::{ErrorGuaranteed, Span};
65

76
use crate::errors;
87

98
/// Emits errors for literal expressions that are invalid inside and outside of an array.
109
fn invalid_type_err(
11-
cx: &mut base::ExtCtxt<'_>,
12-
token_lit: ast::token::Lit,
10+
cx: &mut ExtCtxt<'_>,
11+
token_lit: token::Lit,
1312
span: Span,
1413
is_nested: bool,
1514
) -> ErrorGuaranteed {
@@ -18,18 +17,18 @@ fn invalid_type_err(
1817
};
1918
let snippet = cx.sess.source_map().span_to_snippet(span).ok();
2019
let dcx = cx.dcx();
21-
match ast::LitKind::from_token_lit(token_lit) {
22-
Ok(ast::LitKind::CStr(_, _)) => {
20+
match LitKind::from_token_lit(token_lit) {
21+
Ok(LitKind::CStr(_, _)) => {
2322
// Avoid ambiguity in handling of terminal `NUL` by refusing to
2423
// concatenate C string literals as bytes.
2524
dcx.emit_err(errors::ConcatCStrLit { span })
2625
}
27-
Ok(ast::LitKind::Char(_)) => {
26+
Ok(LitKind::Char(_)) => {
2827
let sugg =
2928
snippet.map(|snippet| ConcatBytesInvalidSuggestion::CharLit { span, snippet });
3029
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "character", sugg })
3130
}
32-
Ok(ast::LitKind::Str(_, _)) => {
31+
Ok(LitKind::Str(_, _)) => {
3332
// suggestion would be invalid if we are nested
3433
let sugg = if !is_nested {
3534
snippet.map(|snippet| ConcatBytesInvalidSuggestion::StrLit { span, snippet })
@@ -38,27 +37,24 @@ fn invalid_type_err(
3837
};
3938
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "string", sugg })
4039
}
41-
Ok(ast::LitKind::Float(_, _)) => {
40+
Ok(LitKind::Float(_, _)) => {
4241
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "float", sugg: None })
4342
}
44-
Ok(ast::LitKind::Bool(_)) => {
43+
Ok(LitKind::Bool(_)) => {
4544
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "boolean", sugg: None })
4645
}
47-
Ok(ast::LitKind::Int(_, _)) if !is_nested => {
46+
Ok(LitKind::Int(_, _)) if !is_nested => {
4847
let sugg =
49-
snippet.map(|snippet| ConcatBytesInvalidSuggestion::IntLit { span: span, snippet });
48+
snippet.map(|snippet| ConcatBytesInvalidSuggestion::IntLit { span, snippet });
5049
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "numeric", sugg })
5150
}
52-
Ok(ast::LitKind::Int(
53-
val,
54-
ast::LitIntType::Unsuffixed | ast::LitIntType::Unsigned(ast::UintTy::U8),
55-
)) => {
51+
Ok(LitKind::Int(val, LitIntType::Unsuffixed | LitIntType::Unsigned(UintTy::U8))) => {
5652
assert!(val.get() > u8::MAX.into()); // must be an error
5753
dcx.emit_err(ConcatBytesOob { span })
5854
}
59-
Ok(ast::LitKind::Int(_, _)) => dcx.emit_err(ConcatBytesNonU8 { span }),
60-
Ok(ast::LitKind::ByteStr(..) | ast::LitKind::Byte(_)) => unreachable!(),
61-
Ok(ast::LitKind::Err(guar)) => guar,
55+
Ok(LitKind::Int(_, _)) => dcx.emit_err(ConcatBytesNonU8 { span }),
56+
Ok(LitKind::ByteStr(..) | LitKind::Byte(_)) => unreachable!(),
57+
Ok(LitKind::Err(guar)) => guar,
6258
Err(err) => report_lit_error(&cx.sess.parse_sess, err, token_lit, span),
6359
}
6460
}
@@ -68,24 +64,24 @@ fn invalid_type_err(
6864
/// Otherwise, returns `None`, and either pushes the `expr`'s span to `missing_literals` or
6965
/// updates `guar` accordingly.
7066
fn handle_array_element(
71-
cx: &mut base::ExtCtxt<'_>,
67+
cx: &mut ExtCtxt<'_>,
7268
guar: &mut Option<ErrorGuaranteed>,
7369
missing_literals: &mut Vec<rustc_span::Span>,
7470
expr: &P<rustc_ast::Expr>,
7571
) -> Option<u8> {
7672
let dcx = cx.dcx();
7773

7874
match expr.kind {
79-
ast::ExprKind::Lit(token_lit) => {
80-
match ast::LitKind::from_token_lit(token_lit) {
81-
Ok(ast::LitKind::Int(
75+
ExprKind::Lit(token_lit) => {
76+
match LitKind::from_token_lit(token_lit) {
77+
Ok(LitKind::Int(
8278
val,
83-
ast::LitIntType::Unsuffixed | ast::LitIntType::Unsigned(ast::UintTy::U8),
79+
LitIntType::Unsuffixed | LitIntType::Unsigned(UintTy::U8),
8480
)) if let Ok(val) = u8::try_from(val.get()) => {
8581
return Some(val);
8682
}
87-
Ok(ast::LitKind::Byte(val)) => return Some(val),
88-
Ok(ast::LitKind::ByteStr(..)) => {
83+
Ok(LitKind::Byte(val)) => return Some(val),
84+
Ok(LitKind::ByteStr(..)) => {
8985
guar.get_or_insert_with(|| {
9086
dcx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: true })
9187
});
@@ -95,12 +91,12 @@ fn handle_array_element(
9591
}
9692
};
9793
}
98-
ast::ExprKind::Array(_) | ast::ExprKind::Repeat(_, _) => {
94+
ExprKind::Array(_) | ExprKind::Repeat(_, _) => {
9995
guar.get_or_insert_with(|| {
10096
dcx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: false })
10197
});
10298
}
103-
ast::ExprKind::IncludedBytes(..) => {
99+
ExprKind::IncludedBytes(..) => {
104100
guar.get_or_insert_with(|| {
105101
dcx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: false })
106102
});
@@ -112,11 +108,11 @@ fn handle_array_element(
112108
}
113109

114110
pub fn expand_concat_bytes(
115-
cx: &mut base::ExtCtxt<'_>,
116-
sp: rustc_span::Span,
111+
cx: &mut ExtCtxt<'_>,
112+
sp: Span,
117113
tts: TokenStream,
118-
) -> Box<dyn base::MacResult + 'static> {
119-
let es = match base::get_exprs_from_tts(cx, tts) {
114+
) -> Box<dyn MacResult + 'static> {
115+
let es = match get_exprs_from_tts(cx, tts) {
120116
Ok(es) => es,
121117
Err(guar) => return DummyResult::any(sp, guar),
122118
};
@@ -125,7 +121,7 @@ pub fn expand_concat_bytes(
125121
let mut guar = None;
126122
for e in es {
127123
match &e.kind {
128-
ast::ExprKind::Array(exprs) => {
124+
ExprKind::Array(exprs) => {
129125
for expr in exprs {
130126
if let Some(elem) =
131127
handle_array_element(cx, &mut guar, &mut missing_literals, expr)
@@ -134,10 +130,9 @@ pub fn expand_concat_bytes(
134130
}
135131
}
136132
}
137-
ast::ExprKind::Repeat(expr, count) => {
138-
if let ast::ExprKind::Lit(token_lit) = count.value.kind
139-
&& let Ok(ast::LitKind::Int(count_val, _)) =
140-
ast::LitKind::from_token_lit(token_lit)
133+
ExprKind::Repeat(expr, count) => {
134+
if let ExprKind::Lit(token_lit) = count.value.kind
135+
&& let Ok(LitKind::Int(count_val, _)) = LitKind::from_token_lit(token_lit)
141136
{
142137
if let Some(elem) =
143138
handle_array_element(cx, &mut guar, &mut missing_literals, expr)
@@ -152,35 +147,35 @@ pub fn expand_concat_bytes(
152147
);
153148
}
154149
}
155-
&ast::ExprKind::Lit(token_lit) => match ast::LitKind::from_token_lit(token_lit) {
156-
Ok(ast::LitKind::Byte(val)) => {
150+
&ExprKind::Lit(token_lit) => match LitKind::from_token_lit(token_lit) {
151+
Ok(LitKind::Byte(val)) => {
157152
accumulator.push(val);
158153
}
159-
Ok(ast::LitKind::ByteStr(ref bytes, _)) => {
154+
Ok(LitKind::ByteStr(ref bytes, _)) => {
160155
accumulator.extend_from_slice(bytes);
161156
}
162157
_ => {
163158
guar.get_or_insert_with(|| invalid_type_err(cx, token_lit, e.span, false));
164159
}
165160
},
166-
ast::ExprKind::IncludedBytes(bytes) => {
161+
ExprKind::IncludedBytes(bytes) => {
167162
accumulator.extend_from_slice(bytes);
168163
}
169-
ast::ExprKind::Err(guarantee) => {
164+
ExprKind::Err(guarantee) => {
170165
guar = Some(*guarantee);
171166
}
172-
ast::ExprKind::Dummy => cx.dcx().span_bug(e.span, "concatenating `ExprKind::Dummy`"),
167+
ExprKind::Dummy => cx.dcx().span_bug(e.span, "concatenating `ExprKind::Dummy`"),
173168
_ => {
174169
missing_literals.push(e.span);
175170
}
176171
}
177172
}
178173
if !missing_literals.is_empty() {
179174
let guar = cx.dcx().emit_err(errors::ConcatBytesMissingLiteral { spans: missing_literals });
180-
return base::MacEager::expr(DummyResult::raw_expr(sp, Some(guar)));
175+
return MacEager::expr(DummyResult::raw_expr(sp, Some(guar)));
181176
} else if let Some(guar) = guar {
182-
return base::MacEager::expr(DummyResult::raw_expr(sp, Some(guar)));
177+
return MacEager::expr(DummyResult::raw_expr(sp, Some(guar)));
183178
}
184179
let sp = cx.with_def_site_ctxt(sp);
185-
base::MacEager::expr(cx.expr_byte_str(sp, accumulator))
180+
MacEager::expr(cx.expr_byte_str(sp, accumulator))
186181
}

‎compiler/rustc_builtin_macros/src/concat_idents.rs

+13-13
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
1-
use rustc_ast as ast;
21
use rustc_ast::ptr::P;
32
use rustc_ast::token::{self, Token};
43
use rustc_ast::tokenstream::{TokenStream, TokenTree};
5-
use rustc_expand::base::{self, *};
4+
use rustc_ast::{AttrVec, Expr, ExprKind, Path, Ty, TyKind, DUMMY_NODE_ID};
5+
use rustc_expand::base::{DummyResult, ExtCtxt, MacResult};
66
use rustc_span::symbol::{Ident, Symbol};
77
use rustc_span::Span;
88

@@ -12,7 +12,7 @@ pub fn expand_concat_idents<'cx>(
1212
cx: &'cx mut ExtCtxt<'_>,
1313
sp: Span,
1414
tts: TokenStream,
15-
) -> Box<dyn base::MacResult + 'cx> {
15+
) -> Box<dyn MacResult + 'cx> {
1616
if tts.is_empty() {
1717
let guar = cx.dcx().emit_err(errors::ConcatIdentsMissingArgs { span: sp });
1818
return DummyResult::any(sp, guar);
@@ -47,21 +47,21 @@ pub fn expand_concat_idents<'cx>(
4747
ident: Ident,
4848
}
4949

50-
impl base::MacResult for ConcatIdentsResult {
51-
fn make_expr(self: Box<Self>) -> Option<P<ast::Expr>> {
52-
Some(P(ast::Expr {
53-
id: ast::DUMMY_NODE_ID,
54-
kind: ast::ExprKind::Path(None, ast::Path::from_ident(self.ident)),
50+
impl MacResult for ConcatIdentsResult {
51+
fn make_expr(self: Box<Self>) -> Option<P<Expr>> {
52+
Some(P(Expr {
53+
id: DUMMY_NODE_ID,
54+
kind: ExprKind::Path(None, Path::from_ident(self.ident)),
5555
span: self.ident.span,
56-
attrs: ast::AttrVec::new(),
56+
attrs: AttrVec::new(),
5757
tokens: None,
5858
}))
5959
}
6060

61-
fn make_ty(self: Box<Self>) -> Option<P<ast::Ty>> {
62-
Some(P(ast::Ty {
63-
id: ast::DUMMY_NODE_ID,
64-
kind: ast::TyKind::Path(None, ast::Path::from_ident(self.ident)),
61+
fn make_ty(self: Box<Self>) -> Option<P<Ty>> {
62+
Some(P(Ty {
63+
id: DUMMY_NODE_ID,
64+
kind: TyKind::Path(None, Path::from_ident(self.ident)),
6565
span: self.ident.span,
6666
tokens: None,
6767
}))

0 commit comments

Comments
 (0)