Skip to content

Commit 4ae328b

Browse files
borsbors
committed
Auto merge of #78296 - Aaron1011:fix/stmt-tokens, r=petrochenkov
Properly handle attributes on statements We now collect tokens for the underlying node wrapped by `StmtKind` nstead of storing tokens directly in `Stmt`. `LazyTokenStream` now supports capturing a trailing semicolon after it is initially constructed. This allows us to avoid refactoring statement parsing to wrap the parsing of the semicolon in `parse_tokens`. Attributes on item statements (e.g. `fn foo() { #[bar] struct MyStruct; }`) are now treated as item attributes, not statement attributes, which is consistent with how we handle attributes on other kinds of statements. The feature-gating code is adjusted so that proc-macro attributes are still allowed on item statements on stable. Two built-in macros (`#[global_allocator]` and `#[test]`) needed to be adjusted to support being passed `Annotatable::Stmt`.
2 parents f8e5209 + 92bfa05 commit 4ae328b

File tree

52 files changed

+602
-255
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

52 files changed

+602
-255
lines changed

Diff for: ‎compiler/rustc_ast/src/ast.rs

+43-5
Original file line numberDiff line numberDiff line change
@@ -901,29 +901,65 @@ pub struct Stmt {
901901
pub id: NodeId,
902902
pub kind: StmtKind,
903903
pub span: Span,
904-
pub tokens: Option<LazyTokenStream>,
905904
}
906905

