use crate::ast::StrStyle;
use crate::ast::SelfKind;
use crate::ast::{GenericParam, GenericParamKind, WhereClause};
-use crate::ast::{Ty, TyKind, GenericBounds};
+use crate::ast::{TyKind, GenericBounds};
use crate::ast::{Visibility, VisibilityKind, Unsafety, CrateSugar};
use crate::ext::base::DummyResult;
use crate::ext::hygiene::SyntaxContext;
Ok(Arg { attrs: attrs.into(), id: ast::DUMMY_NODE_ID, pat, span, ty })
}
- /// Parses an argument in a lambda header (e.g., `|arg, arg|`).
- fn parse_fn_block_arg(&mut self) -> PResult<'a, Arg> {
- let lo = self.token.span;
- let attrs = self.parse_arg_attributes()?;
- let pat = self.parse_pat(Some("argument name"))?;
- let t = if self.eat(&token::Colon) {
- self.parse_ty()?
- } else {
- P(Ty {
- id: ast::DUMMY_NODE_ID,
- node: TyKind::Infer,
- span: self.prev_span,
- })
- };
- let span = lo.to(self.token.span);
- Ok(Arg {
- attrs: attrs.into(),
- ty: t,
- pat,
- span,
- id: ast::DUMMY_NODE_ID
- })
- }
-
crate fn check_lifetime(&mut self) -> bool {
self.expected_tokens.push(TokenType::Lifetime);
self.token.is_lifetime()
}))
}
- /// Parses the `|arg, arg|` header of a closure.
- fn parse_fn_block_decl(&mut self) -> PResult<'a, P<FnDecl>> {
- let inputs_captures = {
- if self.eat(&token::OrOr) {
- Vec::new()
- } else {
- self.expect(&token::BinOp(token::Or))?;
- let args = self.parse_seq_to_before_tokens(
- &[&token::BinOp(token::Or), &token::OrOr],
- SeqSep::trailing_allowed(token::Comma),
- TokenExpectType::NoExpect,
- |p| p.parse_fn_block_arg()
- )?.0;
- self.expect_or()?;
- args
- }
- };
- let output = self.parse_ret_ty(true)?;
-
- Ok(P(FnDecl {
- inputs: inputs_captures,
- output,
- c_variadic: false
- }))
- }
-
fn choose_generics_over_qpath(&self) -> bool {
// There's an ambiguity between generic parameters and qualified paths in impls.
// If we see `<` it may start both, so we have to inspect some following tokens.
use super::{Parser, PResult, Restrictions, PrevTokenKind, TokenType, PathStyle};
use super::{BlockCheckMode, BlockMode, SemiColonMode};
-use super::SeqSep;
-
-use crate::{maybe_recover_from_interpolated_ty_qpath};
+use super::{SeqSep, TokenExpectType};
+use crate::maybe_recover_from_interpolated_ty_qpath;
use crate::ptr::P;
-use crate::ast;
-use crate::ast::{Attribute, AttrStyle};
+use crate::ast::{self, Attribute, AttrStyle};
use crate::ast::{Ident, CaptureBy};
use crate::ast::{Expr, ExprKind, RangeLimits, Label, Movability, IsAsync, Arm};
-use crate::ast::{Ty, TyKind, FunctionRetTy};
+use crate::ast::{Ty, TyKind, FunctionRetTy, Arg, FnDecl};
use crate::ast::{BinOpKind, BinOp, UnOp};
use crate::ast::{Mac_, AnonConst, Field};
use crate::util::parser::{AssocOp, Fixity, prec_let_scrutinee_needs_par};
use std::mem;
-
-use errors::{Applicability};
-
+use errors::Applicability;
use rustc_data_structures::thin_vec::ThinVec;
/// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression
}
}
+ /// Parses the `|arg, arg|` header of a closure.
+ fn parse_fn_block_decl(&mut self) -> PResult<'a, P<FnDecl>> {
+ let inputs_captures = {
+ if self.eat(&token::OrOr) {
+ Vec::new()
+ } else {
+ self.expect(&token::BinOp(token::Or))?;
+ let args = self.parse_seq_to_before_tokens(
+ &[&token::BinOp(token::Or), &token::OrOr],
+ SeqSep::trailing_allowed(token::Comma),
+ TokenExpectType::NoExpect,
+ |p| p.parse_fn_block_arg()
+ )?.0;
+ self.expect_or()?;
+ args
+ }
+ };
+ let output = self.parse_ret_ty(true)?;
+
+ Ok(P(FnDecl {
+ inputs: inputs_captures,
+ output,
+ c_variadic: false
+ }))
+ }
+
+ /// Parses an argument in a lambda header (e.g., `|arg, arg|`).
+ fn parse_fn_block_arg(&mut self) -> PResult<'a, Arg> {
+ let lo = self.token.span;
+ let attrs = self.parse_arg_attributes()?;
+ let pat = self.parse_pat(Some("argument name"))?;
+ let t = if self.eat(&token::Colon) {
+ self.parse_ty()?
+ } else {
+ P(Ty {
+ id: ast::DUMMY_NODE_ID,
+ node: TyKind::Infer,
+ span: self.prev_span,
+ })
+ };
+ let span = lo.to(self.token.span);
+ Ok(Arg {
+ attrs: attrs.into(),
+ ty: t,
+ pat,
+ span,
+ id: ast::DUMMY_NODE_ID
+ })
+ }
+
/// Parses an `if` expression (`if` token already eaten).
fn parse_if_expr(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
let lo = self.prev_span;