289         pub fn parse_single(input: ParseStream) -> Result<Self> {  in parse_single()
290             let begin = input.fork();  in parse_single()
291             let lookahead = input.lookahead1();  in parse_single()
293                 && (input.peek2(Token![::])  in parse_single()
294                     || input.peek2(Token![!])  in parse_single()
295                     || input.peek2(token::Brace)  in parse_single()
296                     || input.peek2(token::Paren)  in parse_single()
297                     || input.peek2(Token![..]))  in parse_single()
298                 || input.peek(Token![self]) && input.peek2(Token![::])  in parse_single()
301                 || input.peek(Token![Self])  in parse_single()
302                 || input.peek(Token![super])  in parse_single()
303                 || input.peek(Token![crate])  in parse_single()
305                 pat_path_or_macro_or_struct_or_range(input)  in parse_single()
307                 input.call(pat_wild).map(Pat::Wild)  in parse_single()
308             } else if input.peek(Token![box]) {  in parse_single()
309                 pat_box(begin, input)  in parse_single()
310             } else if input.peek(Token![-]) || lookahead.peek(Lit) || lookahead.peek(Token![const])  in parse_single()
312                 pat_lit_or_range(input)  in parse_single()
315                 || input.peek(Token![self])  in parse_single()
316                 || input.peek(Ident)  in parse_single()
318                 input.call(pat_ident).map(Pat::Ident)  in parse_single()
320                 input.call(pat_reference).map(Pat::Reference)  in parse_single()
322                 input.call(pat_paren_or_tuple)  in parse_single()
324                 input.call(pat_slice).map(Pat::Slice)  in parse_single()
325             } else if lookahead.peek(Token![..]) && !input.peek(Token![...]) {  in parse_single()
326                 pat_range_half_open(input)  in parse_single()
328                 input.call(pat_const).map(Pat::Verbatim)  in parse_single()
335         pub fn parse_multi(input: ParseStream) -> Result<Self> {  in parse_multi()
336             multi_pat_impl(input, None)  in parse_multi()
381         pub fn parse_multi_with_leading_vert(input: ParseStream) -> Result<Self> {  in parse_multi_with_leading_vert()
382             let leading_vert: Option<Token![|]> = input.parse()?;  in parse_multi_with_leading_vert()
383             multi_pat_impl(input, leading_vert)  in parse_multi_with_leading_vert()
389         fn parse(input: ParseStream) -> Result<Self> {  in parse()
392                 pat: Box::new(Pat::parse_single(input)?),  in parse()
393                 colon_token: input.parse()?,  in parse()
394                 ty: input.parse()?,  in parse()
399     fn multi_pat_impl(input: ParseStream, leading_vert: Option<Token![|]>) -> Result<Pat> {  in multi_pat_impl()
400         let mut pat = Pat::parse_single(input)?;  in multi_pat_impl()
402             || input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=])  in multi_pat_impl()
406             while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {  in multi_pat_impl()
407                 let punct = input.parse()?;  in multi_pat_impl()
409                 let pat = Pat::parse_single(input)?;  in multi_pat_impl()
421     fn pat_path_or_macro_or_struct_or_range(input: ParseStream) -> Result<Pat> {  in pat_path_or_macro_or_struct_or_range()
423         let (qself, path) = path::parsing::qpath(input, expr_style)?;  in pat_path_or_macro_or_struct_or_range()
426             && input.peek(Token![!])  in pat_path_or_macro_or_struct_or_range()
427             && !input.peek(Token![!=])  in pat_path_or_macro_or_struct_or_range()
430             let bang_token: Token![!] = input.parse()?;  in pat_path_or_macro_or_struct_or_range()
431             let (delimiter, tokens) = mac::parse_delimiter(input)?;  in pat_path_or_macro_or_struct_or_range()
443         if input.peek(token::Brace) {  in pat_path_or_macro_or_struct_or_range()
444             pat_struct(input, qself, path).map(Pat::Struct)  in pat_path_or_macro_or_struct_or_range()
445         } else if input.peek(token::Paren) {  in pat_path_or_macro_or_struct_or_range()
446             pat_tuple_struct(input, qself, path).map(Pat::TupleStruct)  in pat_path_or_macro_or_struct_or_range()
447         } else if input.peek(Token![..]) {  in pat_path_or_macro_or_struct_or_range()
448             pat_range(input, qself, path)  in pat_path_or_macro_or_struct_or_range()
458     fn pat_wild(input: ParseStream) -> Result<PatWild> {  in pat_wild()
461             underscore_token: input.parse()?,  in pat_wild()
465     fn pat_box(begin: ParseBuffer, input: ParseStream) -> Result<Pat> {  in pat_box()
466         input.parse::<Token![box]>()?;  in pat_box()
467         Pat::parse_single(input)?;  in pat_box()
468         Ok(Pat::Verbatim(verbatim::between(&begin, input)))  in pat_box()
471     fn pat_ident(input: ParseStream) -> Result<PatIdent> {  in pat_ident()
474             by_ref: input.parse()?,  in pat_ident()
475             mutability: input.parse()?,  in pat_ident()
477                 if input.peek(Token![self]) {  in pat_ident()
478                     input.call(Ident::parse_any)?  in pat_ident()
480                     input.parse()?  in pat_ident()
484                 if input.peek(Token![@]) {  in pat_ident()
485                     let at_token: Token![@] = input.parse()?;  in pat_ident()
486                     let subpat = Pat::parse_single(input)?;  in pat_ident()
496         input: ParseStream,  in pat_tuple_struct()
501         let paren_token = parenthesized!(content in input);  in pat_tuple_struct()
523     fn pat_struct(input: ParseStream, qself: Option<QSelf>, path: Path) -> Result<PatStruct> {  in pat_struct()
525         let brace_token = braced!(content in input);  in pat_struct()
558     fn field_pat(input: ParseStream) -> Result<FieldPat> {  in field_pat()
559         let begin = input.fork();  in field_pat()
560         let boxed: Option<Token![box]> = input.parse()?;  in field_pat()
561         let by_ref: Option<Token![ref]> = input.parse()?;  in field_pat()
562         let mutability: Option<Token![mut]> = input.parse()?;  in field_pat()
565             input.parse().map(Member::Named)  in field_pat()
567             input.parse()  in field_pat()
570         if boxed.is_none() && by_ref.is_none() && mutability.is_none() && input.peek(Token![:])  in field_pat()
576                 colon_token: Some(input.parse()?),  in field_pat()
577                 pat: Box::new(Pat::parse_multi_with_leading_vert(input)?),  in field_pat()
587             Pat::Verbatim(verbatim::between(&begin, input))  in field_pat()
606     fn pat_range(input: ParseStream, qself: Option<QSelf>, path: Path) -> Result<Pat> {  in pat_range()
607         let limits = RangeLimits::parse_obsolete(input)?;  in pat_range()
608         let end = input.call(pat_range_bound)?;  in pat_range()
610             return Err(input.error("expected range upper bound"));  in pat_range()
624     fn pat_range_half_open(input: ParseStream) -> Result<Pat> {  in pat_range_half_open()
625         let limits: RangeLimits = input.parse()?;  in pat_range_half_open()
626         let end = input.call(pat_range_bound)?;  in pat_range_half_open()
640                 RangeLimits::Closed(_) => Err(input.error("expected range upper bound")),  in pat_range_half_open()
645     fn pat_paren_or_tuple(input: ParseStream) -> Result<Pat> {  in pat_paren_or_tuple()
647         let paren_token = parenthesized!(content in input);  in pat_paren_or_tuple()
675     fn pat_reference(input: ParseStream) -> Result<PatReference> {  in pat_reference()
678             and_token: input.parse()?,  in pat_reference()
679             mutability: input.parse()?,  in pat_reference()
680             pat: Box::new(Pat::parse_single(input)?),  in pat_reference()
684     fn pat_lit_or_range(input: ParseStream) -> Result<Pat> {  in pat_lit_or_range()
685         let start = input.call(pat_range_bound)?.unwrap();  in pat_lit_or_range()
686         if input.peek(Token![..]) {  in pat_lit_or_range()
687             let limits = RangeLimits::parse_obsolete(input)?;  in pat_lit_or_range()
688             let end = input.call(pat_range_bound)?;  in pat_lit_or_range()
690                 return Err(input.error("expected range upper bound"));  in pat_lit_or_range()
728     fn pat_range_bound(input: ParseStream) -> Result<Option<PatRangeBound>> {  in pat_range_bound()
729         if input.is_empty()  in pat_range_bound()
730             || input.peek(Token![|])  in pat_range_bound()
731             || input.peek(Token![=])  in pat_range_bound()
732             || input.peek(Token![:]) && !input.peek(Token![::])  in pat_range_bound()
733             || input.peek(Token![,])  in pat_range_bound()
734             || input.peek(Token![;])  in pat_range_bound()
735             || input.peek(Token![if])  in pat_range_bound()
740         let lookahead = input.lookahead1();  in pat_range_bound()
742             PatRangeBound::Lit(input.parse()?)  in pat_range_bound()
751             PatRangeBound::Path(input.parse()?)  in pat_range_bound()
753             PatRangeBound::Const(input.parse()?)  in pat_range_bound()
761     fn pat_slice(input: ParseStream) -> Result<PatSlice> {  in pat_slice()
763         let bracket_token = bracketed!(content in input);  in pat_slice()
796     fn pat_const(input: ParseStream) -> Result<TokenStream> {  in pat_const()
797         let begin = input.fork();  in pat_const()
798         input.parse::<Token![const]>()?;  in pat_const()
801         braced!(content in input);  in pat_const()
805         Ok(verbatim::between(&begin, input))  in pat_const()