907906
impl Stmt {
907+
pub fn tokens(&self) -> Option<&LazyTokenStream> {
908+
match self.kind {
909+
StmtKind::Local(ref local) => local.tokens.as_ref(),
910+
StmtKind::Item(ref item) => item.tokens.as_ref(),
911+
StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => expr.tokens.as_ref(),
912+
StmtKind::Empty => None,
913+
StmtKind::MacCall(ref mac) => mac.tokens.as_ref(),
914+
}
915+
}
916+
917+
pub fn tokens_mut(&mut self) -> Option<&mut LazyTokenStream> {
918+
match self.kind {
919+
StmtKind::Local(ref mut local) => local.tokens.as_mut(),
920+
StmtKind::Item(ref mut item) => item.tokens.as_mut(),
921+
StmtKind::Expr(ref mut expr) | StmtKind::Semi(ref mut expr) => expr.tokens.as_mut(),
922+
StmtKind::Empty => None,
923+
StmtKind::MacCall(ref mut mac) => mac.tokens.as_mut(),
924+
}
925+
}
926+
927+
pub fn set_tokens(&mut self, tokens: Option<LazyTokenStream>) {
928+
match self.kind {
929+
StmtKind::Local(ref mut local) => local.tokens = tokens,
930+
StmtKind::Item(ref mut item) => item.tokens = tokens,
931+
StmtKind::Expr(ref mut expr) | StmtKind::Semi(ref mut expr) => expr.tokens = tokens,
932+
StmtKind::Empty => {}
933+
StmtKind::MacCall(ref mut mac) => mac.tokens = tokens,
934+
}
935+
}
936+
908937
pub fn has_trailing_semicolon(&self) -> bool {
909938
match &self.kind {
910939
StmtKind::Semi(_) => true,
911940
StmtKind::MacCall(mac) => matches!(mac.style, MacStmtStyle::Semicolon),
912941
_ => false,
913942
}
914943
}
944+
945+
/// Converts a parsed `Stmt` to a `Stmt` with
946+
/// a trailing semicolon.
947+
///
948+
/// This only modifies the parsed AST struct, not the attached
949+
/// `LazyTokenStream`. The parser is responsible for calling
950+
/// `CreateTokenStream::add_trailing_semi` when there is actually
951+
/// a semicolon in the tokenstream.
915952
pub fn add_trailing_semicolon(mut self) -> Self {
916953
self.kind = match self.kind {
917954
StmtKind::Expr(expr) => StmtKind::Semi(expr),
918955
StmtKind::MacCall(mac) => {
919-
StmtKind::MacCall(mac.map(|MacCallStmt { mac, style: _, attrs }| MacCallStmt {
920-
mac,
921-
style: MacStmtStyle::Semicolon,
922-
attrs,
956+
StmtKind::MacCall(mac.map(|MacCallStmt { mac, style: _, attrs, tokens }| {
957+
MacCallStmt { mac, style: MacStmtStyle::Semicolon, attrs, tokens }
923958
}))
924959
}
925960
kind => kind,
926961
};
962+
927963
self
928964
}
929965

@@ -963,6 +999,7 @@ pub struct MacCallStmt {
963999
pub mac: MacCall,
9641000
pub style: MacStmtStyle,
9651001
pub attrs: AttrVec,
1002+
pub tokens: Option<LazyTokenStream>,
9661003
}
9671004

9681005
#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)]
@@ -988,6 +1025,7 @@ pub struct Local {
9881025
pub init: Option<P<Expr>>,
9891026
pub span: Span,
9901027
pub attrs: AttrVec,
1028+
pub tokens: Option<LazyTokenStream>,
9911029
}
9921030

9931031
/// An arm of a 'match'.

Diff for: ‎compiler/rustc_ast/src/mut_visit.rs

+6-8
Original file line numberDiff line numberDiff line change
@@ -579,13 +579,14 @@ pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(
579579
}
580580

581581
pub fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
582-
let Local { id, pat, ty, init, span, attrs } = local.deref_mut();
582+
let Local { id, pat, ty, init, span, attrs, tokens } = local.deref_mut();
583583
vis.visit_id(id);
584584
vis.visit_pat(pat);
585585
visit_opt(ty, |ty| vis.visit_ty(ty));
586586
visit_opt(init, |init| vis.visit_expr(init));
587587
vis.visit_span(span);
588588
visit_thin_attrs(attrs, vis);
589+
visit_lazy_tts(tokens, vis);
589590
}
590591

591592
pub fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
@@ -1328,16 +1329,12 @@ pub fn noop_filter_map_expr<T: MutVisitor>(mut e: P<Expr>, vis: &mut T) -> Optio
13281329
}
13291330

13301331
pub fn noop_flat_map_stmt<T: MutVisitor>(
1331-
Stmt { kind, mut span, mut id, mut tokens }: Stmt,
1332+
Stmt { kind, mut span, mut id }: Stmt,
13321333
vis: &mut T,
13331334
) -> SmallVec<[Stmt; 1]> {
13341335
vis.visit_id(&mut id);
13351336
vis.visit_span(&mut span);
1336-
visit_lazy_tts(&mut tokens, vis);
1337-
noop_flat_map_stmt_kind(kind, vis)
1338-
.into_iter()
1339-
.map(|kind| Stmt { id, kind, span, tokens: tokens.clone() })
1340-
.collect()
1337+
noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| Stmt { id, kind, span }).collect()
13411338
}
13421339

13431340
pub fn noop_flat_map_stmt_kind<T: MutVisitor>(
@@ -1354,9 +1351,10 @@ pub fn noop_flat_map_stmt_kind<T: MutVisitor>(
13541351
StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(),
13551352
StmtKind::Empty => smallvec![StmtKind::Empty],
13561353
StmtKind::MacCall(mut mac) => {
1357-
let MacCallStmt { mac: mac_, style: _, attrs } = mac.deref_mut();
1354+
let MacCallStmt { mac: mac_, style: _, attrs, tokens } = mac.deref_mut();
13581355
vis.visit_mac_call(mac_);
13591356
visit_thin_attrs(attrs, vis);
1357+
visit_lazy_tts(tokens, vis);
13601358
smallvec![StmtKind::MacCall(mac)]
13611359
}
13621360
}

Diff for: ‎compiler/rustc_ast/src/tokenstream.rs

+11
Original file line numberDiff line numberDiff line change
@@ -121,10 +121,14 @@ where
121121
}
122122

123123
pub trait CreateTokenStream: sync::Send + sync::Sync {
124+
fn add_trailing_semi(&self) -> Box<dyn CreateTokenStream>;
124125
fn create_token_stream(&self) -> TokenStream;
125126
}
126127

127128
impl CreateTokenStream for TokenStream {
129+
fn add_trailing_semi(&self) -> Box<dyn CreateTokenStream> {
130+
panic!("Cannot call `add_trailing_semi` on a `TokenStream`!");
131+
}
128132
fn create_token_stream(&self) -> TokenStream {
129133
self.clone()
130134
}
@@ -141,6 +145,13 @@ impl LazyTokenStream {
141145
LazyTokenStream(Lrc::new(Box::new(inner)))
142146
}
143147

148+
/// Extends the captured stream by one token,
149+
/// which must be a trailing semicolon. This
150+
/// affects the `TokenStream` created by `make_tokenstream`.
151+
pub fn add_trailing_semi(&self) -> LazyTokenStream {
152+
LazyTokenStream(Lrc::new(self.0.add_trailing_semi()))
153+
}
154+
144155
pub fn create_token_stream(&self) -> TokenStream {
145156
self.0.create_token_stream()
146157
}

Diff for: ‎compiler/rustc_ast/src/visit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -689,7 +689,7 @@ pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) {
689689
StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => visitor.visit_expr(expr),
690690
StmtKind::Empty => {}
691691
StmtKind::MacCall(ref mac) => {
692-
let MacCallStmt { ref mac, style: _, ref attrs } = **mac;
692+
let MacCallStmt { ref mac, style: _, ref attrs, tokens: _ } = **mac;
693693
visitor.visit_mac_call(mac);
694694
for attr in attrs.iter() {
695695
visitor.visit_attribute(attr);

Diff for: ‎compiler/rustc_ast_passes/src/lib.rs

+1
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
77
#![feature(bindings_after_at)]
88
#![feature(iter_is_partitioned)]
9+
#![recursion_limit = "256"]
910

1011
pub mod ast_validation;
1112
pub mod feature_gate;

Diff for: ‎compiler/rustc_builtin_macros/src/deriving/debug.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -132,6 +132,7 @@ fn stmt_let_underscore(cx: &mut ExtCtxt<'_>, sp: Span, expr: P<ast::Expr>) -> as
132132
id: ast::DUMMY_NODE_ID,
133133
span: sp,
134134
attrs: ast::AttrVec::new(),
135+
tokens: None,
135136
});
136-
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span: sp, tokens: None }
137+
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span: sp }
137138
}

