Lines Matching refs:input
261 pub fn parse_single(input: ParseStream) -> Result<Self> {
262 let begin = input.fork();
263 let lookahead = input.lookahead1();
265 && (input.peek2(Token![::])
266 || input.peek2(Token![!])
267 || input.peek2(token::Brace)
268 || input.peek2(token::Paren)
269 || input.peek2(Token![..]))
270 || input.peek(Token![self]) && input.peek2(Token![::])
273 || input.peek(Token![Self])
274 || input.peek(Token![super])
275 || input.peek(Token![crate])
277 pat_path_or_macro_or_struct_or_range(input)
279 input.call(pat_wild).map(Pat::Wild)
280 } else if input.peek(Token![box]) {
281 pat_box(begin, input)
282 } else if input.peek(Token![-]) || lookahead.peek(Lit) || lookahead.peek(Token![const])
284 pat_lit_or_range(input)
287 || input.peek(Token![self])
288 || input.peek(Ident)
290 input.call(pat_ident).map(Pat::Ident)
292 input.call(pat_reference).map(Pat::Reference)
294 input.call(pat_paren_or_tuple)
296 input.call(pat_slice).map(Pat::Slice)
297 } else if lookahead.peek(Token![..]) && !input.peek(Token![...]) {
298 pat_range_half_open(input)
300 input.call(pat_const).map(Pat::Verbatim)
307 pub fn parse_multi(input: ParseStream) -> Result<Self> {
308 multi_pat_impl(input, None)
352 /// macro-generated macro input.
353 pub fn parse_multi_with_leading_vert(input: ParseStream) -> Result<Self> {
354 let leading_vert: Option<Token![|]> = input.parse()?;
355 multi_pat_impl(input, leading_vert)
361 fn parse(input: ParseStream) -> Result<Self> {
364 pat: Box::new(Pat::parse_single(input)?),
365 colon_token: input.parse()?,
366 ty: input.parse()?,
371 fn multi_pat_impl(input: ParseStream, leading_vert: Option<Token![|]>) -> Result<Pat> {
372 let mut pat = Pat::parse_single(input)?;
374 || input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=])
378 while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {
379 let punct = input.parse()?;
381 let pat = Pat::parse_single(input)?;
393 fn pat_path_or_macro_or_struct_or_range(input: ParseStream) -> Result<Pat> {
394 let (qself, path) = path::parsing::qpath(input, true)?;
397 && input.peek(Token![!])
398 && !input.peek(Token![!=])
401 let bang_token: Token![!] = input.parse()?;
402 let (delimiter, tokens) = mac::parse_delimiter(input)?;
414 if input.peek(token::Brace) {
415 pat_struct(input, qself, path).map(Pat::Struct)
416 } else if input.peek(token::Paren) {
417 pat_tuple_struct(input, qself, path).map(Pat::TupleStruct)
418 } else if input.peek(Token![..]) {
419 pat_range(input, qself, path)
429 fn pat_wild(input: ParseStream) -> Result<PatWild> {
432 underscore_token: input.parse()?,
436 fn pat_box(begin: ParseBuffer, input: ParseStream) -> Result<Pat> {
437 input.parse::<Token![box]>()?;
438 Pat::parse_single(input)?;
439 Ok(Pat::Verbatim(verbatim::between(&begin, input)))
442 fn pat_ident(input: ParseStream) -> Result<PatIdent> {
445 by_ref: input.parse()?,
446 mutability: input.parse()?,
447 ident: input.call(Ident::parse_any)?,
449 if input.peek(Token![@]) {
450 let at_token: Token![@] = input.parse()?;
451 let subpat = Pat::parse_single(input)?;
461 input: ParseStream,
466 let paren_token = parenthesized!(content in input);
488 fn pat_struct(input: ParseStream, qself: Option<QSelf>, path: Path) -> Result<PatStruct> {
490 let brace_token = braced!(content in input);
523 fn field_pat(input: ParseStream) -> Result<FieldPat> {
524 let begin = input.fork();
525 let boxed: Option<Token![box]> = input.parse()?;
526 let by_ref: Option<Token![ref]> = input.parse()?;
527 let mutability: Option<Token![mut]> = input.parse()?;
530 input.parse().map(Member::Named)
532 input.parse()
535 if boxed.is_none() && by_ref.is_none() && mutability.is_none() && input.peek(Token![:])
541 colon_token: Some(input.parse()?),
542 pat: Box::new(Pat::parse_multi_with_leading_vert(input)?),
552 Pat::Verbatim(verbatim::between(&begin, input))
571 fn pat_range(input: ParseStream, qself: Option<QSelf>, path: Path) -> Result<Pat> {
572 let limits = RangeLimits::parse_obsolete(input)?;
573 let end = input.call(pat_range_bound)?;
575 return Err(input.error("expected range upper bound"));
589 fn pat_range_half_open(input: ParseStream) -> Result<Pat> {
590 let limits: RangeLimits = input.parse()?;
591 let end = input.call(pat_range_bound)?;
605 RangeLimits::Closed(_) => Err(input.error("expected range upper bound")),
610 fn pat_paren_or_tuple(input: ParseStream) -> Result<Pat> {
612 let paren_token = parenthesized!(content in input);
640 fn pat_reference(input: ParseStream) -> Result<PatReference> {
643 and_token: input.parse()?,
644 mutability: input.parse()?,
645 pat: Box::new(Pat::parse_single(input)?),
649 fn pat_lit_or_range(input: ParseStream) -> Result<Pat> {
650 let start = input.call(pat_range_bound)?.unwrap();
651 if input.peek(Token![..]) {
652 let limits = RangeLimits::parse_obsolete(input)?;
653 let end = input.call(pat_range_bound)?;
655 return Err(input.error("expected range upper bound"));
693 fn pat_range_bound(input: ParseStream) -> Result<Option<PatRangeBound>> {
694 if input.is_empty()
695 || input.peek(Token![|])
696 || input.peek(Token![=])
697 || input.peek(Token![:]) && !input.peek(Token![::])
698 || input.peek(Token![,])
699 || input.peek(Token![;])
700 || input.peek(Token![if])
705 let lookahead = input.lookahead1();
707 PatRangeBound::Lit(input.parse()?)
716 PatRangeBound::Path(input.parse()?)
718 PatRangeBound::Const(input.parse()?)
726 fn pat_slice(input: ParseStream) -> Result<PatSlice> {
728 let bracket_token = bracketed!(content in input);
761 fn pat_const(input: ParseStream) -> Result<TokenStream> {
762 let begin = input.fork();
763 input.parse::<Token![const]>()?;
766 braced!(content in input);
770 Ok(verbatim::between(&begin, input))