diff options
Diffstat (limited to 'src/libsyntax/parse/parser')
| -rw-r--r-- | src/libsyntax/parse/parser/expr.rs | 141 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser/item.rs | 115 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser/module.rs | 6 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser/pat.rs | 4 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser/stmt.rs | 64 |
5 files changed, 164 insertions, 166 deletions
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs index e8c8e199fd0..f70c607198f 100644 --- a/src/libsyntax/parse/parser/expr.rs +++ b/src/libsyntax/parse/parser/expr.rs @@ -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 }) } } diff --git a/src/libsyntax/parse/parser/item.rs b/src/libsyntax/parse/parser/item.rs index 59a3ade9c30..be7fc48fdaf 100644 --- a/src/libsyntax/parse/parser/item.rs +++ b/src/libsyntax/parse/parser/item.rs @@ -2,34 +2,36 @@ use super::{Parser, PResult, PathStyle, SemiColonMode, BlockMode}; use crate::maybe_whole; use crate::ptr::P; -use crate::ast::{self, Ident, Attribute, AttrStyle}; -use crate::ast::{Item, ItemKind, ImplItem, TraitItem, TraitItemKind}; -use crate::ast::{UseTree, UseTreeKind, PathSegment}; -use crate::ast::{IsAuto, Constness, IsAsync, Unsafety, Defaultness}; -use crate::ast::{Visibility, VisibilityKind, Mutability, FnDecl, FnHeader}; -use crate::ast::{ForeignItem, ForeignItemKind}; -use crate::ast::{Ty, TyKind, GenericBounds, TraitRef}; -use crate::ast::{EnumDef, VariantData, StructField, AnonConst}; -use crate::ast::{Mac, MacDelimiter}; +use crate::ast::{ + self, DUMMY_NODE_ID, Ident, Attribute, AttrStyle, + Item, ItemKind, ImplItem, TraitItem, TraitItemKind, + UseTree, UseTreeKind, PathSegment, + IsAuto, Constness, IsAsync, Unsafety, Defaultness, + Visibility, VisibilityKind, Mutability, FnDecl, FnHeader, + ForeignItem, ForeignItemKind, + Ty, TyKind, Generics, GenericBounds, TraitRef, + EnumDef, VariantData, StructField, AnonConst, + Mac, MacDelimiter, +}; use crate::ext::base::DummyResult; use crate::parse::token; use crate::parse::parser::maybe_append; -use crate::parse::diagnostics::{Error}; +use crate::parse::diagnostics::Error; use crate::tokenstream::{TokenTree, TokenStream}; use crate::source_map::{respan, Span, Spanned}; use crate::symbol::{kw, sym}; use std::mem; use log::debug; -use rustc_target::spec::abi::{Abi}; +use rustc_target::spec::abi::Abi; use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; -/// Whether the type alias or associated type is a concrete type or an opaque type +/// Whether the type alias or associated type is a concrete type or an opaque type. #[derive(Debug)] pub enum AliasKind { - /// Just a new name for the same type + /// Just a new name for the same type. Weak(P<Ty>), - /// Only trait impls of the type will be usable, not the actual type itself + /// Only trait impls of the type will be usable, not the actual type itself. OpaqueTy(GenericBounds), } @@ -200,7 +202,7 @@ impl<'a> Parser<'a> { return Ok(Some(item)); } - // Parse `async unsafe? fn`. + // Parses `async unsafe? fn`. if self.check_keyword(kw::Async) { let async_span = self.token.span; if self.is_keyword_ahead(1, &[kw::Fn]) @@ -214,8 +216,8 @@ impl<'a> Parser<'a> { let (ident, item_, extra_attrs) = self.parse_item_fn(unsafety, respan(async_span, IsAsync::Async { - closure_id: ast::DUMMY_NODE_ID, - return_impl_trait_id: ast::DUMMY_NODE_ID, + closure_id: DUMMY_NODE_ID, + return_impl_trait_id: DUMMY_NODE_ID, }), respan(fn_span, Constness::NotConst), Abi::Rust)?; @@ -286,7 +288,7 @@ impl<'a> Parser<'a> { && self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) { // UNSAFE FUNCTION ITEM self.bump(); // `unsafe` - // `{` is also expected after `unsafe`, in case of error, include it in the diagnostic + // `{` is also expected after `unsafe`; in case of error, include it in the diagnostic. self.check(&token::OpenDelim(token::Brace)); let abi = if self.eat_keyword(kw::Extern) { self.parse_opt_abi()?.unwrap_or(Abi::C) @@ -521,7 +523,7 @@ impl<'a> Parser<'a> { let mac_lo = self.token.span; - // item macro. + // Item macro let path = self.parse_path(PathStyle::Mod)?; self.expect(&token::Not)?; let (delim, tts) = self.expect_delimited_token_tree()?; @@ -659,7 +661,7 @@ impl<'a> Parser<'a> { let mut generics = if self.choose_generics_over_qpath() { self.parse_generics()? } else { - ast::Generics::default() + Generics::default() }; // Disambiguate `impl !Trait for Type { ... }` and `impl ! { ... }` for the never type. @@ -676,7 +678,7 @@ impl<'a> Parser<'a> { self.look_ahead(1, |t| t != &token::Lt) { let span = self.prev_span.between(self.token.span); self.struct_span_err(span, "missing trait in a trait impl").emit(); - P(Ty { node: TyKind::Path(None, err_path(span)), span, id: ast::DUMMY_NODE_ID }) + P(Ty { node: TyKind::Path(None, err_path(span)), span, id: DUMMY_NODE_ID }) } else { self.parse_ty()? }; @@ -798,7 +800,7 @@ impl<'a> Parser<'a> { self.expect(&token::Eq)?; let expr = self.parse_expr()?; self.expect(&token::Semi)?; - (name, ast::ImplItemKind::Const(typ, expr), ast::Generics::default()) + (name, ast::ImplItemKind::Const(typ, expr), Generics::default()) } else { let (name, inner_attrs, generics, node) = self.parse_impl_method(&vis, at_end)?; attrs.extend(inner_attrs); @@ -806,7 +808,7 @@ impl<'a> Parser<'a> { }; Ok(ImplItem { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(self.prev_span), ident: name, vis, @@ -847,14 +849,13 @@ impl<'a> Parser<'a> { !self.is_keyword_ahead(1, &[kw::Fn, kw::Unsafe]) } - /// Parse a method or a macro invocation in a trait impl. + /// Parses a method or a macro invocation in a trait impl. fn parse_impl_method(&mut self, vis: &Visibility, at_end: &mut bool) - -> PResult<'a, (Ident, Vec<Attribute>, ast::Generics, - ast::ImplItemKind)> { - // code copied from parse_macro_use_or_failure... abstraction! + -> PResult<'a, (Ident, Vec<Attribute>, Generics, ast::ImplItemKind)> { + // FIXME: code copied from `parse_macro_use_or_failure` -- use abstraction! if let Some(mac) = self.parse_assoc_macro_invoc("impl", Some(vis), at_end)? { // method macro - Ok((Ident::invalid(), vec![], ast::Generics::default(), + Ok((Ident::invalid(), vec![], Generics::default(), ast::ImplItemKind::Macro(mac))) } else { let (constness, unsafety, asyncness, abi) = self.parse_fn_front_matter()?; @@ -930,7 +931,7 @@ impl<'a> Parser<'a> { }; if self.eat(&token::Eq) { - // it's a trait alias + // It's a trait alias. let bounds = self.parse_generic_bounds(None)?; tps.where_clause = self.parse_where_clause()?; self.expect(&token::Semi)?; @@ -948,7 +949,7 @@ impl<'a> Parser<'a> { } Ok((ident, ItemKind::TraitAlias(tps, bounds), None)) } else { - // it's a normal trait + // It's a normal trait. tps.where_clause = self.parse_where_clause()?; self.expect(&token::OpenDelim(token::Brace))?; let mut trait_items = vec![]; @@ -1023,10 +1024,10 @@ impl<'a> Parser<'a> { self.expect(&token::Semi)?; None }; - (ident, TraitItemKind::Const(ty, default), ast::Generics::default()) + (ident, TraitItemKind::Const(ty, default), Generics::default()) } else if let Some(mac) = self.parse_assoc_macro_invoc("trait", None, &mut false)? { // trait item macro. - (Ident::invalid(), ast::TraitItemKind::Macro(mac), ast::Generics::default()) + (Ident::invalid(), ast::TraitItemKind::Macro(mac), Generics::default()) } else { let (constness, unsafety, asyncness, abi) = self.parse_fn_front_matter()?; @@ -1089,7 +1090,7 @@ impl<'a> Parser<'a> { }; Ok(TraitItem { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, ident: name, attrs, generics, @@ -1103,7 +1104,7 @@ impl<'a> Parser<'a> { /// /// TraitItemAssocTy = Ident ["<"...">"] [":" [GenericBounds]] ["where" ...] ["=" Ty] fn parse_trait_item_assoc_ty(&mut self) - -> PResult<'a, (Ident, TraitItemKind, ast::Generics)> { + -> PResult<'a, (Ident, TraitItemKind, Generics)> { let ident = self.parse_ident()?; let mut generics = self.parse_generics()?; @@ -1165,7 +1166,7 @@ impl<'a> Parser<'a> { UseTreeKind::Nested(self.parse_use_tree_list()?) } } else { - UseTreeKind::Simple(self.parse_rename()?, ast::DUMMY_NODE_ID, ast::DUMMY_NODE_ID) + UseTreeKind::Simple(self.parse_rename()?, DUMMY_NODE_ID, DUMMY_NODE_ID) } }; @@ -1178,7 +1179,7 @@ impl<'a> Parser<'a> { /// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`] /// ``` fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, ast::NodeId)>> { - self.parse_delim_comma_seq(token::Brace, |p| Ok((p.parse_use_tree()?, ast::DUMMY_NODE_ID))) + self.parse_delim_comma_seq(token::Brace, |p| Ok((p.parse_use_tree()?, DUMMY_NODE_ID))) .map(|(r, _)| r) } @@ -1240,9 +1241,9 @@ impl<'a> Parser<'a> { let mut idents = vec![]; let mut replacement = vec![]; let mut fixed_crate_name = false; - // Accept `extern crate name-like-this` for better diagnostics + // Accept `extern crate name-like-this` for better diagnostics. let dash = token::BinOp(token::BinOpToken::Minus); - if self.token == dash { // Do not include `-` as part of the expected tokens list + if self.token == dash { // Do not include `-` as part of the expected tokens list. while self.eat(&dash) { fixed_crate_name = true; replacement.push((self.prev_span, "_".to_string())); @@ -1283,7 +1284,7 @@ impl<'a> Parser<'a> { } /// Parses the name and optional generic types of a function header. - fn parse_fn_header(&mut self) -> PResult<'a, (Ident, ast::Generics)> { + fn parse_fn_header(&mut self) -> PResult<'a, (Ident, Generics)> { let id = self.parse_ident()?; let generics = self.parse_generics()?; Ok((id, generics)) @@ -1379,7 +1380,7 @@ impl<'a> Parser<'a> { ForeignItem { ident: Ident::invalid(), span: lo.to(self.prev_span), - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, attrs, vis: visibility, node: ForeignItemKind::Macro(mac), @@ -1415,7 +1416,7 @@ impl<'a> Parser<'a> { ident, attrs, node: ForeignItemKind::Fn(decl, generics), - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(hi), vis, }) @@ -1435,7 +1436,7 @@ impl<'a> Parser<'a> { ident, attrs, node: ForeignItemKind::Static(ty, mutbl), - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(hi), vis, }) @@ -1453,7 +1454,7 @@ impl<'a> Parser<'a> { ident, attrs, node: ForeignItemKind::Ty, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(hi), vis }) @@ -1461,7 +1462,7 @@ impl<'a> Parser<'a> { fn is_static_global(&mut self) -> bool { if self.check_keyword(kw::Static) { - // Check if this could be a closure + // Check if this could be a closure. !self.look_ahead(1, |token| { if token.is_keyword(kw::Move) { return true; @@ -1492,7 +1493,7 @@ impl<'a> Parser<'a> { /// Parses `type Foo = Bar;` or returns `None` /// without modifying the parser state. - fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, ast::Generics)>> { + fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, Generics)>> { // This parses the grammar: // Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";" if self.eat_keyword(kw::Type) { @@ -1503,7 +1504,7 @@ impl<'a> Parser<'a> { } /// Parses a type alias or opaque type. - fn parse_type_alias(&mut self) -> PResult<'a, (Ident, AliasKind, ast::Generics)> { + fn parse_type_alias(&mut self) -> PResult<'a, (Ident, AliasKind, Generics)> { let ident = self.parse_ident()?; let mut tps = self.parse_generics()?; tps.where_clause = self.parse_where_clause()?; @@ -1536,7 +1537,7 @@ impl<'a> Parser<'a> { } /// Parses the part of an enum declaration following the `{`. - fn parse_enum_def(&mut self, _generics: &ast::Generics) -> PResult<'a, EnumDef> { + fn parse_enum_def(&mut self, _generics: &Generics) -> PResult<'a, EnumDef> { let mut variants = Vec::new(); while self.token != token::CloseDelim(token::Brace) { let variant_attrs = self.parse_outer_attributes()?; @@ -1552,15 +1553,15 @@ impl<'a> Parser<'a> { } else if self.check(&token::OpenDelim(token::Paren)) { VariantData::Tuple( self.parse_tuple_struct_body()?, - ast::DUMMY_NODE_ID, + DUMMY_NODE_ID, ) } else { - VariantData::Unit(ast::DUMMY_NODE_ID) + VariantData::Unit(DUMMY_NODE_ID) }; let disr_expr = if self.eat(&token::Eq) { Some(AnonConst { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, value: self.parse_expr()?, }) } else { @@ -1569,7 +1570,7 @@ impl<'a> Parser<'a> { let vr = ast::Variant { ident, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, attrs: variant_attrs, data: struct_def, disr_expr, @@ -1622,7 +1623,7 @@ impl<'a> Parser<'a> { generics.where_clause = self.parse_where_clause()?; if self.eat(&token::Semi) { // If we see a: `struct Foo<T> where T: Copy;` style decl. - VariantData::Unit(ast::DUMMY_NODE_ID) + VariantData::Unit(DUMMY_NODE_ID) } else { // If we see: `struct Foo<T> where T: Copy { ... }` let (fields, recovered) = self.parse_record_struct_body()?; @@ -1630,14 +1631,14 @@ impl<'a> Parser<'a> { } // No `where` so: `struct Foo<T>;` } else if self.eat(&token::Semi) { - VariantData::Unit(ast::DUMMY_NODE_ID) + VariantData::Unit(DUMMY_NODE_ID) // Record-style struct definition } else if self.token == token::OpenDelim(token::Brace) { let (fields, recovered) = self.parse_record_struct_body()?; VariantData::Struct(fields, recovered) // Tuple-style struct definition with optional where-clause. } else if self.token == token::OpenDelim(token::Paren) { - let body = VariantData::Tuple(self.parse_tuple_struct_body()?, ast::DUMMY_NODE_ID); + let body = VariantData::Tuple(self.parse_tuple_struct_body()?, DUMMY_NODE_ID); generics.where_clause = self.parse_where_clause()?; self.expect(&token::Semi)?; body @@ -1726,7 +1727,7 @@ impl<'a> Parser<'a> { span: lo.to(ty.span), vis, ident: None, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, ty, attrs, }) @@ -1817,7 +1818,7 @@ impl<'a> Parser<'a> { span: lo.to(self.prev_span), ident: Some(name), vis, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, ty, attrs, }) @@ -1909,7 +1910,7 @@ impl<'a> Parser<'a> { P(Item { ident, attrs, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, node, vis, span, diff --git a/src/libsyntax/parse/parser/module.rs b/src/libsyntax/parse/parser/module.rs index 3f6f87b1c44..2d2fb487d7d 100644 --- a/src/libsyntax/parse/parser/module.rs +++ b/src/libsyntax/parse/parser/module.rs @@ -36,12 +36,12 @@ impl<'a> Parser<'a> { krate } - /// Parse a `mod <foo> { ... }` or `mod <foo>;` item + /// Parses a `mod <foo> { ... }` or `mod <foo>;` item. pub(super) fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<'a, ItemInfo> { let (in_cfg, outer_attrs) = { let mut strip_unconfigured = crate::config::StripUnconfigured { sess: self.sess, - features: None, // don't perform gated feature checking + features: None, // Don't perform gated feature checking. }; let mut outer_attrs = outer_attrs.to_owned(); strip_unconfigured.process_cfg_attrs(&mut outer_attrs); @@ -57,7 +57,7 @@ impl<'a> Parser<'a> { self.submod_path(id, &outer_attrs, id_span)?; let (module, mut attrs) = self.eval_src_mod(path, directory_ownership, id.to_string(), id_span)?; - // Record that we fetched the mod from an external file + // Record that we fetched the mod from an external file. if warn { let attr = attr::mk_attr_outer( attr::mk_word_item(Ident::with_dummy_span(sym::warn_directory_ownership))); diff --git a/src/libsyntax/parse/parser/pat.rs b/src/libsyntax/parse/parser/pat.rs index 669f657160b..49f8d58c6a7 100644 --- a/src/libsyntax/parse/parser/pat.rs +++ b/src/libsyntax/parse/parser/pat.rs @@ -844,14 +844,14 @@ impl<'a> Parser<'a> { // Check if a colon exists one ahead. This means we're parsing a fieldname. let hi; let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) { - // Parsing a pattern of the form "fieldname: pat" + // Parsing a pattern of the form `fieldname: pat`. let fieldname = self.parse_field_name()?; self.bump(); let pat = self.parse_pat_with_or_inner()?; hi = pat.span; (pat, fieldname, false) } else { - // Parsing a pattern of the form "(box) (ref) (mut) fieldname" + // Parsing a pattern of the form `(box) (ref) (mut) fieldname`. let is_box = self.eat_keyword(kw::Box); let boxed_span = self.token.span; let is_ref = self.eat_keyword(kw::Ref); diff --git a/src/libsyntax/parse/parser/stmt.rs b/src/libsyntax/parse/parser/stmt.rs index 748c1a168b0..6a3ac2d73f8 100644 --- a/src/libsyntax/parse/parser/stmt.rs +++ b/src/libsyntax/parse/parser/stmt.rs @@ -5,12 +5,12 @@ use super::pat::GateOr; use crate::ptr::P; use crate::{maybe_whole, ThinVec}; -use crate::ast::{self, Stmt, StmtKind, Local, Block, BlockCheckMode, Expr, ExprKind}; +use crate::ast::{self, DUMMY_NODE_ID, Stmt, StmtKind, Local, Block, BlockCheckMode, Expr, ExprKind}; use crate::ast::{Attribute, AttrStyle, VisibilityKind, MacStmtStyle, Mac, MacDelimiter}; use crate::ext::base::DummyResult; use crate::parse::{classify, DirectoryOwnership}; use crate::parse::diagnostics::Error; -use crate::parse::token::{self}; +use crate::parse::token; use crate::source_map::{respan, Span}; use crate::symbol::{kw, sym}; @@ -18,7 +18,7 @@ use std::mem; use errors::Applicability; impl<'a> Parser<'a> { - /// Parse a statement. This stops just before trailing semicolons on everything but items. + /// Parses a statement. This stops just before trailing semicolons on everything but items. /// e.g., a `StmtKind::Semi` parses to a `StmtKind::Expr`, leaving the trailing `;` unconsumed. pub fn parse_stmt(&mut self) -> PResult<'a, Option<Stmt>> { Ok(self.parse_stmt_(true)) @@ -43,7 +43,7 @@ impl<'a> Parser<'a> { Ok(Some(if self.eat_keyword(kw::Let) { Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, node: StmtKind::Local(self.parse_local(attrs.into())?), span: lo.to(self.prev_span), } @@ -53,7 +53,7 @@ impl<'a> Parser<'a> { lo, )? { Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, node: StmtKind::Item(macro_def), span: lo.to(self.prev_span), } @@ -85,7 +85,7 @@ impl<'a> Parser<'a> { })?; return Ok(Some(Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, node: StmtKind::Expr(expr), span: lo.to(self.prev_span), })); @@ -114,17 +114,17 @@ impl<'a> Parser<'a> { // We used to incorrectly stop parsing macro-expanded statements here. // If the next token will be an error anyway but could have parsed with the // earlier behavior, stop parsing here and emit a warning to avoid breakage. - else if macro_legacy_warnings && - self.token.can_begin_expr() && - match self.token.kind { - // These can continue an expression, so we can't stop parsing and warn. - token::OpenDelim(token::Paren) | token::OpenDelim(token::Bracket) | - token::BinOp(token::Minus) | token::BinOp(token::Star) | - token::BinOp(token::And) | token::BinOp(token::Or) | - token::AndAnd | token::OrOr | - token::DotDot | token::DotDotDot | token::DotDotEq => false, - _ => true, - } { + else if macro_legacy_warnings && self.token.can_begin_expr() && + match self.token.kind { + // These can continue an expression, so we can't stop parsing and warn. + token::OpenDelim(token::Paren) | token::OpenDelim(token::Bracket) | + token::BinOp(token::Minus) | token::BinOp(token::Star) | + token::BinOp(token::And) | token::BinOp(token::Or) | + token::AndAnd | token::OrOr | + token::DotDot | token::DotDotDot | token::DotDotEq => false, + _ => true, + } + { self.warn_missing_semicolon(); StmtKind::Mac(P((mac, style, attrs.into()))) } else { @@ -135,7 +135,7 @@ impl<'a> Parser<'a> { StmtKind::Expr(e) }; Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(hi), node, } @@ -148,7 +148,7 @@ impl<'a> Parser<'a> { match item { Some(i) => Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(i.span), node: StmtKind::Item(i), }, @@ -178,7 +178,7 @@ impl<'a> Parser<'a> { // an empty tuple that spans the excess semicolons // to preserve this info until the lint stage return Ok(Some(Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(last_semi), node: StmtKind::Semi(self.mk_expr(lo.to(last_semi), ExprKind::Tup(Vec::new()), @@ -196,7 +196,7 @@ impl<'a> Parser<'a> { let e = self.parse_expr_res( Restrictions::STMT_EXPR, Some(attrs.into()))?; Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(e.span), node: StmtKind::Expr(e), } @@ -218,7 +218,7 @@ impl<'a> Parser<'a> { match self.parse_ty() { Ok(ty) => (None, Some(ty)), Err(mut err) => { - // Rewind to before attempting to parse the type and continue parsing + // Rewind to before attempting to parse the type and continue parsing. let parser_snapshot_after_type = self.clone(); mem::replace(self, parser_snapshot_before_type); @@ -272,7 +272,7 @@ impl<'a> Parser<'a> { ty, pat, init, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, span: lo.to(hi), attrs, })) @@ -334,18 +334,18 @@ impl<'a> Parser<'a> { // if (cond) // bar; // - // Which is valid in other languages, but not Rust. + // which is valid in other languages, but not Rust. match self.parse_stmt_without_recovery(false) { Ok(Some(stmt)) => { if self.look_ahead(1, |t| t == &token::OpenDelim(token::Brace)) || do_not_suggest_help { - // if the next token is an open brace (e.g., `if a b {`), the place- - // inside-a-block suggestion would be more likely wrong than right + // If the next token is an open brace (e.g., `if a b {`), the place- + // inside-a-block suggestion would be more likely wrong than right. e.span_label(sp, "expected `{`"); return Err(e); } let mut stmt_span = stmt.span; - // expand the span to include the semicolon, if it exists + // Expand the span to include the semicolon, if it exists. if self.eat(&token::Semi) { stmt_span = stmt_span.with_hi(self.prev_span.hi()); } @@ -354,7 +354,7 @@ impl<'a> Parser<'a> { stmt_span, "try placing this code inside a block", format!("{{ {} }}", snippet), - // speculative, has been misleading in the past (#46836) + // Speculative; has been misleading in the past (#46836). Applicability::MaybeIncorrect, ); } @@ -399,7 +399,7 @@ impl<'a> Parser<'a> { err.emit(); self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore); Some(Stmt { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, node: StmtKind::Expr(DummyResult::raw_expr(self.token.span, true)), span: self.token.span, }) @@ -415,15 +415,15 @@ impl<'a> Parser<'a> { } Ok(P(ast::Block { stmts, - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, rules: s, span: lo.to(self.prev_span), })) } /// Parses a statement, including the trailing semicolon. - crate fn parse_full_stmt(&mut self, macro_legacy_warnings: bool) -> PResult<'a, Option<Stmt>> { - // skip looking for a trailing semicolon when we have an interpolated statement + pub fn parse_full_stmt(&mut self, macro_legacy_warnings: bool) -> PResult<'a, Option<Stmt>> { + // Skip looking for a trailing semicolon when we have an interpolated statement. maybe_whole!(self, NtStmt, |x| Some(x)); let mut stmt = match self.parse_stmt_without_recovery(macro_legacy_warnings)? { |