Diff for: ‎compiler/rustc_builtin_macros/src/deriving/mod.rs

-1
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,6 @@ impl MultiItemModifier for BuiltinDerive {
6464
id: ast::DUMMY_NODE_ID,
6565
kind: ast::StmtKind::Item(a.expect_item()),
6666
span,
67-
tokens: None,
6867
})));
6968
});
7069
} else {

Diff for: ‎compiler/rustc_codegen_ssa/src/mir/block.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -451,7 +451,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
451451
Inhabited,
452452
ZeroValid,
453453
UninitValid,
454-
};
454+
}
455455
let panic_intrinsic = intrinsic.and_then(|i| match i {
456456
sym::assert_inhabited => Some(AssertIntrinsic::Inhabited),
457457
sym::assert_zero_valid => Some(AssertIntrinsic::ZeroValid),

Diff for: ‎compiler/rustc_expand/src/base.rs

-2
Original file line numberDiff line numberDiff line change
@@ -374,7 +374,6 @@ macro_rules! make_stmts_default {
374374
id: ast::DUMMY_NODE_ID,
375375
span: e.span,
376376
kind: ast::StmtKind::Expr(e),
377-
tokens: None
378377
}]
379378
})
380379
};
@@ -617,7 +616,6 @@ impl MacResult for DummyResult {
617616
id: ast::DUMMY_NODE_ID,
618617
kind: ast::StmtKind::Expr(DummyResult::raw_expr(self.span, self.is_error)),
619618
span: self.span,
620-
tokens: None
621619
}])
622620
}
623621

Diff for: ‎compiler/rustc_expand/src/build.rs

+6-20
Original file line numberDiff line numberDiff line change
@@ -140,12 +140,7 @@ impl<'a> ExtCtxt<'a> {
140140
}
141141

142142
pub fn stmt_expr(&self, expr: P<ast::Expr>) -> ast::Stmt {
143-
ast::Stmt {
144-
id: ast::DUMMY_NODE_ID,
145-
span: expr.span,
146-
kind: ast::StmtKind::Expr(expr),
147-
tokens: None,
148-
}
143+
ast::Stmt { id: ast::DUMMY_NODE_ID, span: expr.span, kind: ast::StmtKind::Expr(expr) }
149144
}
150145

151146
pub fn stmt_let(&self, sp: Span, mutbl: bool, ident: Ident, ex: P<ast::Expr>) -> ast::Stmt {
@@ -162,13 +157,9 @@ impl<'a> ExtCtxt<'a> {
162157
id: ast::DUMMY_NODE_ID,
163158
span: sp,
164159
attrs: AttrVec::new(),
165-
});
166-
ast::Stmt {
167-
id: ast::DUMMY_NODE_ID,
168-
kind: ast::StmtKind::Local(local),
169-
span: sp,
170160
tokens: None,
171-
}
161+
});
162+
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span: sp }
172163
}
173164

174165
// Generates `let _: Type;`, which is usually used for type assertions.
@@ -180,17 +171,13 @@ impl<'a> ExtCtxt<'a> {
180171
id: ast::DUMMY_NODE_ID,
181172
span,
182173
attrs: AttrVec::new(),
174+
tokens: None,
183175
});
184-
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span, tokens: None }
176+
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span }
185177
}
186178

187179
pub fn stmt_item(&self, sp: Span, item: P<ast::Item>) -> ast::Stmt {
188-
ast::Stmt {
189-
id: ast::DUMMY_NODE_ID,
190-
kind: ast::StmtKind::Item(item),
191-
span: sp,
192-
tokens: None,
193-
}
180+
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Item(item), span: sp }
194181
}
195182

