bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Aggregation of cosmetic changes made during work on REPL PRs: libsyntax

Browse source
This commit is contained in:
Alexander Regueiro 2019-09-06 03:56:45 +01:00
parent ef54f57c5b
commit 49d2fd1725
26 changed files with 538 additions and 524 deletions
Download patch file Download diff file Expand all files Collapse all files

141
src/libsyntax/parse/parser/expr.rs
View file

@ -1,26 +1,26 @@
use super::{Parser, PResult, Restrictions, PrevTokenKind, TokenType, PathStyle};
use super::{BlockMode, SemiColonMode};
use super::{SeqSep, TokenExpectType};
use super::{
Parser, PResult, Restrictions, PrevTokenKind, TokenType, PathStyle, BlockMode, SemiColonMode,
SeqSep, TokenExpectType,
};
use super::pat::{GateOr, PARAM_EXPECTED};
use crate::ast::{
self, DUMMY_NODE_ID, Attribute, AttrStyle, Ident, CaptureBy, BlockCheckMode,
Expr, ExprKind, RangeLimits, Label, Movability, IsAsync, Arm, Ty, TyKind,
FunctionRetTy, Param, FnDecl, BinOpKind, BinOp, UnOp, Mac, AnonConst, Field,
};
use crate::maybe_recover_from_interpolated_ty_qpath;
use crate::ptr::P;
use crate::ast::{self, Attribute, AttrStyle, Ident, CaptureBy, BlockCheckMode};
use crate::ast::{Expr, ExprKind, RangeLimits, Label, Movability, IsAsync, Arm};
use crate::ast::{Ty, TyKind, FunctionRetTy, Param, FnDecl};
use crate::ast::{BinOpKind, BinOp, UnOp};
use crate::ast::{Mac, AnonConst, Field};
use crate::parse::classify;
use crate::parse::token::{self, Token};
use crate::parse::diagnostics::{Error};
use crate::parse::diagnostics::Error;
use crate::print::pprust;
use crate::ptr::P;
use crate::source_map::{self, Span};
use crate::symbol::{kw, sym};
use crate::util::parser::{AssocOp, Fixity, prec_let_scrutinee_needs_par};
use std::mem;
use errors::Applicability;
use std::mem;
use rustc_data_structures::thin_vec::ThinVec;
/// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression
@ -51,7 +51,7 @@ macro_rules! maybe_whole_expr {
$p.token.span, ExprKind::Block(block, None), ThinVec::new()
));
}
// N.B: `NtIdent(ident)` is normalized to `Ident` in `fn bump`.
// N.B., `NtIdent(ident)` is normalized to `Ident` in `fn bump`.
_ => {},
};
}
@ -340,7 +340,7 @@ impl<'a> Parser<'a> {
fn is_at_start_of_range_notation_rhs(&self) -> bool {
if self.token.can_begin_expr() {
// parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`.
// Parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`.
if self.token == token::OpenDelim(token::Brace) {
return !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
}
@ -350,12 +350,12 @@ impl<'a> Parser<'a> {
}
}
/// Parse prefix-forms of range notation: `..expr`, `..`, `..=expr`
/// Parses prefix-forms of range notation: `..expr`, `..`, `..=expr`.
fn parse_prefix_range_expr(
&mut self,
already_parsed_attrs: Option<ThinVec<Attribute>>
) -> PResult<'a, P<Expr>> {
// Check for deprecated `...` syntax
// Check for deprecated `...` syntax.
if self.token == token::DotDotDot {
self.err_dotdotdot_syntax(self.token.span);
}
@ -389,7 +389,7 @@ impl<'a> Parser<'a> {
Ok(self.mk_expr(lo.to(hi), r, attrs))
}
/// Parse a prefix-unary-operator expr
/// Parses a prefix-unary-operator expr.
fn parse_prefix_expr(
&mut self,
already_parsed_attrs: Option<ThinVec<Attribute>>
@ -549,7 +549,7 @@ impl<'a> Parser<'a> {
let expr = mk_expr(self, P(Ty {
span: path.span,
node: TyKind::Path(None, path),
id: ast::DUMMY_NODE_ID
id: DUMMY_NODE_ID,
}));
let expr_str = self.span_to_snippet(expr.span)
@ -565,7 +565,7 @@ impl<'a> Parser<'a> {
expr.span,
&format!("try {} the cast value", op_verb),
format!("({})", expr_str),
Applicability::MachineApplicable
Applicability::MachineApplicable,
)
.emit();
@ -741,7 +741,6 @@ impl<'a> Parser<'a> {
})
}
/// At the bottom (top?) of the precedence hierarchy,
/// Parses things like parenthesized exprs, macros, `return`, etc.
///
@ -755,7 +754,7 @@ impl<'a> Parser<'a> {
// added to the return value after the fact.
//
// Therefore, prevent sub-parser from parsing
// attributes by giving them a empty "already parsed" list.
// attributes by giving them a empty "already-parsed" list.
let mut attrs = ThinVec::new();
let lo = self.token.span;
@ -778,7 +777,7 @@ impl<'a> Parser<'a> {
}
}
// Note: when adding new syntax here, don't forget to adjust TokenKind::can_begin_expr().
// Note: when adding new syntax here, don't forget to adjust `TokenKind::can_begin_expr()`.
match self.token.kind {
// This match arm is a special-case of the `_` match arm below and
// could be removed without changing functionality, but it's faster
@ -791,8 +790,8 @@ impl<'a> Parser<'a> {
attrs.extend(self.parse_inner_attributes()?);
// (e) is parenthesized e
// (e,) is a tuple with only one field, e
// `(e)` is parenthesized `e`.
// `(e,)` is a tuple with only one field, `e`.
let mut es = vec![];
let mut trailing_comma = false;
let mut recovered = false;
@ -800,7 +799,7 @@ impl<'a> Parser<'a> {
es.push(match self.parse_expr() {
Ok(es) => es,
Err(mut err) => {
// recover from parse error in tuple list
// Recover from parse error in tuple list.
match self.token.kind {
token::Ident(name, false)
if name == kw::Underscore && self.look_ahead(1, |t| {
@ -844,7 +843,7 @@ impl<'a> Parser<'a> {
return self.parse_block_expr(None, lo, BlockCheckMode::Default, attrs);
}
token::BinOp(token::Or) | token::OrOr => {
return self.parse_lambda_expr(attrs);
return self.parse_closure(attrs);
}
token::OpenDelim(token::Bracket) => {
self.bump();
@ -852,21 +851,21 @@ impl<'a> Parser<'a> {
attrs.extend(self.parse_inner_attributes()?);
if self.eat(&token::CloseDelim(token::Bracket)) {
// Empty vector.
// Empty vector
ex = ExprKind::Array(Vec::new());
} else {
// Nonempty vector.
// Non-empty vector
let first_expr = self.parse_expr()?;
if self.eat(&token::Semi) {
// Repeating array syntax: [ 0; 512 ]
// Repeating array syntax: `[ 0; 512 ]`
let count = AnonConst {
id: ast::DUMMY_NODE_ID,
id: DUMMY_NODE_ID,
value: self.parse_expr()?,
};
self.expect(&token::CloseDelim(token::Bracket))?;
ex = ExprKind::Repeat(first_expr, count);
} else if self.eat(&token::Comma) {
// Vector with two or more elements.
// Vector with two or more elements
let remaining_exprs = self.parse_seq_to_end(
&token::CloseDelim(token::Bracket),
SeqSep::trailing_allowed(token::Comma),
@ -876,7 +875,7 @@ impl<'a> Parser<'a> {
exprs.extend(remaining_exprs);
ex = ExprKind::Array(exprs);
} else {
// Vector with one element.
// Vector with one element
self.expect(&token::CloseDelim(token::Bracket))?;
ex = ExprKind::Array(vec![first_expr]);
}
@ -892,7 +891,7 @@ impl<'a> Parser<'a> {
if self.token.is_path_start() {
let path = self.parse_path(PathStyle::Expr)?;
// `!`, as an operator, is prefix, so we know this isn't that
// `!`, as an operator, is prefix, so we know this isn't that.
if self.eat(&token::Not) {
// MACRO INVOCATION expression
let (delim, tts) = self.expect_delimited_token_tree()?;
@ -920,7 +919,7 @@ impl<'a> Parser<'a> {
return self.maybe_recover_from_bad_qpath(expr, true);
}
if self.check_keyword(kw::Move) || self.check_keyword(kw::Static) {
return self.parse_lambda_expr(attrs);
return self.parse_closure(attrs);
}
if self.eat_keyword(kw::If) {
return self.parse_if_expr(attrs);
@ -991,13 +990,13 @@ impl<'a> Parser<'a> {
return self.parse_try_block(lo, attrs);
}
// Span::rust_2018() is somewhat expensive; don't get it repeatedly.
// `Span::rust_2018()` is somewhat expensive; don't get it repeatedly.
let is_span_rust_2018 = self.token.span.rust_2018();
if is_span_rust_2018 && self.check_keyword(kw::Async) {
return if self.is_async_block() { // check for `async {` and `async move {`
return if self.is_async_block() { // Check for `async {` and `async move {`.
self.parse_async_block(attrs)
} else {
self.parse_lambda_expr(attrs)
self.parse_closure(attrs)
};
}
if self.eat_keyword(kw::Return) {
@ -1043,13 +1042,12 @@ impl<'a> Parser<'a> {
// recovery in order to keep the error count down. Fixing the
// delimiters will possibly also fix the bare semicolon found in
// expression context. For example, silence the following error:
// ```
// error: expected expression, found `;`
// --> file.rs:2:13
// |
// 2 | foo(bar(;
// | ^ expected expression
// ```
//
// error: expected expression, found `;`
// --> file.rs:2:13
// |
// 2 | foo(bar(;
// | ^ expected expression
self.bump();
return Ok(self.mk_expr(self.token.span, ExprKind::Err, ThinVec::new()));
}
@ -1096,11 +1094,11 @@ impl<'a> Parser<'a> {
attrs.extend(self.parse_inner_attributes()?);
let blk = self.parse_block_tail(lo, blk_mode)?;
return Ok(self.mk_expr(blk.span, ExprKind::Block(blk, opt_label), attrs));
Ok(self.mk_expr(blk.span, ExprKind::Block(blk, opt_label), attrs))
}
/// Parses `move |args| expr`.
fn parse_lambda_expr(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
/// Parses a closure (e.g., `move |args| expr`).
fn parse_closure(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
let lo = self.token.span;
let movability = if self.eat_keyword(kw::Static) {
@ -1115,7 +1113,7 @@ impl<'a> Parser<'a> {
IsAsync::NotAsync
};
if asyncness.is_async() {
// Feature gate `async ||` closures.
// Feature-gate `async ||` closures.
self.sess.gated_spans.async_closure.borrow_mut().push(self.prev_span);
}
@ -1128,8 +1126,7 @@ impl<'a> Parser<'a> {
self.parse_expr_res(restrictions, None)?
},
_ => {
// If an explicit return type is given, require a
// block to appear (RFC 968).
// If an explicit return type is given, require a block to appear (RFC 968).
let body_lo = self.token.span;
self.parse_block_expr(None, body_lo, BlockCheckMode::Default, ThinVec::new())?
}
@ -1141,7 +1138,7 @@ impl<'a> Parser<'a> {
attrs))
}
/// Parse an optional `move` prefix to a closure lke construct.
/// Parses an optional `move` prefix to a closure lke construct.
fn parse_capture_clause(&mut self) -> CaptureBy {
if self.eat_keyword(kw::Move) {
CaptureBy::Value
@ -1176,7 +1173,7 @@ impl<'a> Parser<'a> {
}))
}
/// Parses a parameter in a lambda header (e.g., `|arg, arg|`).
/// Parses a parameter in a closure header (e.g., `|arg, arg|`).
fn parse_fn_block_param(&mut self) -> PResult<'a, Param> {
let lo = self.token.span;
let attrs = self.parse_param_attributes()?;
@ -1185,7 +1182,7 @@ impl<'a> Parser<'a> {
self.parse_ty()?
} else {
P(Ty {
id: ast::DUMMY_NODE_ID,
id: DUMMY_NODE_ID,
node: TyKind::Infer,
span: self.prev_span,
})
@ -1196,7 +1193,7 @@ impl<'a> Parser<'a> {
ty: t,
pat,
span,
id: ast::DUMMY_NODE_ID
id: DUMMY_NODE_ID
})
}
@ -1233,7 +1230,7 @@ impl<'a> Parser<'a> {
Ok(self.mk_expr(lo.to(hi), ExprKind::If(cond, thn, els), attrs))
}
/// Parse the condition of a `if`- or `while`-expression
/// Parses the condition of a `if` or `while` expression.
fn parse_cond_expr(&mut self) -> PResult<'a, P<Expr>> {
let cond = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
@ -1261,7 +1258,7 @@ impl<'a> Parser<'a> {
Ok(self.mk_expr(span, ExprKind::Let(pat, expr), attrs))
}
/// `else` token already eaten
/// Parses an `else { ... }` expression (`else` token already eaten).
fn parse_else_expr(&mut self) -> PResult<'a, P<Expr>> {
if self.eat_keyword(kw::If) {
return self.parse_if_expr(ThinVec::new());
@ -1271,7 +1268,7 @@ impl<'a> Parser<'a> {
}
}
/// Parse a 'for' .. 'in' expression ('for' token already eaten)
/// Parses a `for ... in` expression (`for` token already eaten).
fn parse_for_expr(
&mut self,
opt_label: Option<Label>,
@ -1327,7 +1324,7 @@ impl<'a> Parser<'a> {
Ok(self.mk_expr(span, ExprKind::While(cond, body, opt_label), attrs))
}
/// Parse `loop {...}`, `loop` token already eaten.
/// Parses `loop { ... }` (`loop` token already eaten).
fn parse_loop_expr(
&mut self,
opt_label: Option<Label>,
@ -1350,7 +1347,7 @@ impl<'a> Parser<'a> {
}
}
// `match` token already eaten
/// Parses a `match ... { ... }` expression (`match` token already eaten).
fn parse_match_expr(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
let match_span = self.prev_span;
let lo = self.prev_span;
@ -1457,7 +1454,7 @@ impl<'a> Parser<'a> {
guard,
body: expr,
span: lo.to(hi),
id: ast::DUMMY_NODE_ID,
id: DUMMY_NODE_ID,
})
}
@ -1491,7 +1488,7 @@ impl<'a> Parser<'a> {
self.token.is_keyword(kw::Try) &&
self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) &&
self.token.span.rust_2018() &&
// prevent `while try {} {}`, `if try {} {} else {}`, etc.
// Prevent `while try {} {}`, `if try {} {} else {}`, etc.
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
}
@ -1504,7 +1501,7 @@ impl<'a> Parser<'a> {
attrs.extend(iattrs);
Ok(self.mk_expr(
span_lo.to(body.span),
ExprKind::Async(capture_clause, ast::DUMMY_NODE_ID, body), attrs))
ExprKind::Async(capture_clause, DUMMY_NODE_ID, body), attrs))
}
fn is_async_block(&self) -> bool {
@ -1527,18 +1524,18 @@ impl<'a> Parser<'a> {
) -> Option<PResult<'a, P<Expr>>> {
let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
let certainly_not_a_block = || self.look_ahead(1, |t| t.is_ident()) && (
// `{ ident, ` cannot start a block
// `{ ident, ` cannot start a block.
self.look_ahead(2, |t| t == &token::Comma) ||
self.look_ahead(2, |t| t == &token::Colon) && (
// `{ ident: token, ` cannot start a block
// `{ ident: token, ` cannot start a block.
self.look_ahead(4, |t| t == &token::Comma) ||
// `{ ident: ` cannot start a block unless it's a type ascription `ident: Type`
// `{ ident: ` cannot start a block unless it's a type ascription `ident: Type`.
self.look_ahead(3, |t| !t.can_begin_type())
)
);
if struct_allowed || certainly_not_a_block() {
// This is a struct literal, but we don't can't accept them here
// This is a struct literal, but we don't can't accept them here.
let expr = self.parse_struct_expr(lo, path.clone(), attrs.clone());
if let (Ok(expr), false) = (&expr, struct_allowed) {
self.struct_span_err(
@ -1606,14 +1603,14 @@ impl<'a> Parser<'a> {
let mut recovery_field = None;
if let token::Ident(name, _) = self.token.kind {
if !self.token.is_reserved_ident() && self.look_ahead(1, |t| *t == token::Colon) {
// Use in case of error after field-looking code: `S { foo: () with a }`
// Use in case of error after field-looking code: `S { foo: () with a }`.
recovery_field = Some(ast::Field {
ident: Ident::new(name, self.token.span),
span: self.token.span,
expr: self.mk_expr(self.token.span, ExprKind::Err, ThinVec::new()),
is_shorthand: false,
attrs: ThinVec::new(),
id: ast::DUMMY_NODE_ID,
id: DUMMY_NODE_ID,
});
}
}
@ -1639,7 +1636,7 @@ impl<'a> Parser<'a> {
match self.expect_one_of(&[token::Comma],
&[token::CloseDelim(token::Brace)]) {
Ok(_) => if let Some(f) = parsed_field.or(recovery_field) {
// only include the field if there's no parse error for the field name
// Only include the field if there's no parse error for the field name.
fields.push(f);
}
Err(mut e) => {
@ -1659,7 +1656,7 @@ impl<'a> Parser<'a> {
return Ok(self.mk_expr(span, ExprKind::Struct(pth, fields, base), attrs));
}
/// Parse ident (COLON expr)?
/// Parses `ident (COLON expr)?`.
fn parse_field(&mut self) -> PResult<'a, Field> {
let attrs = self.parse_outer_attributes()?;
let lo = self.token.span;
@ -1699,7 +1696,7 @@ impl<'a> Parser<'a> {
expr,
is_shorthand,
attrs: attrs.into(),
id: ast::DUMMY_NODE_ID,
id: DUMMY_NODE_ID,
})
}
@ -1772,6 +1769,6 @@ impl<'a> Parser<'a> {
}
crate fn mk_expr(&self, span: Span, node: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr> {
P(Expr { node, span, attrs, id: ast::DUMMY_NODE_ID })
P(Expr { node, span, attrs, id: DUMMY_NODE_ID })
}
}