Lines Matching refs:input
1040 fn parse(input: ParseStream) -> Result<Self> {
1042 input,
1132 pub fn parse_without_eager_brace(input: ParseStream) -> Result<Expr> {
1133 ambiguous_expr(input, AllowStruct(false))
1170 fn can_begin_expr(input: ParseStream) -> bool {
1171 input.peek(Ident::peek_any) // value name or keyword
1172 || input.peek(token::Paren) // tuple
1173 || input.peek(token::Bracket) // array
1174 || input.peek(token::Brace) // block
1175 || input.peek(Lit) // literal
1176 || input.peek(Token![!]) && !input.peek(Token![!=]) // operator not
1177 || input.peek(Token![-]) && !input.peek(Token![-=]) && !input.peek(Token![->]) // unary minus
1178 || input.peek(Token![*]) && !input.peek(Token![*=]) // dereference
1179 || input.peek(Token![|]) && !input.peek(Token![|=]) // closure
1180 || input.peek(Token![&]) && !input.peek(Token![&=]) // reference
1181 || input.peek(Token![..]) // range notation
1182 || input.peek(Token![<]) && !input.peek(Token![<=]) && !input.peek(Token![<<=]) // associated path
1183 || input.peek(Token![::]) // global path
1184 || input.peek(Lifetime) // labeled loop
1185 || input.peek(Token![#]) // expression attributes
1190 input: ParseStream,
1196 let ahead = input.fork();
1201 input.advance_to(&ahead);
1203 let mut rhs = unary_expr(input, allow_struct)?;
1205 let next = peek_precedence(input);
1207 rhs = parse_expr(input, rhs, allow_struct, next)?;
1219 && input.peek(Token![=])
1220 && !input.peek(Token![==])
1221 && !input.peek(Token![=>])
1223 let eq_token: Token![=] = input.parse()?;
1224 let mut rhs = unary_expr(input, allow_struct)?;
1226 let next = peek_precedence(input);
1228 rhs = parse_expr(input, rhs, allow_struct, next)?;
1239 } else if Precedence::Range >= base && input.peek(Token![..]) {
1240 let limits: RangeLimits = input.parse()?;
1242 && (input.is_empty()
1243 || input.peek(Token![,])
1244 || input.peek(Token![;])
1245 || input.peek(Token![.]) && !input.peek(Token![..])
1246 || !allow_struct.0 && input.peek(token::Brace))
1250 let mut rhs = unary_expr(input, allow_struct)?;
1252 let next = peek_precedence(input);
1254 rhs = parse_expr(input, rhs, allow_struct, next)?;
1267 } else if Precedence::Cast >= base && input.peek(Token![as]) {
1268 let as_token: Token![as] = input.parse()?;
1271 let ty = ty::parsing::ambig_ty(input, allow_plus, allow_group_generic)?;
1272 check_cast(input)?;
1287 fn parse_expr(input: ParseStream, mut lhs: Expr, base: Precedence) -> Result<Expr> {
1289 let ahead = input.fork();
1294 input.advance_to(&ahead);
1296 let mut rhs = unary_expr(input)?;
1298 let next = peek_precedence(input);
1300 rhs = parse_expr(input, rhs, next)?;
1311 } else if Precedence::Cast >= base && input.peek(Token![as]) {
1312 let as_token: Token![as] = input.parse()?;
1315 let ty = ty::parsing::ambig_ty(input, allow_plus, allow_group_generic)?;
1316 check_cast(input)?;
1330 fn peek_precedence(input: ParseStream) -> Precedence {
1331 if let Ok(op) = input.fork().parse() {
1333 } else if input.peek(Token![=]) && !input.peek(Token![=>]) {
1335 } else if input.peek(Token![..]) {
1337 } else if input.peek(Token![as]) {
1346 input: ParseStream,
1350 input,
1355 input,
1364 fn expr_attrs(input: ParseStream) -> Result<Vec<Attribute>> {
1366 while !input.peek(token::Group) && input.peek(Token![#]) {
1367 attrs.push(input.call(attr::parsing::single_parse_outer)?);
1377 fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
1378 let begin = input.fork();
1379 let attrs = input.call(expr_attrs)?;
1380 if input.peek(token::Group) {
1381 return trailer_expr(begin, attrs, input, allow_struct);
1384 if input.peek(Token![&]) {
1385 let and_token: Token![&] = input.parse()?;
1386 let raw: Option<kw::raw> = if input.peek(kw::raw)
1387 && (input.peek2(Token![mut]) || input.peek2(Token![const]))
1389 Some(input.parse()?)
1393 let mutability: Option<Token![mut]> = input.parse()?;
1395 input.parse::<Token![const]>()?;
1397 let expr = Box::new(unary_expr(input, allow_struct)?);
1399 Ok(Expr::Verbatim(verbatim::between(&begin, input)))
1408 } else if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) {
1409 expr_unary(input, attrs, allow_struct).map(Expr::Unary)
1411 trailer_expr(begin, attrs, input, allow_struct)
1416 fn unary_expr(input: ParseStream) -> Result<Expr> {
1417 if input.peek(Token![&]) {
1420 and_token: input.parse()?,
1421 mutability: input.parse()?,
1422 expr: Box::new(unary_expr(input)?),
1424 } else if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) {
1427 op: input.parse()?,
1428 expr: Box::new(unary_expr(input)?),
1431 trailer_expr(input)
1445 input: ParseStream,
1448 let atom = atom_expr(input, allow_struct)?;
1449 let mut e = trailer_helper(input, atom)?;
1452 *tokens = verbatim::between(&begin, input);
1463 fn trailer_helper(input: ParseStream, mut e: Expr) -> Result<Expr> {
1465 if input.peek(token::Paren) {
1470 paren_token: parenthesized!(content in input),
1473 } else if input.peek(Token![.])
1474 && !input.peek(Token![..])
1480 let mut dot_token: Token![.] = input.parse()?;
1482 let float_token: Option<LitFloat> = input.parse()?;
1489 let await_token: Option<Token![await]> = input.parse()?;
1500 let member: Member = input.parse()?;
1501 let turbofish = if member.is_named() && input.peek(Token![::]) {
1502 Some(AngleBracketedGenericArguments::parse_turbofish(input)?)
1507 if turbofish.is_some() || input.peek(token::Paren) {
1516 paren_token: parenthesized!(content in input),
1529 } else if input.peek(token::Bracket) {
1534 bracket_token: bracketed!(content in input),
1537 } else if input.peek(Token![?]) {
1541 question_token: input.parse()?,
1551 fn trailer_expr(input: ParseStream) -> Result<Expr> {
1552 let mut e = atom_expr(input)?;
1555 if input.peek(token::Paren) {
1560 paren_token: parenthesized!(content in input),
1563 } else if input.peek(Token![.])
1564 && !input.peek(Token![..])
1565 && !input.peek2(Token![await])
1567 let mut dot_token: Token![.] = input.parse()?;
1569 let float_token: Option<LitFloat> = input.parse()?;
1576 let member: Member = input.parse()?;
1577 let turbofish = if member.is_named() && input.peek(Token![::]) {
1578 let colon2_token: Token![::] = input.parse()?;
1580 AngleBracketedGenericArguments::do_parse(Some(colon2_token), input)?;
1586 if turbofish.is_some() || input.peek(token::Paren) {
1595 paren_token: parenthesized!(content in input),
1608 } else if input.peek(token::Bracket) {
1613 bracket_token: bracketed!(content in input),
1627 fn atom_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
1628 if input.peek(token::Group) {
1629 expr_group(input, allow_struct)
1630 } else if input.peek(Lit) {
1631 input.parse().map(Expr::Lit)
1632 } else if input.peek(Token![async])
1633 && (input.peek2(token::Brace) || input.peek2(Token![move]) && input.peek3(token::Brace))
1635 input.parse().map(Expr::Async)
1636 } else if input.peek(Token![try]) && input.peek2(token::Brace) {
1637 input.parse().map(Expr::TryBlock)
1638 } else if input.peek(Token![|])
1639 || input.peek(Token![move])
1640 || input.peek(Token![for])
1641 && input.peek2(Token![<])
1642 && (input.peek3(Lifetime) || input.peek3(Token![>]))
1643 || input.peek(Token![const]) && !input.peek2(token::Brace)
1644 || input.peek(Token![static])
1645 || input.peek(Token![async]) && (input.peek2(Token![|]) || input.peek2(Token![move]))
1647 expr_closure(input, allow_struct).map(Expr::Closure)
1648 } else if input.peek(kw::builtin) && input.peek2(Token![#]) {
1649 expr_builtin(input)
1650 } else if input.peek(Ident)
1651 || input.peek(Token![::])
1652 || input.peek(Token![<])
1653 || input.peek(Token![self])
1654 || input.peek(Token![Self])
1655 || input.peek(Token![super])
1656 || input.peek(Token![crate])
1657 || input.peek(Token![try]) && (input.peek2(Token![!]) || input.peek2(Token![::]))
1659 path_or_macro_or_struct(input, allow_struct)
1660 } else if input.peek(token::Paren) {
1661 paren_or_tuple(input)
1662 } else if input.peek(Token![break]) {
1663 expr_break(input, allow_struct).map(Expr::Break)
1664 } else if input.peek(Token![continue]) {
1665 input.parse().map(Expr::Continue)
1666 } else if input.peek(Token![return]) {
1667 expr_return(input, allow_struct).map(Expr::Return)
1668 } else if input.peek(token::Bracket) {
1669 array_or_repeat(input)
1670 } else if input.peek(Token![let]) {
1671 input.parse().map(Expr::Let)
1672 } else if input.peek(Token![if]) {
1673 input.parse().map(Expr::If)
1674 } else if input.peek(Token![while]) {
1675 input.parse().map(Expr::While)
1676 } else if input.peek(Token![for]) {
1677 input.parse().map(Expr::ForLoop)
1678 } else if input.peek(Token![loop]) {
1679 input.parse().map(Expr::Loop)
1680 } else if input.peek(Token![match]) {
1681 input.parse().map(Expr::Match)
1682 } else if input.peek(Token![yield]) {
1683 input.parse().map(Expr::Yield)
1684 } else if input.peek(Token![unsafe]) {
1685 input.parse().map(Expr::Unsafe)
1686 } else if input.peek(Token![const]) {
1687 input.parse().map(Expr::Const)
1688 } else if input.peek(token::Brace) {
1689 input.parse().map(Expr::Block)
1690 } else if input.peek(Token![..]) {
1691 expr_range(input, allow_struct).map(Expr::Range)
1692 } else if input.peek(Token![_]) {
1693 input.parse().map(Expr::Infer)
1694 } else if input.peek(Lifetime) {
1695 atom_labeled(input)
1697 Err(input.error("expected an expression"))
1702 fn atom_labeled(input: ParseStream) -> Result<Expr> {
1703 let the_label: Label = input.parse()?;
1704 let mut expr = if input.peek(Token![while]) {
1705 Expr::While(input.parse()?)
1706 } else if input.peek(Token![for]) {
1707 Expr::ForLoop(input.parse()?)
1708 } else if input.peek(Token![loop]) {
1709 Expr::Loop(input.parse()?)
1710 } else if input.peek(token::Brace) {
1711 Expr::Block(input.parse()?)
1713 return Err(input.error("expected loop or block expression"));
1726 fn atom_expr(input: ParseStream) -> Result<Expr> {
1727 if input.peek(token::Group) {
1728 expr_group(input)
1729 } else if input.peek(Lit) {
1730 input.parse().map(Expr::Lit)
1731 } else if input.peek(token::Paren) {
1732 input.call(expr_paren).map(Expr::Paren)
1733 } else if input.peek(Ident)
1734 || input.peek(Token![::])
1735 || input.peek(Token![<])
1736 || input.peek(Token![self])
1737 || input.peek(Token![Self])
1738 || input.peek(Token![super])
1739 || input.peek(Token![crate])
1741 path_or_macro_or_struct(input)
1742 } else if input.is_empty() {
1743 Err(input.error("expected an expression"))
1745 if input.peek(token::Brace) {
1746 let scan = input.fork();
1750 let expr_block = verbatim::between(input, &scan);
1751 input.advance_to(&scan);
1755 Err(input.error("unsupported expression; enable syn's features=[\"full\"]"))
1760 fn expr_builtin(input: ParseStream) -> Result<Expr> {
1761 let begin = input.fork();
1763 input.parse::<kw::builtin>()?;
1764 input.parse::<Token![#]>()?;
1765 input.parse::<Ident>()?;
1768 parenthesized!(args in input);
1771 Ok(Expr::Verbatim(verbatim::between(&begin, input)))
1775 input: ParseStream,
1778 let (qself, path) = path::parsing::qpath(input, true)?;
1782 input,
1791 input: ParseStream,
1795 && input.peek(Token![!])
1796 && !input.peek(Token![!=])
1799 let bang_token: Token![!] = input.parse()?;
1800 let (delimiter, tokens) = mac::parse_delimiter(input)?;
1814 if allow_struct.0 && input.peek(token::Brace) {
1815 return expr_struct_helper(input, qself, path).map(Expr::Struct);
1827 fn parse(input: ParseStream) -> Result<Self> {
1830 mac: input.parse()?,
1836 fn paren_or_tuple(input: ParseStream) -> Result<Expr> {
1838 let paren_token = parenthesized!(content in input);
1875 fn array_or_repeat(input: ParseStream) -> Result<Expr> {
1877 let bracket_token = bracketed!(content in input);
1922 fn parse(input: ParseStream) -> Result<Self> {
1924 let bracket_token = bracketed!(content in input);
1948 fn parse(input: ParseStream) -> Result<Self> {
1951 bracket_token: bracketed!(content in input),
1961 pub(crate) fn expr_early(input: ParseStream) -> Result<Expr> {
1962 let mut attrs = input.call(expr_attrs)?;
1963 let mut expr = if input.peek(token::Group) {
1965 let atom = expr_group(input, allow_struct)?;
1967 trailer_helper(input, atom)?
1971 } else if input.peek(Token![if]) {
1972 Expr::If(input.parse()?)
1973 } else if input.peek(Token![while]) {
1974 Expr::While(input.parse()?)
1975 } else if input.peek(Token![for])
1976 && !(input.peek2(Token![<]) && (input.peek3(Lifetime) || input.peek3(Token![>])))
1978 Expr::ForLoop(input.parse()?)
1979 } else if input.peek(Token![loop]) {
1980 Expr::Loop(input.parse()?)
1981 } else if input.peek(Token![match]) {
1982 Expr::Match(input.parse()?)
1983 } else if input.peek(Token![try]) && input.peek2(token::Brace) {
1984 Expr::TryBlock(input.parse()?)
1985 } else if input.peek(Token![unsafe]) {
1986 Expr::Unsafe(input.parse()?)
1987 } else if input.peek(Token![const]) && input.peek2(token::Brace) {
1988 Expr::Const(input.parse()?)
1989 } else if input.peek(token::Brace) {
1990 Expr::Block(input.parse()?)
1991 } else if input.peek(Lifetime) {
1992 atom_labeled(input)?
1995 unary_expr(input, allow_struct)?
2003 return parse_expr(input, expr, allow_struct, Precedence::Any);
2006 if input.peek(Token![.]) && !input.peek(Token![..]) || input.peek(Token![?]) {
2007 expr = trailer_helper(input, expr)?;
2013 return parse_expr(input, expr, allow_struct, Precedence::Any);
2042 fn parse(input: ParseStream) -> Result<Self> {
2045 lit: input.parse()?,
2051 input: ParseStream,
2054 let group = crate::group::parse_group(input)?;
2060 Path::parse_rest(input, &mut expr.path, true)?;
2064 input,
2087 fn parse(input: ParseStream) -> Result<Self> {
2088 expr_paren(input)
2092 fn expr_paren(input: ParseStream) -> Result<ExprParen> {
2096 paren_token: parenthesized!(content in input),
2104 fn parse(input: ParseStream) -> Result<Self> {
2107 let_token: input.parse()?,
2108 pat: Box::new(Pat::parse_multi_with_leading_vert(input)?),
2109 eq_token: input.parse()?,
2112 let lhs = unary_expr(input, allow_struct)?;
2113 parse_expr(input, lhs, allow_struct, Precedence::Compare)?
2122 fn parse(input: ParseStream) -> Result<Self> {
2123 let attrs = input.call(Attribute::parse_outer)?;
2126 if_token: input.parse()?,
2127 cond: Box::new(input.call(Expr::parse_without_eager_brace)?),
2128 then_branch: input.parse()?,
2130 if input.peek(Token![else]) {
2131 Some(input.call(else_block)?)
2141 fn else_block(input: ParseStream) -> Result<(Token![else], Box<Expr>)> {
2142 let else_token: Token![else] = input.parse()?;
2144 let lookahead = input.lookahead1();
2146 input.parse().map(Expr::If)?
2151 block: input.parse()?,
2163 fn parse(input: ParseStream) -> Result<Self> {
2165 attrs: input.call(Attribute::parse_outer)?,
2166 underscore_token: input.parse()?,
2174 fn parse(input: ParseStream) -> Result<Self> {
2175 let mut attrs = input.call(Attribute::parse_outer)?;
2176 let label: Option<Label> = input.parse()?;
2177 let for_token: Token![for] = input.parse()?;
2179 let pat = Pat::parse_multi_with_leading_vert(input)?;
2181 let in_token: Token![in] = input.parse()?;
2182 let expr: Expr = input.call(Expr::parse_without_eager_brace)?;
2185 let brace_token = braced!(content in input);
2204 fn parse(input: ParseStream) -> Result<Self> {
2205 let mut attrs = input.call(Attribute::parse_outer)?;
2206 let label: Option<Label> = input.parse()?;
2207 let loop_token: Token![loop] = input.parse()?;
2210 let brace_token = braced!(content in input);
2226 fn parse(input: ParseStream) -> Result<Self> {
2227 let mut attrs = input.call(Attribute::parse_outer)?;
2228 let match_token: Token![match] = input.parse()?;
2229 let expr = Expr::parse_without_eager_brace(input)?;
2232 let brace_token = braced!(content in input);
2260 fn parse(input: ParseStream) -> Result<Self> {
2261 let mut expr: Expr = input.parse()?;
2292 fn parse(input: ParseStream) -> Result<Self> {
2295 expr_unary(input, attrs, allow_struct)
2301 input: ParseStream,
2307 op: input.parse()?,
2308 expr: Box::new(unary_expr(input, allow_struct)?),
2315 fn parse(input: ParseStream) -> Result<Self> {
2317 expr_closure(input, allow_struct)
2324 fn parse(input: ParseStream) -> Result<Self> {
2328 and_token: input.parse()?,
2329 mutability: input.parse()?,
2330 expr: Box::new(unary_expr(input, allow_struct)?),
2338 fn parse(input: ParseStream) -> Result<Self> {
2340 expr_break(input, allow_struct)
2347 fn parse(input: ParseStream) -> Result<Self> {
2349 expr_return(input, allow_struct)
2356 fn parse(input: ParseStream) -> Result<Self> {
2359 try_token: input.parse()?,
2360 block: input.parse()?,
2368 fn parse(input: ParseStream) -> Result<Self> {
2371 yield_token: input.parse()?,
2373 if can_begin_expr(input) {
2374 Some(input.parse()?)
2384 fn expr_closure(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprClosure> {
2385 let lifetimes: Option<BoundLifetimes> = input.parse()?;
2386 let constness: Option<Token![const]> = input.parse()?;
2387 let movability: Option<Token![static]> = input.parse()?;
2388 let asyncness: Option<Token![async]> = input.parse()?;
2389 let capture: Option<Token![move]> = input.parse()?;
2390 let or1_token: Token![|] = input.parse()?;
2394 if input.peek(Token![|]) {
2397 let value = closure_arg(input)?;
2399 if input.peek(Token![|]) {
2402 let punct: Token![,] = input.parse()?;
2406 let or2_token: Token![|] = input.parse()?;
2408 let (output, body) = if input.peek(Token![->]) {
2409 let arrow_token: Token![->] = input.parse()?;
2410 let ty: Type = input.parse()?;
2411 let body: Block = input.parse()?;
2420 let body = ambiguous_expr(input, allow_struct)?;
2442 fn parse(input: ParseStream) -> Result<Self> {
2445 async_token: input.parse()?,
2446 capture: input.parse()?,
2447 block: input.parse()?,
2453 fn closure_arg(input: ParseStream) -> Result<Pat> {
2454 let attrs = input.call(Attribute::parse_outer)?;
2455 let mut pat = Pat::parse_single(input)?;
2457 if input.peek(Token![:]) {
2461 colon_token: input.parse()?,
2462 ty: input.parse()?,
2491 fn parse(input: ParseStream) -> Result<Self> {
2492 let mut attrs = input.call(Attribute::parse_outer)?;
2493 let label: Option<Label> = input.parse()?;
2494 let while_token: Token![while] = input.parse()?;
2495 let cond = Expr::parse_without_eager_brace(input)?;
2498 let brace_token = braced!(content in input);
2515 fn parse(input: ParseStream) -> Result<Self> {
2516 let const_token: Token![const] = input.parse()?;
2519 let brace_token = braced!(content in input);
2534 fn parse(input: ParseStream) -> Result<Self> {
2536 name: input.parse()?,
2537 colon_token: input.parse()?,
2545 fn parse(input: ParseStream) -> Result<Self> {
2546 if input.peek(Lifetime) {
2547 input.parse().map(Some)
2557 fn parse(input: ParseStream) -> Result<Self> {
2560 continue_token: input.parse()?,
2561 label: input.parse()?,
2567 fn expr_break(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprBreak> {
2568 let break_token: Token![break] = input.parse()?;
2570 let ahead = input.fork();
2575 let _ = ambiguous_expr(input, allow_struct)?;
2577 let end_span = input.cursor().prev_span();
2585 input.advance_to(&ahead);
2586 let expr = if can_begin_expr(input) && (allow_struct.0 || !input.peek(token::Brace)) {
2587 let expr = ambiguous_expr(input, allow_struct)?;
2602 fn expr_return(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprReturn> {
2605 return_token: input.parse()?,
2607 if can_begin_expr(input) {
2613 let expr = ambiguous_expr(input, allow_struct)?;
2624 fn parse(input: ParseStream) -> Result<Self> {
2625 let attrs = input.call(Attribute::parse_outer)?;
2626 let member: Member = input.parse()?;
2627 let (colon_token, value) = if input.peek(Token![:]) || !member.is_named() {
2628 let colon_token: Token![:] = input.parse()?;
2629 let value: Expr = input.parse()?;
2653 fn parse(input: ParseStream) -> Result<Self> {
2654 let (qself, path) = path::parsing::qpath(input, true)?;
2655 expr_struct_helper(input, qself, path)
2660 input: ParseStream,
2665 let brace_token = braced!(content in input);
2707 fn parse(input: ParseStream) -> Result<Self> {
2708 let unsafe_token: Token![unsafe] = input.parse()?;
2711 let brace_token = braced!(content in input);
2726 fn parse(input: ParseStream) -> Result<Self> {
2727 let mut attrs = input.call(Attribute::parse_outer)?;
2728 let label: Option<Label> = input.parse()?;
2731 let brace_token = braced!(content in input);
2744 fn expr_range(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprRange> {
2745 let limits: RangeLimits = input.parse()?;
2747 && (input.is_empty()
2748 || input.peek(Token![,])
2749 || input.peek(Token![;])
2750 || input.peek(Token![.]) && !input.peek(Token![..])
2751 || !allow_struct.0 && input.peek(token::Brace))
2755 let to = ambiguous_expr(input, allow_struct)?;
2769 fn parse(input: ParseStream) -> Result<Self> {
2770 let lookahead = input.lookahead1();
2773 let dot_dot_dot = dot_dot && input.peek(Token![...]);
2775 input.parse().map(RangeLimits::Closed)
2777 input.parse().map(RangeLimits::HalfOpen)
2786 pub(crate) fn parse_obsolete(input: ParseStream) -> Result<Self> {
2787 let lookahead = input.lookahead1();
2790 let dot_dot_dot = dot_dot && input.peek(Token![...]);
2792 input.parse().map(RangeLimits::Closed)
2794 let dot3: Token![...] = input.parse()?;
2797 input.parse().map(RangeLimits::HalfOpen)
2806 fn parse(input: ParseStream) -> Result<Self> {
2810 let attrs = input.call(Attribute::parse_outer)?;
2812 let (qself, path) = path::parsing::qpath(input, true)?;
2820 fn parse(input: ParseStream) -> Result<Self> {
2821 if input.peek(Ident) {
2822 input.parse().map(Member::Named)
2823 } else if input.peek(LitInt) {
2824 input.parse().map(Member::Unnamed)
2826 Err(input.error("expected identifier or integer"))
2834 fn parse(input: ParseStream) -> Result<Arm> {
2837 attrs: input.call(Attribute::parse_outer)?,
2838 pat: Pat::parse_multi_with_leading_vert(input)?,
2840 if input.peek(Token![if]) {
2841 let if_token: Token![if] = input.parse()?;
2842 let guard: Expr = input.parse()?;
2848 fat_arrow_token: input.parse()?,
2850 let body = input.call(expr_early)?;
2855 if requires_comma && !input.is_empty() {
2856 Some(input.parse()?)
2858 input.parse()?
2867 fn parse(input: ParseStream) -> Result<Self> {
2868 let lit: LitInt = input.parse()?;
2926 fn check_cast(input: ParseStream) -> Result<()> {
2927 let kind = if input.peek(Token![.]) && !input.peek(Token![..]) {
2928 if input.peek2(Token![await]) {
2930 } else if input.peek2(Ident) && (input.peek3(token::Paren) || input.peek3(Token![::])) {
2935 } else if input.peek(Token![?]) {
2937 } else if input.peek(token::Bracket) {
2939 } else if input.peek(token::Paren) {
2945 Err(input.error(msg))