Skip to content

Commit 4439bb0

Browse files
JohnTitorJohnTitor
authored
Rollup merge of rust-lang#69579 - petrochenkov:noprevspan, r=Centril
parser: Remove `Parser::prev_span` Follow-up to rust-lang#69384. r? @Centril
2 parents 48ec252 + 7de9a72 commit 4439bb0

File tree

13 files changed

+231
-214
lines changed

13 files changed

+231
-214
lines changed

‎src/librustc_builtin_macros/asm.rs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -151,7 +151,7 @@ fn parse_inline_asm<'a>(
151151

152152
let constraint = parse_asm_str(&mut p)?;
153153

154-
let span = p.prev_span;
154+
let span = p.prev_token.span;
155155

156156
p.expect(&token::OpenDelim(token::Paren))?;
157157
let expr = p.parse_expr()?;
@@ -202,15 +202,15 @@ fn parse_inline_asm<'a>(
202202
if constraint.as_str().starts_with('=') {
203203
struct_span_err!(
204204
cx.parse_sess.span_diagnostic,
205-
p.prev_span,
205+
p.prev_token.span,
206206
E0662,
207207
"input operand constraint contains '='"
208208
)
209209
.emit();
210210
} else if constraint.as_str().starts_with('+') {
211211
struct_span_err!(
212212
cx.parse_sess.span_diagnostic,
213-
p.prev_span,
213+
p.prev_token.span,
214214
E0663,
215215
"input operand constraint contains '+'"
216216
)
@@ -233,11 +233,11 @@ fn parse_inline_asm<'a>(
233233
let s = parse_asm_str(&mut p)?;
234234

235235
if OPTIONS.iter().any(|&opt| s == opt) {
236-
cx.span_warn(p.prev_span, "expected a clobber, found an option");
236+
cx.span_warn(p.prev_token.span, "expected a clobber, found an option");
237237
} else if s.as_str().starts_with('{') || s.as_str().ends_with('}') {
238238
struct_span_err!(
239239
cx.parse_sess.span_diagnostic,
240-
p.prev_span,
240+
p.prev_token.span,
241241
E0664,
242242
"clobber should not be surrounded by braces"
243243
)
@@ -259,7 +259,7 @@ fn parse_inline_asm<'a>(
259259
} else if option == sym::intel {
260260
dialect = AsmDialect::Intel;
261261
} else {
262-
cx.span_warn(p.prev_span, "unrecognized option");
262+
cx.span_warn(p.prev_token.span, "unrecognized option");
263263
}
264264

265265
if p.token == token::Comma {

‎src/librustc_builtin_macros/assert.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -106,7 +106,7 @@ fn parse_assert<'a>(
106106
let custom_message =
107107
if let token::Literal(token::Lit { kind: token::Str, .. }) = parser.token.kind {
108108
let mut err = cx.struct_span_warn(parser.token.span, "unexpected string literal");
109-
let comma_span = parser.prev_span.shrink_to_hi();
109+
let comma_span = parser.prev_token.span.shrink_to_hi();
110110
err.span_suggestion_short(
111111
comma_span,
112112
"try adding a comma",

‎src/librustc_parse/parser/attr.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ impl<'a> Parser<'a> {
116116
self.expect(&token::OpenDelim(token::Bracket))?;
117117
let item = self.parse_attr_item()?;
118118
self.expect(&token::CloseDelim(token::Bracket))?;
119-
let hi = self.prev_span;
119+
let hi = self.prev_token.span;
120120

121121
let attr_sp = lo.to(hi);
122122

@@ -255,7 +255,7 @@ impl<'a> Parser<'a> {
255255
while self.token.kind != token::Eof {
256256
let lo = self.token.span;
257257
let item = self.parse_attr_item()?;
258-
expanded_attrs.push((item, lo.to(self.prev_span)));
258+
expanded_attrs.push((item, lo.to(self.prev_token.span)));
259259
if !self.eat(&token::Comma) {
260260
break;
261261
}
@@ -303,7 +303,7 @@ impl<'a> Parser<'a> {
303303
let lo = self.token.span;
304304
let path = self.parse_path(PathStyle::Mod)?;
305305
let kind = self.parse_meta_item_kind()?;
306-
let span = lo.to(self.prev_span);
306+
let span = lo.to(self.prev_token.span);
307307
Ok(ast::MetaItem { path, kind, span })
308308
}
309309

‎src/librustc_parse/parser/diagnostics.rs‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -260,24 +260,24 @@ impl<'a> Parser<'a> {
260260
};
261261
(
262262
format!("expected one of {}, found {}", expect, actual),
263-
(self.prev_span.shrink_to_hi(), format!("expected one of {}", short_expect)),
263+
(self.prev_token.span.shrink_to_hi(), format!("expected one of {}", short_expect)),
264264
)
265265
} else if expected.is_empty() {
266266
(
267267
format!("unexpected token: {}", actual),
268-
(self.prev_span, "unexpected token after this".to_string()),
268+
(self.prev_token.span, "unexpected token after this".to_string()),
269269
)
270270
} else {
271271
(
272272
format!("expected {}, found {}", expect, actual),
273-
(self.prev_span.shrink_to_hi(), format!("expected {}", expect)),
273+
(self.prev_token.span.shrink_to_hi(), format!("expected {}", expect)),
274274
)
275275
};
276276
self.last_unexpected_token_span = Some(self.token.span);
277277
let mut err = self.struct_span_err(self.token.span, &msg_exp);
278278
let sp = if self.token == token::Eof {
279279
// This is EOF; don't want to point at the following char, but rather the last token.
280-
self.prev_span
280+
self.prev_token.span
281281
} else {
282282
label_sp
283283
};
@@ -298,7 +298,7 @@ impl<'a> Parser<'a> {
298298
}
299299

300300
let sm = self.sess.source_map();
301-
if self.prev_span == DUMMY_SP {
301+
if self.prev_token.span == DUMMY_SP {
302302
// Account for macro context where the previous span might not be
303303
// available to avoid incorrect output (#54841).
304304
err.span_label(self.token.span, label_exp);
@@ -577,7 +577,7 @@ impl<'a> Parser<'a> {
577577
match inner_op.kind {
578578
ExprKind::Binary(op, _, _) if op.node.is_comparison() => {
579579
// Respan to include both operators.
580-
let op_span = op.span.to(self.prev_span);
580+
let op_span = op.span.to(self.prev_token.span);
581581
let mut err =
582582
self.struct_span_err(op_span, "comparison operators cannot be chained");
583583

@@ -632,7 +632,7 @@ impl<'a> Parser<'a> {
632632
// FIXME: actually check that the two expressions in the binop are
633633
// paths and resynthesize new fn call expression instead of using
634634
// `ExprKind::Err` placeholder.
635-
mk_err_expr(self, inner_op.span.to(self.prev_span))
635+
mk_err_expr(self, inner_op.span.to(self.prev_token.span))
636636
}
637637
Err(mut expr_err) => {
638638
expr_err.cancel();
@@ -654,7 +654,7 @@ impl<'a> Parser<'a> {
654654
// FIXME: actually check that the two expressions in the binop are
655655
// paths and resynthesize new fn call expression instead of using
656656
// `ExprKind::Err` placeholder.
657-
mk_err_expr(self, inner_op.span.to(self.prev_span))
657+
mk_err_expr(self, inner_op.span.to(self.prev_token.span))
658658
}
659659
}
660660
} else {
@@ -723,7 +723,7 @@ impl<'a> Parser<'a> {
723723

724724
self.bump(); // `+`
725725
let bounds = self.parse_generic_bounds(None)?;
726-
let sum_span = ty.span.to(self.prev_span);
726+
let sum_span = ty.span.to(self.prev_token.span);
727727

728728
let mut err = struct_span_err!(
729729
self.sess.span_diagnostic,
@@ -790,7 +790,7 @@ impl<'a> Parser<'a> {
790790

791791
let mut path = ast::Path { segments: Vec::new(), span: DUMMY_SP };
792792
self.parse_path_segments(&mut path.segments, T::PATH_STYLE)?;
793-
path.span = ty_span.to(self.prev_span);
793+
path.span = ty_span.to(self.prev_token.span);
794794

795795
let ty_str = self.span_to_snippet(ty_span).unwrap_or_else(|_| pprust::ty_to_string(&ty));
796796
self.struct_span_err(path.span, "missing angle brackets in associated item path")
@@ -809,9 +809,9 @@ impl<'a> Parser<'a> {
809809

810810
pub(super) fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool {
811811
if self.eat(&token::Semi) {
812-
let mut err = self.struct_span_err(self.prev_span, "expected item, found `;`");
812+
let mut err = self.struct_span_err(self.prev_token.span, "expected item, found `;`");
813813
err.span_suggestion_short(
814-
self.prev_span,
814+
self.prev_token.span,
815815
"remove this semicolon",
816816
String::new(),
817817
Applicability::MachineApplicable,
@@ -854,10 +854,10 @@ impl<'a> Parser<'a> {
854854
}
855855
// We don't want to point at the following span after DUMMY_SP.
856856
// This happens when the parser finds an empty TokenStream.
857-
_ if self.prev_span == DUMMY_SP => (self.token.span, self.token.span),
857+
_ if self.prev_token.span == DUMMY_SP => (self.token.span, self.token.span),
858858
// EOF, don't want to point at the following char, but rather the last token.
859-
(token::Eof, None) => (self.prev_span, self.token.span),
860-
_ => (self.prev_span.shrink_to_hi(), self.token.span),
859+
(token::Eof, None) => (self.prev_token.span, self.token.span),
860+
_ => (self.prev_token.span.shrink_to_hi(), self.token.span),
861861
};
862862
let msg = format!(
863863
"expected `{}`, found {}",
@@ -894,10 +894,10 @@ impl<'a> Parser<'a> {
894894
let sm = self.sess.source_map();
895895
let msg = format!("expected `;`, found `{}`", super::token_descr(&self.token));
896896
let appl = Applicability::MachineApplicable;
897-
if self.token.span == DUMMY_SP || self.prev_span == DUMMY_SP {
897+
if self.token.span == DUMMY_SP || self.prev_token.span == DUMMY_SP {
898898
// Likely inside a macro, can't provide meaninful suggestions.
899899
return self.expect(&token::Semi).map(drop);
900-
} else if !sm.is_multiline(self.prev_span.until(self.token.span)) {
900+
} else if !sm.is_multiline(self.prev_token.span.until(self.token.span)) {
901901
// The current token is in the same line as the prior token, not recoverable.
902902
} else if self.look_ahead(1, |t| {
903903
t == &token::CloseDelim(token::Brace) || t.can_begin_expr() && t.kind != token::Colon
@@ -910,7 +910,7 @@ impl<'a> Parser<'a> {
910910
// let x = 32:
911911
// let y = 42;
912912
self.bump();
913-
let sp = self.prev_span;
913+
let sp = self.prev_token.span;
914914
self.struct_span_err(sp, &msg)
915915
.span_suggestion(sp, "change this to `;`", ";".to_string(), appl)
916916
.emit();
@@ -927,7 +927,7 @@ impl<'a> Parser<'a> {
927927
//
928928
// let x = 32
929929
// let y = 42;
930-
let sp = self.prev_span.shrink_to_hi();
930+
let sp = self.prev_token.span.shrink_to_hi();
931931
self.struct_span_err(sp, &msg)
932932
.span_label(self.token.span, "unexpected token")
933933
.span_suggestion_short(sp, "add `;` here", ";".to_string(), appl)
@@ -961,7 +961,7 @@ impl<'a> Parser<'a> {
961961
self.expect(&token::OpenDelim(token::Paren))?;
962962
let expr = self.parse_expr()?;
963963
self.expect(&token::CloseDelim(token::Paren))?;
964-
Ok((self.prev_span, expr, false))
964+
Ok((self.prev_token.span, expr, false))
965965
}
966966

967967
fn recover_await_prefix(&mut self, await_sp: Span) -> PResult<'a, (Span, P<Expr>, bool)> {
@@ -1036,10 +1036,10 @@ impl<'a> Parser<'a> {
10361036
.span_to_snippet(pat.span.trim_start(begin_par_sp).unwrap())
10371037
.unwrap_or_else(|_| pprust::pat_to_string(&pat));
10381038

1039-
self.struct_span_err(self.prev_span, "unexpected closing `)`")
1039+
self.struct_span_err(self.prev_token.span, "unexpected closing `)`")
10401040
.span_label(begin_par_sp, "opening `(`")
10411041
.span_suggestion(
1042-
begin_par_sp.to(self.prev_span),
1042+
begin_par_sp.to(self.prev_token.span),
10431043
"remove parenthesis in `for` loop",
10441044
format!("{} in {}", pat_str, pprust::expr_to_string(&expr)),
10451045
// With e.g. `for (x) in y)` this would replace `(x) in y)`
@@ -1091,7 +1091,7 @@ impl<'a> Parser<'a> {
10911091
err.emit();
10921092
// Recover from parse error, callers expect the closing delim to be consumed.
10931093
self.consume_block(delim, ConsumeClosingDelim::Yes);
1094-
self.mk_expr(lo.to(self.prev_span), ExprKind::Err, AttrVec::new())
1094+
self.mk_expr(lo.to(self.prev_token.span), ExprKind::Err, AttrVec::new())
10951095
}
10961096
}
10971097
}
@@ -1138,7 +1138,7 @@ impl<'a> Parser<'a> {
11381138
err.span_label(sp, "unclosed delimiter");
11391139
}
11401140
err.span_suggestion_short(
1141-
self.prev_span.shrink_to_hi(),
1141+
self.prev_token.span.shrink_to_hi(),
11421142
&format!("{} may belong here", delim.to_string()),
11431143
delim.to_string(),
11441144
Applicability::MaybeIncorrect,
@@ -1246,9 +1246,9 @@ impl<'a> Parser<'a> {
12461246
pub(super) fn check_for_for_in_in_typo(&mut self, in_span: Span) {
12471247
if self.eat_keyword(kw::In) {
12481248
// a common typo: `for _ in in bar {}`
1249-
self.struct_span_err(self.prev_span, "expected iterable, found keyword `in`")
1249+
self.struct_span_err(self.prev_token.span, "expected iterable, found keyword `in`")
12501250
.span_suggestion_short(
1251-
in_span.until(self.prev_span),
1251+
in_span.until(self.prev_token.span),
12521252
"remove the duplicated `in`",
12531253
String::new(),
12541254
Applicability::MachineApplicable,

0 commit comments

Comments
 (0)