196183
pub fn block_expr(&self, expr: P<ast::Expr>) -> P<ast::Block> {
@@ -200,7 +187,6 @@ impl<'a> ExtCtxt<'a> {
200187
id: ast::DUMMY_NODE_ID,
201188
span: expr.span,
202189
kind: ast::StmtKind::Expr(expr),
203-
tokens: None,
204190
}],
205191
)
206192
}

Diff for: ‎compiler/rustc_expand/src/expand.rs

+3-9
Original file line numberDiff line numberDiff line change
@@ -1274,12 +1274,6 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
12741274
// we'll expand attributes on expressions separately
12751275
if !stmt.is_expr() {
12761276
let attr = if stmt.is_item() {
1277-
// FIXME: Implement proper token collection for statements
1278-
if let StmtKind::Item(item) = &mut stmt.kind {
1279-
stmt.tokens = item.tokens.take()
1280-
} else {
1281-
unreachable!()
1282-
};
12831277
self.take_first_attr(&mut stmt)
12841278
} else {
12851279
// Ignore derives on non-item statements for backwards compatibility.
@@ -1295,7 +1289,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
12951289
}
12961290

12971291
if let StmtKind::MacCall(mac) = stmt.kind {
1298-
let MacCallStmt { mac, style, attrs } = mac.into_inner();
1292+
let MacCallStmt { mac, style, attrs, tokens: _ } = mac.into_inner();
12991293
self.check_attributes(&attrs);
13001294
let mut placeholder =
13011295
self.collect_bang(mac, stmt.span, AstFragmentKind::Stmts).make_stmts();
@@ -1312,10 +1306,10 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
13121306
}
13131307

13141308
// The placeholder expander gives ids to statements, so we avoid folding the id here.
1315-
let ast::Stmt { id, kind, span, tokens } = stmt;
1309+
let ast::Stmt { id, kind, span } = stmt;
13161310
noop_flat_map_stmt_kind(kind, self)
13171311
.into_iter()
1318-
.map(|kind| ast::Stmt { id, kind, span, tokens: tokens.clone() })
1312+
.map(|kind| ast::Stmt { id, kind, span })
13191313
.collect()
13201314
}
13211315

Diff for: ‎compiler/rustc_expand/src/placeholders.rs

+4-7
Original file line numberDiff line numberDiff line change
@@ -104,8 +104,9 @@ pub fn placeholder(
104104
mac: mac_placeholder(),
105105
style: ast::MacStmtStyle::Braces,
106106
attrs: ast::AttrVec::new(),
107+
tokens: None,
107108
});
108-
ast::Stmt { id, span, kind: ast::StmtKind::MacCall(mac), tokens: None }
109+
ast::Stmt { id, span, kind: ast::StmtKind::MacCall(mac) }
109110
}]),
110111
AstFragmentKind::Arms => AstFragment::Arms(smallvec![ast::Arm {
111112
attrs: Default::default(),
@@ -331,12 +332,8 @@ impl<'a, 'b> MutVisitor for PlaceholderExpander<'a, 'b> {
331332

332333
// FIXME: We will need to preserve the original semicolon token and
333334
// span as part of #15701
334-
let empty_stmt = ast::Stmt {
335-
id: ast::DUMMY_NODE_ID,
336-
kind: ast::StmtKind::Empty,
337-
span: DUMMY_SP,
338-
tokens: None,
339-
};
335+
let empty_stmt =
336+
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Empty, span: DUMMY_SP };
340337

341338
if let Some(stmt) = stmts.pop() {
342339
if stmt.has_trailing_semicolon() {

Diff for: ‎compiler/rustc_interface/src/util.rs

-2
Original file line numberDiff line numberDiff line change
@@ -810,7 +810,6 @@ impl<'a> MutVisitor for ReplaceBodyWithLoop<'a, '_> {
810810
id: resolver.next_node_id(),
811811
kind: ast::StmtKind::Expr(expr),
812812
span: rustc_span::DUMMY_SP,
813-
tokens: None,
814813
}
815814
}
816815

@@ -827,7 +826,6 @@ impl<'a> MutVisitor for ReplaceBodyWithLoop<'a, '_> {
827826
id: self.resolver.next_node_id(),
828827
span: rustc_span::DUMMY_SP,
829828
kind: ast::StmtKind::Expr(loop_expr),
830-
tokens: None,
831829
};
832830

833831
if self.within_static_or_const {

Diff for: ‎compiler/rustc_lint/src/builtin.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2345,7 +2345,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
23452345
enum InitKind {
23462346
Zeroed,
23472347
Uninit,
2348-
};
2348+
}
23492349

23502350
/// Information about why a type cannot be initialized this way.
23512351
/// Contains an error message and optionally a span to point at.

0 commit comments

Comments
 (0)