bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #69447 - Centril:minor-stmt-refactor, r=estebank

Browse source 
Minor refactoring of statement parsing

Extracted out of https://github.com/rust-lang/rust/pull/69445.

r? @estebank
This commit is contained in:
Dylan DPC 2020-02-26 15:34:35 +01:00 • committed by GitHub
commit ae383e2af8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 86 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

179
src/librustc_parse/parser/stmt.rs
View file

@ -35,61 +35,32 @@ impl<'a> Parser<'a> {
let attrs = self.parse_outer_attributes()?; let attrs = self.parse_outer_attributes()?;
let lo = self.token.span; let lo = self.token.span;
if self.eat_keyword(kw::Let) { let stmt = if self.eat_keyword(kw::Let) {
return self.parse_local_mk(lo, attrs.into()).map(Some); self.parse_local_mk(lo, attrs.into())?
} } else if self.is_kw_followed_by_ident(kw::Mut) {
if self.is_kw_followed_by_ident(kw::Mut) { self.recover_stmt_local(lo, attrs.into(), "missing keyword", "let mut")?
return self.recover_stmt_local(lo, attrs.into(), "missing keyword", "let mut"); } else if self.is_kw_followed_by_ident(kw::Auto) {
}
if self.is_kw_followed_by_ident(kw::Auto) {
self.bump(); // `auto` self.bump(); // `auto`
let msg = "write `let` instead of `auto` to introduce a new variable"; let msg = "write `let` instead of `auto` to introduce a new variable";
return self.recover_stmt_local(lo, attrs.into(), msg, "let"); self.recover_stmt_local(lo, attrs.into(), msg, "let")?
} } else if self.is_kw_followed_by_ident(sym::var) {
if self.is_kw_followed_by_ident(sym::var) {
self.bump(); // `var` self.bump(); // `var`
let msg = "write `let` instead of `var` to introduce a new variable"; let msg = "write `let` instead of `var` to introduce a new variable";
return self.recover_stmt_local(lo, attrs.into(), msg, "let"); self.recover_stmt_local(lo, attrs.into(), msg, "let")?
} } else if self.token.is_path_start()
&& !self.token.is_qpath_start()
// Starts like a simple path, being careful to avoid contextual keywords, && !self.is_path_start_item()
// e.g., `union`, items with `crate` visibility, or `auto trait` items.
// We aim to parse an arbitrary path `a::b` but not something that starts like a path
// (1 token), but it fact not a path. Also, we avoid stealing syntax from `parse_item_`.
if self.token.is_path_start() && !self.token.is_qpath_start() && !self.is_path_start_item()
{ {
let path = self.parse_path(PathStyle::Expr)?; // We have avoided contextual keywords like `union`, items with `crate` visibility,
// or `auto trait` items. We aim to parse an arbitrary path `a::b` but not something
if self.eat(&token::Not) { // that starts like a path (1 token), but it fact not a path.
return self.parse_stmt_mac(lo, attrs.into(), path); // Also, we avoid stealing syntax from `parse_item_`.
} self.parse_stmt_path_start(lo, attrs)?
} else if let Some(item) = self.parse_stmt_item(attrs.clone())? {
let expr = if self.check(&token::OpenDelim(token::Brace)) { // FIXME: Bad copy of attrs
self.parse_struct_expr(lo, path, AttrVec::new())? self.mk_stmt(lo.to(item.span), StmtKind::Item(P(item)))
} else { } else if self.token == token::Semi {
let hi = self.prev_span; // Do not attempt to parse an expression if we're done here.
self.mk_expr(lo.to(hi), ExprKind::Path(None, path), AttrVec::new())
};
let expr = self.with_res(Restrictions::STMT_EXPR, |this| {
let expr = this.parse_dot_or_call_expr_with(expr, lo, attrs.into())?;
this.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(expr))
})?;
return Ok(Some(self.mk_stmt(lo.to(self.prev_span), StmtKind::Expr(expr))));
}
// FIXME: Bad copy of attrs
let old_directory_ownership =
mem::replace(&mut self.directory.ownership, DirectoryOwnership::UnownedViaBlock);
let item = self.parse_item_common(attrs.clone(), false, true, |_| true)?;
self.directory.ownership = old_directory_ownership;
if let Some(item) = item {
return Ok(Some(self.mk_stmt(lo.to(item.span), StmtKind::Item(P(item)))));
}
// Do not attempt to parse an expression if we're done here.
if self.token == token::Semi {
self.error_outer_attrs(&attrs); self.error_outer_attrs(&attrs);
self.bump(); self.bump();
let mut last_semi = lo; let mut last_semi = lo;
@ -104,27 +75,49 @@ impl<'a> Parser<'a> {
ExprKind::Tup(Vec::new()), ExprKind::Tup(Vec::new()),
AttrVec::new(), AttrVec::new(),
)); ));
return Ok(Some(self.mk_stmt(lo.to(last_semi), kind))); self.mk_stmt(lo.to(last_semi), kind)
} } else if self.token != token::CloseDelim(token::Brace) {
// Remainder are line-expr stmts.
if self.token == token::CloseDelim(token::Brace) { let e = self.parse_expr_res(Restrictions::STMT_EXPR, Some(attrs.into()))?;
self.mk_stmt(lo.to(e.span), StmtKind::Expr(e))
} else {
self.error_outer_attrs(&attrs); self.error_outer_attrs(&attrs);
return Ok(None); return Ok(None);
};
Ok(Some(stmt))
}
fn parse_stmt_item(&mut self, attrs: Vec<Attribute>) -> PResult<'a, Option<ast::Item>> {
let old = mem::replace(&mut self.directory.ownership, DirectoryOwnership::UnownedViaBlock);
let item = self.parse_item_common(attrs.clone(), false, true, |_| true)?;
self.directory.ownership = old;
Ok(item)
}
fn parse_stmt_path_start(&mut self, lo: Span, attrs: Vec<Attribute>) -> PResult<'a, Stmt> {
let path = self.parse_path(PathStyle::Expr)?;
if self.eat(&token::Not) {
return self.parse_stmt_mac(lo, attrs.into(), path);
} }
// Remainder are line-expr stmts. let expr = if self.check(&token::OpenDelim(token::Brace)) {
let e = self.parse_expr_res(Restrictions::STMT_EXPR, Some(attrs.into()))?; self.parse_struct_expr(lo, path, AttrVec::new())?
Ok(Some(self.mk_stmt(lo.to(e.span), StmtKind::Expr(e)))) } else {
let hi = self.prev_span;
self.mk_expr(lo.to(hi), ExprKind::Path(None, path), AttrVec::new())
};
let expr = self.with_res(Restrictions::STMT_EXPR, |this| {
let expr = this.parse_dot_or_call_expr_with(expr, lo, attrs.into())?;
this.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(expr))
})?;
Ok(self.mk_stmt(lo.to(self.prev_span), StmtKind::Expr(expr)))
} }
/// Parses a statement macro `mac!(args)` provided a `path` representing `mac`. /// Parses a statement macro `mac!(args)` provided a `path` representing `mac`.
/// At this point, the `!` token after the path has already been eaten. /// At this point, the `!` token after the path has already been eaten.
fn parse_stmt_mac( fn parse_stmt_mac(&mut self, lo: Span, attrs: AttrVec, path: ast::Path) -> PResult<'a, Stmt> {
&mut self,
lo: Span,
attrs: AttrVec,
path: ast::Path,
) -> PResult<'a, Option<Stmt>> {
let args = self.parse_mac_args()?; let args = self.parse_mac_args()?;
let delim = args.delim(); let delim = args.delim();
let hi = self.prev_span; let hi = self.prev_span;
@ -145,7 +138,7 @@ impl<'a> Parser<'a> {
let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?; let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?;
StmtKind::Expr(e) StmtKind::Expr(e)
}; };
Ok(Some(self.mk_stmt(lo.to(hi), kind))) Ok(self.mk_stmt(lo.to(hi), kind))
} }
/// Error on outer attributes in this context. /// Error on outer attributes in this context.
@ -167,12 +160,12 @@ impl<'a> Parser<'a> {
attrs: AttrVec, attrs: AttrVec,
msg: &str, msg: &str,
sugg: &str, sugg: &str,
) -> PResult<'a, Option<Stmt>> { ) -> PResult<'a, Stmt> {
let stmt = self.parse_local_mk(lo, attrs)?; let stmt = self.parse_local_mk(lo, attrs)?;
self.struct_span_err(lo, "invalid variable declaration") self.struct_span_err(lo, "invalid variable declaration")
.span_suggestion(lo, msg, sugg.to_string(), Applicability::MachineApplicable) .span_suggestion(lo, msg, sugg.to_string(), Applicability::MachineApplicable)
.emit(); .emit();
Ok(Some(stmt)) Ok(stmt)
} }
fn parse_local_mk(&mut self, lo: Span, attrs: AttrVec) -> PResult<'a, Stmt> { fn parse_local_mk(&mut self, lo: Span, attrs: AttrVec) -> PResult<'a, Stmt> {
@ -372,36 +365,36 @@ impl<'a> Parser<'a> {
let mut eat_semi = true; let mut eat_semi = true;
match stmt.kind { match stmt.kind {
StmtKind::Expr(ref expr) if self.token != token::Eof => { // Expression without semicolon.
// expression without semicolon StmtKind::Expr(ref expr)
if classify::expr_requires_semi_to_be_stmt(expr) { if self.token != token::Eof && classify::expr_requires_semi_to_be_stmt(expr) =>
// Just check for errors and recover; do not eat semicolon yet. {
if let Err(mut e) = // Just check for errors and recover; do not eat semicolon yet.
self.expect_one_of(&[], &[token::Semi, token::CloseDelim(token::Brace)]) if let Err(mut e) =
{ self.expect_one_of(&[], &[token::Semi, token::CloseDelim(token::Brace)])
if let TokenKind::DocComment(..) = self.token.kind { {
if let Ok(snippet) = self.span_to_snippet(self.token.span) { if let TokenKind::DocComment(..) = self.token.kind {
let sp = self.token.span; if let Ok(snippet) = self.span_to_snippet(self.token.span) {
let marker = &snippet[..3]; let sp = self.token.span;
let (comment_marker, doc_comment_marker) = marker.split_at(2); let marker = &snippet[..3];
let (comment_marker, doc_comment_marker) = marker.split_at(2);
e.span_suggestion( e.span_suggestion(
sp.with_hi(sp.lo() + BytePos(marker.len() as u32)), sp.with_hi(sp.lo() + BytePos(marker.len() as u32)),
&format!( &format!(
"add a space before `{}` to use a regular comment", "add a space before `{}` to use a regular comment",
doc_comment_marker, doc_comment_marker,
), ),
format!("{} {}", comment_marker, doc_comment_marker), format!("{} {}", comment_marker, doc_comment_marker),
Applicability::MaybeIncorrect, Applicability::MaybeIncorrect,
); );
}
} }
e.emit();
self.recover_stmt();
// Don't complain about type errors in body tail after parse error (#57383).
let sp = expr.span.to(self.prev_span);
stmt.kind = StmtKind::Expr(self.mk_expr_err(sp));
} }
e.emit();
self.recover_stmt();
// Don't complain about type errors in body tail after parse error (#57383).
let sp = expr.span.to(self.prev_span);
stmt.kind = StmtKind::Expr(self.mk_expr_err(sp));
} }
} }
StmtKind::Local(..) => { StmtKind::Local(..) => {