Lines Matching refs:input
830 pub fn parse_without_eager_brace(input: ParseStream) -> Result<Expr> { in parse_without_eager_brace()
831 parsing::ambiguous_expr(input, parsing::AllowStruct(false)) in parse_without_eager_brace()
892 pub fn parse_with_earlier_boundary_rule(input: ParseStream) -> Result<Expr> { in parse_with_earlier_boundary_rule()
893 parsing::parse_with_earlier_boundary_rule(input) in parse_with_earlier_boundary_rule()
908 pub fn peek(input: ParseStream) -> bool { in peek()
909 input.peek(Ident::peek_any) && !input.peek(Token![as]) // value name or keyword in peek()
910 || input.peek(token::Paren) // tuple in peek()
911 || input.peek(token::Bracket) // array in peek()
912 || input.peek(token::Brace) // block in peek()
913 || input.peek(Lit) // literal in peek()
914 || input.peek(Token![!]) && !input.peek(Token![!=]) // operator not in peek()
915 … || input.peek(Token![-]) && !input.peek(Token![-=]) && !input.peek(Token![->]) // unary minus in peek()
916 || input.peek(Token![*]) && !input.peek(Token![*=]) // dereference in peek()
917 || input.peek(Token![|]) && !input.peek(Token![|=]) // closure in peek()
918 || input.peek(Token![&]) && !input.peek(Token![&=]) // reference in peek()
919 || input.peek(Token![..]) // range in peek()
920 … || input.peek(Token![<]) && !input.peek(Token![<=]) && !input.peek(Token![<<=]) // associated path in peek()
921 || input.peek(Token![::]) // absolute path in peek()
922 || input.peek(Lifetime) // labeled loop in peek()
923 || input.peek(Token![#]) // expression attributes in peek()
1231 fn parse(input: ParseStream) -> Result<Self> { in parse()
1233 input, in parse()
1241 pub(super) fn parse_with_earlier_boundary_rule(input: ParseStream) -> Result<Expr> { in parse_with_earlier_boundary_rule()
1242 let mut attrs = input.call(expr_attrs)?; in parse_with_earlier_boundary_rule()
1243 let mut expr = if input.peek(token::Group) { in parse_with_earlier_boundary_rule()
1245 let atom = expr_group(input, allow_struct)?; in parse_with_earlier_boundary_rule()
1247 trailer_helper(input, atom)? in parse_with_earlier_boundary_rule()
1251 } else if input.peek(Token![if]) { in parse_with_earlier_boundary_rule()
1252 Expr::If(input.parse()?) in parse_with_earlier_boundary_rule()
1253 } else if input.peek(Token![while]) { in parse_with_earlier_boundary_rule()
1254 Expr::While(input.parse()?) in parse_with_earlier_boundary_rule()
1255 } else if input.peek(Token![for]) in parse_with_earlier_boundary_rule()
1256 && !generics::parsing::choose_generics_over_qpath_after_keyword(input) in parse_with_earlier_boundary_rule()
1258 Expr::ForLoop(input.parse()?) in parse_with_earlier_boundary_rule()
1259 } else if input.peek(Token![loop]) { in parse_with_earlier_boundary_rule()
1260 Expr::Loop(input.parse()?) in parse_with_earlier_boundary_rule()
1261 } else if input.peek(Token![match]) { in parse_with_earlier_boundary_rule()
1262 Expr::Match(input.parse()?) in parse_with_earlier_boundary_rule()
1263 } else if input.peek(Token![try]) && input.peek2(token::Brace) { in parse_with_earlier_boundary_rule()
1264 Expr::TryBlock(input.parse()?) in parse_with_earlier_boundary_rule()
1265 } else if input.peek(Token![unsafe]) { in parse_with_earlier_boundary_rule()
1266 Expr::Unsafe(input.parse()?) in parse_with_earlier_boundary_rule()
1267 } else if input.peek(Token![const]) && input.peek2(token::Brace) { in parse_with_earlier_boundary_rule()
1268 Expr::Const(input.parse()?) in parse_with_earlier_boundary_rule()
1269 } else if input.peek(token::Brace) { in parse_with_earlier_boundary_rule()
1270 Expr::Block(input.parse()?) in parse_with_earlier_boundary_rule()
1271 } else if input.peek(Lifetime) { in parse_with_earlier_boundary_rule()
1272 atom_labeled(input)? in parse_with_earlier_boundary_rule()
1275 unary_expr(input, allow_struct)? in parse_with_earlier_boundary_rule()
1283 return parse_expr(input, expr, allow_struct, Precedence::MIN); in parse_with_earlier_boundary_rule()
1286 if input.peek(Token![.]) && !input.peek(Token![..]) || input.peek(Token![?]) { in parse_with_earlier_boundary_rule()
1287 expr = trailer_helper(input, expr)?; in parse_with_earlier_boundary_rule()
1293 return parse_expr(input, expr, allow_struct, Precedence::MIN); in parse_with_earlier_boundary_rule()
1313 input: ParseStream, in parse_expr()
1319 let ahead = input.fork(); in parse_expr()
1336 return Err(input.error("comparison operators cannot be chained")); in parse_expr()
1340 input.advance_to(&ahead); in parse_expr()
1341 let right = parse_binop_rhs(input, allow_struct, precedence)?; in parse_expr()
1349 && input.peek(Token![=]) in parse_expr()
1350 && !input.peek(Token![=>]) in parse_expr()
1356 let eq_token: Token![=] = input.parse()?; in parse_expr()
1357 let right = parse_binop_rhs(input, allow_struct, Precedence::Assign)?; in parse_expr()
1364 } else if Precedence::Range >= base && input.peek(Token![..]) { in parse_expr()
1365 let limits: RangeLimits = input.parse()?; in parse_expr()
1366 let end = parse_range_end(input, &limits, allow_struct)?; in parse_expr()
1373 } else if Precedence::Cast >= base && input.peek(Token![as]) { in parse_expr()
1374 let as_token: Token![as] = input.parse()?; in parse_expr()
1377 let ty = ty::parsing::ambig_ty(input, allow_plus, allow_group_generic)?; in parse_expr()
1378 check_cast(input)?; in parse_expr()
1393 fn parse_expr(input: ParseStream, mut lhs: Expr, base: Precedence) -> Result<Expr> { in parse_expr()
1395 let ahead = input.fork(); in parse_expr()
1404 return Err(input.error("comparison operators cannot be chained")); in parse_expr()
1408 input.advance_to(&ahead); in parse_expr()
1409 let right = parse_binop_rhs(input, precedence)?; in parse_expr()
1416 } else if Precedence::Cast >= base && input.peek(Token![as]) { in parse_expr()
1417 let as_token: Token![as] = input.parse()?; in parse_expr()
1420 let ty = ty::parsing::ambig_ty(input, allow_plus, allow_group_generic)?; in parse_expr()
1421 check_cast(input)?; in parse_expr()
1436 input: ParseStream, in parse_binop_rhs()
1441 input, in parse_binop_rhs()
1446 let next = peek_precedence(input); in parse_binop_rhs()
1448 let cursor = input.cursor(); in parse_binop_rhs()
1450 input, in parse_binop_rhs()
1456 if cursor == input.cursor() { in parse_binop_rhs()
1470 fn peek_precedence(input: ParseStream) -> Precedence { in peek_precedence()
1471 if let Ok(op) = input.fork().parse() { in peek_precedence()
1473 } else if input.peek(Token![=]) && !input.peek(Token![=>]) { in peek_precedence()
1475 } else if input.peek(Token![..]) { in peek_precedence()
1477 } else if input.peek(Token![as]) { in peek_precedence()
1486 input: ParseStream, in ambiguous_expr()
1490 input, in ambiguous_expr()
1495 input, in ambiguous_expr()
1504 fn expr_attrs(input: ParseStream) -> Result<Vec<Attribute>> { in expr_attrs()
1506 while !input.peek(token::Group) && input.peek(Token![#]) { in expr_attrs()
1507 attrs.push(input.call(attr::parsing::single_parse_outer)?); in expr_attrs()
1517 fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { in unary_expr()
1518 let begin = input.fork(); in unary_expr()
1519 let attrs = input.call(expr_attrs)?; in unary_expr()
1520 if input.peek(token::Group) { in unary_expr()
1521 return trailer_expr(begin, attrs, input, allow_struct); in unary_expr()
1524 if input.peek(Token![&]) { in unary_expr()
1525 let and_token: Token![&] = input.parse()?; in unary_expr()
1526 let raw: Option<Token![raw]> = if input.peek(Token![raw]) in unary_expr()
1527 && (input.peek2(Token![mut]) || input.peek2(Token![const])) in unary_expr()
1529 Some(input.parse()?) in unary_expr()
1533 let mutability: Option<Token![mut]> = input.parse()?; in unary_expr()
1535 Some(input.parse()?) in unary_expr()
1539 let expr = Box::new(unary_expr(input, allow_struct)?); in unary_expr()
1559 } else if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) { in unary_expr()
1560 expr_unary(input, attrs, allow_struct).map(Expr::Unary) in unary_expr()
1562 trailer_expr(begin, attrs, input, allow_struct) in unary_expr()
1567 fn unary_expr(input: ParseStream) -> Result<Expr> { in unary_expr()
1568 if input.peek(Token![&]) { in unary_expr()
1571 and_token: input.parse()?, in unary_expr()
1572 mutability: input.parse()?, in unary_expr()
1573 expr: Box::new(unary_expr(input)?), in unary_expr()
1575 } else if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) { in unary_expr()
1578 op: input.parse()?, in unary_expr()
1579 expr: Box::new(unary_expr(input)?), in unary_expr()
1582 trailer_expr(input) in unary_expr()
1596 input: ParseStream, in trailer_expr()
1599 let atom = atom_expr(input, allow_struct)?; in trailer_expr()
1600 let mut e = trailer_helper(input, atom)?; in trailer_expr()
1603 *tokens = verbatim::between(&begin, input); in trailer_expr()
1625 fn trailer_helper(input: ParseStream, mut e: Expr) -> Result<Expr> { in trailer_helper()
1627 if input.peek(token::Paren) { in trailer_helper()
1632 paren_token: parenthesized!(content in input), in trailer_helper()
1635 } else if input.peek(Token![.]) in trailer_helper()
1636 && !input.peek(Token![..]) in trailer_helper()
1642 let mut dot_token: Token![.] = input.parse()?; in trailer_helper()
1644 let float_token: Option<LitFloat> = input.parse()?; in trailer_helper()
1651 let await_token: Option<Token![await]> = input.parse()?; in trailer_helper()
1662 let member: Member = input.parse()?; in trailer_helper()
1663 let turbofish = if member.is_named() && input.peek(Token![::]) { in trailer_helper()
1664 Some(AngleBracketedGenericArguments::parse_turbofish(input)?) in trailer_helper()
1669 if turbofish.is_some() || input.peek(token::Paren) { in trailer_helper()
1678 paren_token: parenthesized!(content in input), in trailer_helper()
1691 } else if input.peek(token::Bracket) { in trailer_helper()
1696 bracket_token: bracketed!(content in input), in trailer_helper()
1699 } else if input.peek(Token![?]) in trailer_helper()
1708 question_token: input.parse()?, in trailer_helper()
1718 fn trailer_expr(input: ParseStream) -> Result<Expr> { in trailer_expr()
1719 let mut e = atom_expr(input)?; in trailer_expr()
1722 if input.peek(token::Paren) { in trailer_expr()
1727 paren_token: parenthesized!(content in input), in trailer_expr()
1730 } else if input.peek(Token![.]) in trailer_expr()
1731 && !input.peek(Token![..]) in trailer_expr()
1732 && !input.peek2(Token![await]) in trailer_expr()
1734 let mut dot_token: Token![.] = input.parse()?; in trailer_expr()
1736 let float_token: Option<LitFloat> = input.parse()?; in trailer_expr()
1743 let member: Member = input.parse()?; in trailer_expr()
1744 let turbofish = if member.is_named() && input.peek(Token![::]) { in trailer_expr()
1745 let colon2_token: Token![::] = input.parse()?; in trailer_expr()
1747 AngleBracketedGenericArguments::do_parse(Some(colon2_token), input)?; in trailer_expr()
1753 if turbofish.is_some() || input.peek(token::Paren) { in trailer_expr()
1762 paren_token: parenthesized!(content in input), in trailer_expr()
1775 } else if input.peek(token::Bracket) { in trailer_expr()
1780 bracket_token: bracketed!(content in input), in trailer_expr()
1794 fn atom_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { in atom_expr()
1795 if input.peek(token::Group) { in atom_expr()
1796 expr_group(input, allow_struct) in atom_expr()
1797 } else if input.peek(Lit) { in atom_expr()
1798 input.parse().map(Expr::Lit) in atom_expr()
1799 } else if input.peek(Token![async]) in atom_expr()
1800 && (input.peek2(token::Brace) || input.peek2(Token![move]) && input.peek3(token::Brace)) in atom_expr()
1802 input.parse().map(Expr::Async) in atom_expr()
1803 } else if input.peek(Token![try]) && input.peek2(token::Brace) { in atom_expr()
1804 input.parse().map(Expr::TryBlock) in atom_expr()
1805 } else if input.peek(Token![|]) in atom_expr()
1806 || input.peek(Token![move]) in atom_expr()
1807 || input.peek(Token![for]) in atom_expr()
1808 && generics::parsing::choose_generics_over_qpath_after_keyword(input) in atom_expr()
1809 || input.peek(Token![const]) && !input.peek2(token::Brace) in atom_expr()
1810 || input.peek(Token![static]) in atom_expr()
1811 || input.peek(Token![async]) && (input.peek2(Token![|]) || input.peek2(Token![move])) in atom_expr()
1813 expr_closure(input, allow_struct).map(Expr::Closure) in atom_expr()
1814 } else if token::parsing::peek_keyword(input.cursor(), "builtin") && input.peek2(Token![#]) in atom_expr()
1816 expr_builtin(input) in atom_expr()
1817 } else if input.peek(Ident) in atom_expr()
1818 || input.peek(Token![::]) in atom_expr()
1819 || input.peek(Token![<]) in atom_expr()
1820 || input.peek(Token![self]) in atom_expr()
1821 || input.peek(Token![Self]) in atom_expr()
1822 || input.peek(Token![super]) in atom_expr()
1823 || input.peek(Token![crate]) in atom_expr()
1824 || input.peek(Token![try]) && (input.peek2(Token![!]) || input.peek2(Token![::])) in atom_expr()
1826 path_or_macro_or_struct(input, allow_struct) in atom_expr()
1827 } else if input.peek(token::Paren) { in atom_expr()
1828 paren_or_tuple(input) in atom_expr()
1829 } else if input.peek(Token![break]) { in atom_expr()
1830 expr_break(input, allow_struct).map(Expr::Break) in atom_expr()
1831 } else if input.peek(Token![continue]) { in atom_expr()
1832 input.parse().map(Expr::Continue) in atom_expr()
1833 } else if input.peek(Token![return]) { in atom_expr()
1834 input.parse().map(Expr::Return) in atom_expr()
1835 } else if input.peek(Token![become]) { in atom_expr()
1836 expr_become(input) in atom_expr()
1837 } else if input.peek(token::Bracket) { in atom_expr()
1838 array_or_repeat(input) in atom_expr()
1839 } else if input.peek(Token![let]) { in atom_expr()
1840 expr_let(input, allow_struct).map(Expr::Let) in atom_expr()
1841 } else if input.peek(Token![if]) { in atom_expr()
1842 input.parse().map(Expr::If) in atom_expr()
1843 } else if input.peek(Token![while]) { in atom_expr()
1844 input.parse().map(Expr::While) in atom_expr()
1845 } else if input.peek(Token![for]) { in atom_expr()
1846 input.parse().map(Expr::ForLoop) in atom_expr()
1847 } else if input.peek(Token![loop]) { in atom_expr()
1848 input.parse().map(Expr::Loop) in atom_expr()
1849 } else if input.peek(Token![match]) { in atom_expr()
1850 input.parse().map(Expr::Match) in atom_expr()
1851 } else if input.peek(Token![yield]) { in atom_expr()
1852 input.parse().map(Expr::Yield) in atom_expr()
1853 } else if input.peek(Token![unsafe]) { in atom_expr()
1854 input.parse().map(Expr::Unsafe) in atom_expr()
1855 } else if input.peek(Token![const]) { in atom_expr()
1856 input.parse().map(Expr::Const) in atom_expr()
1857 } else if input.peek(token::Brace) { in atom_expr()
1858 input.parse().map(Expr::Block) in atom_expr()
1859 } else if input.peek(Token![..]) { in atom_expr()
1860 expr_range(input, allow_struct).map(Expr::Range) in atom_expr()
1861 } else if input.peek(Token![_]) { in atom_expr()
1862 input.parse().map(Expr::Infer) in atom_expr()
1863 } else if input.peek(Lifetime) { in atom_expr()
1864 atom_labeled(input) in atom_expr()
1866 Err(input.error("expected an expression")) in atom_expr()
1871 fn atom_labeled(input: ParseStream) -> Result<Expr> { in atom_labeled()
1872 let the_label: Label = input.parse()?; in atom_labeled()
1873 let mut expr = if input.peek(Token![while]) { in atom_labeled()
1874 Expr::While(input.parse()?) in atom_labeled()
1875 } else if input.peek(Token![for]) { in atom_labeled()
1876 Expr::ForLoop(input.parse()?) in atom_labeled()
1877 } else if input.peek(Token![loop]) { in atom_labeled()
1878 Expr::Loop(input.parse()?) in atom_labeled()
1879 } else if input.peek(token::Brace) { in atom_labeled()
1880 Expr::Block(input.parse()?) in atom_labeled()
1882 return Err(input.error("expected loop or block expression")); in atom_labeled()
1895 fn atom_expr(input: ParseStream) -> Result<Expr> { in atom_expr()
1896 if input.peek(token::Group) { in atom_expr()
1897 expr_group(input) in atom_expr()
1898 } else if input.peek(Lit) { in atom_expr()
1899 input.parse().map(Expr::Lit) in atom_expr()
1900 } else if input.peek(token::Paren) { in atom_expr()
1901 paren_or_tuple(input) in atom_expr()
1902 } else if input.peek(Ident) in atom_expr()
1903 || input.peek(Token![::]) in atom_expr()
1904 || input.peek(Token![<]) in atom_expr()
1905 || input.peek(Token![self]) in atom_expr()
1906 || input.peek(Token![Self]) in atom_expr()
1907 || input.peek(Token![super]) in atom_expr()
1908 || input.peek(Token![crate]) in atom_expr()
1910 path_or_macro_or_struct(input) in atom_expr()
1911 } else if input.is_empty() { in atom_expr()
1912 Err(input.error("expected an expression")) in atom_expr()
1914 if input.peek(token::Brace) { in atom_expr()
1915 let scan = input.fork(); in atom_expr()
1919 let expr_block = verbatim::between(input, &scan); in atom_expr()
1920 input.advance_to(&scan); in atom_expr()
1924 Err(input.error("unsupported expression; enable syn's features=[\"full\"]")) in atom_expr()
1929 fn expr_builtin(input: ParseStream) -> Result<Expr> { in expr_builtin()
1930 let begin = input.fork(); in expr_builtin()
1932 token::parsing::keyword(input, "builtin")?; in expr_builtin()
1933 input.parse::<Token![#]>()?; in expr_builtin()
1934 input.parse::<Ident>()?; in expr_builtin()
1937 parenthesized!(args in input); in expr_builtin()
1940 Ok(Expr::Verbatim(verbatim::between(&begin, input))) in expr_builtin()
1944 input: ParseStream, in path_or_macro_or_struct()
1948 let (qself, path) = path::parsing::qpath(input, expr_style)?; in path_or_macro_or_struct()
1952 input, in path_or_macro_or_struct()
1961 input: ParseStream, in rest_of_path_or_macro_or_struct()
1965 && input.peek(Token![!]) in rest_of_path_or_macro_or_struct()
1966 && !input.peek(Token![!=]) in rest_of_path_or_macro_or_struct()
1969 let bang_token: Token![!] = input.parse()?; in rest_of_path_or_macro_or_struct()
1970 let (delimiter, tokens) = mac::parse_delimiter(input)?; in rest_of_path_or_macro_or_struct()
1984 if allow_struct.0 && input.peek(token::Brace) { in rest_of_path_or_macro_or_struct()
1985 return expr_struct_helper(input, qself, path).map(Expr::Struct); in rest_of_path_or_macro_or_struct()
1997 fn parse(input: ParseStream) -> Result<Self> { in parse()
2000 mac: input.parse()?, in parse()
2005 fn paren_or_tuple(input: ParseStream) -> Result<Expr> { in paren_or_tuple()
2007 let paren_token = parenthesized!(content in input); in paren_or_tuple()
2044 fn array_or_repeat(input: ParseStream) -> Result<Expr> { in array_or_repeat()
2046 let bracket_token = bracketed!(content in input); in array_or_repeat()
2091 fn parse(input: ParseStream) -> Result<Self> { in parse()
2093 let bracket_token = bracketed!(content in input); in parse()
2117 fn parse(input: ParseStream) -> Result<Self> { in parse()
2120 bracket_token: bracketed!(content in input), in parse()
2150 fn parse(input: ParseStream) -> Result<Self> { in parse()
2153 lit: input.parse()?, in parse()
2159 input: ParseStream, in expr_group()
2162 let group = crate::group::parse_group(input)?; in expr_group()
2168 Path::parse_rest(input, &mut expr.path, true)?; in expr_group()
2172 input, in expr_group()
2195 fn parse(input: ParseStream) -> Result<Self> { in parse()
2199 paren_token: parenthesized!(content in input), in parse()
2208 fn parse(input: ParseStream) -> Result<Self> { in parse()
2210 expr_let(input, allow_struct) in parse()
2215 fn expr_let(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprLet> { in expr_let()
2218 let_token: input.parse()?, in expr_let()
2219 pat: Box::new(Pat::parse_multi_with_leading_vert(input)?), in expr_let()
2220 eq_token: input.parse()?, in expr_let()
2222 let lhs = unary_expr(input, allow_struct)?; in expr_let()
2223 parse_expr(input, lhs, allow_struct, Precedence::Compare)? in expr_let()
2231 fn parse(input: ParseStream) -> Result<Self> { in parse()
2232 let attrs = input.call(Attribute::parse_outer)?; in parse()
2237 let if_token: Token![if] = input.parse()?; in parse()
2238 let cond = input.call(Expr::parse_without_eager_brace)?; in parse()
2239 let then_branch: Block = input.parse()?; in parse()
2249 if !input.peek(Token![else]) { in parse()
2253 let else_token: Token![else] = input.parse()?; in parse()
2254 let lookahead = input.lookahead1(); in parse()
2264 block: input.parse()?, in parse()
2285 fn parse(input: ParseStream) -> Result<Self> { in parse()
2287 attrs: input.call(Attribute::parse_outer)?, in parse()
2288 underscore_token: input.parse()?, in parse()
2296 fn parse(input: ParseStream) -> Result<Self> { in parse()
2297 let mut attrs = input.call(Attribute::parse_outer)?; in parse()
2298 let label: Option<Label> = input.parse()?; in parse()
2299 let for_token: Token![for] = input.parse()?; in parse()
2301 let pat = Pat::parse_multi_with_leading_vert(input)?; in parse()
2303 let in_token: Token![in] = input.parse()?; in parse()
2304 let expr: Expr = input.call(Expr::parse_without_eager_brace)?; in parse()
2307 let brace_token = braced!(content in input); in parse()
2326 fn parse(input: ParseStream) -> Result<Self> { in parse()
2327 let mut attrs = input.call(Attribute::parse_outer)?; in parse()
2328 let label: Option<Label> = input.parse()?; in parse()
2329 let loop_token: Token![loop] = input.parse()?; in parse()
2332 let brace_token = braced!(content in input); in parse()
2348 fn parse(input: ParseStream) -> Result<Self> { in parse()
2349 let mut attrs = input.call(Attribute::parse_outer)?; in parse()
2350 let match_token: Token![match] = input.parse()?; in parse()
2351 let expr = Expr::parse_without_eager_brace(input)?; in parse()
2354 let brace_token = braced!(content in input); in parse()
2379 fn parse(input: ParseStream) -> Result<Self> {
2380 let mut expr: Expr = input.parse()?;
2411 fn parse(input: ParseStream) -> Result<Self> { in parse()
2414 expr_unary(input, attrs, allow_struct) in parse()
2420 input: ParseStream, in expr_unary()
2426 op: input.parse()?, in expr_unary()
2427 expr: Box::new(unary_expr(input, allow_struct)?), in expr_unary()
2434 fn parse(input: ParseStream) -> Result<Self> { in parse()
2436 expr_closure(input, allow_struct) in parse()
2443 fn parse(input: ParseStream) -> Result<Self> { in parse()
2447 and_token: input.parse()?, in parse()
2448 raw: input.parse()?, in parse()
2449 mutability: input.parse()?, in parse()
2450 expr: Box::new(unary_expr(input, allow_struct)?), in parse()
2458 fn parse(input: ParseStream) -> Result<Self> { in parse()
2462 and_token: input.parse()?, in parse()
2463 mutability: input.parse()?, in parse()
2464 expr: Box::new(unary_expr(input, allow_struct)?), in parse()
2472 fn parse(input: ParseStream) -> Result<Self> { in parse()
2474 expr_break(input, allow_struct) in parse()
2481 fn parse(input: ParseStream) -> Result<Self> { in parse()
2484 return_token: input.parse()?, in parse()
2486 if Expr::peek(input) { in parse()
2487 Some(input.parse()?) in parse()
2497 fn expr_become(input: ParseStream) -> Result<Expr> { in expr_become()
2498 let begin = input.fork(); in expr_become()
2499 input.parse::<Token![become]>()?; in expr_become()
2500 input.parse::<Expr>()?; in expr_become()
2501 Ok(Expr::Verbatim(verbatim::between(&begin, input))) in expr_become()
2507 fn parse(input: ParseStream) -> Result<Self> { in parse()
2510 try_token: input.parse()?, in parse()
2511 block: input.parse()?, in parse()
2519 fn parse(input: ParseStream) -> Result<Self> { in parse()
2522 yield_token: input.parse()?, in parse()
2524 if Expr::peek(input) { in parse()
2525 Some(input.parse()?) in parse()
2535 fn expr_closure(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprClosure> { in expr_closure()
2536 let lifetimes: Option<BoundLifetimes> = input.parse()?; in expr_closure()
2537 let constness: Option<Token![const]> = input.parse()?; in expr_closure()
2538 let movability: Option<Token![static]> = input.parse()?; in expr_closure()
2539 let asyncness: Option<Token![async]> = input.parse()?; in expr_closure()
2540 let capture: Option<Token![move]> = input.parse()?; in expr_closure()
2541 let or1_token: Token![|] = input.parse()?; in expr_closure()
2545 if input.peek(Token![|]) { in expr_closure()
2548 let value = closure_arg(input)?; in expr_closure()
2550 if input.peek(Token![|]) { in expr_closure()
2553 let punct: Token![,] = input.parse()?; in expr_closure()
2557 let or2_token: Token![|] = input.parse()?; in expr_closure()
2559 let (output, body) = if input.peek(Token![->]) { in expr_closure()
2560 let arrow_token: Token![->] = input.parse()?; in expr_closure()
2561 let ty: Type = input.parse()?; in expr_closure()
2562 let body: Block = input.parse()?; in expr_closure()
2571 let body = ambiguous_expr(input, allow_struct)?; in expr_closure()
2593 fn parse(input: ParseStream) -> Result<Self> { in parse()
2596 async_token: input.parse()?, in parse()
2597 capture: input.parse()?, in parse()
2598 block: input.parse()?, in parse()
2604 fn closure_arg(input: ParseStream) -> Result<Pat> { in closure_arg()
2605 let attrs = input.call(Attribute::parse_outer)?; in closure_arg()
2606 let mut pat = Pat::parse_single(input)?; in closure_arg()
2608 if input.peek(Token![:]) { in closure_arg()
2612 colon_token: input.parse()?, in closure_arg()
2613 ty: input.parse()?, in closure_arg()
2642 fn parse(input: ParseStream) -> Result<Self> { in parse()
2643 let mut attrs = input.call(Attribute::parse_outer)?; in parse()
2644 let label: Option<Label> = input.parse()?; in parse()
2645 let while_token: Token![while] = input.parse()?; in parse()
2646 let cond = Expr::parse_without_eager_brace(input)?; in parse()
2649 let brace_token = braced!(content in input); in parse()
2666 fn parse(input: ParseStream) -> Result<Self> { in parse()
2667 let const_token: Token![const] = input.parse()?; in parse()
2670 let brace_token = braced!(content in input); in parse()
2685 fn parse(input: ParseStream) -> Result<Self> { in parse()
2687 name: input.parse()?, in parse()
2688 colon_token: input.parse()?, in parse()
2696 fn parse(input: ParseStream) -> Result<Self> { in parse()
2697 if input.peek(Lifetime) { in parse()
2698 input.parse().map(Some) in parse()
2708 fn parse(input: ParseStream) -> Result<Self> { in parse()
2711 continue_token: input.parse()?, in parse()
2712 label: input.parse()?, in parse()
2718 fn expr_break(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprBreak> { in expr_break()
2719 let break_token: Token![break] = input.parse()?; in expr_break()
2721 let ahead = input.fork(); in expr_break()
2726 let _: Expr = input.parse()?; in expr_break()
2728 let end_span = input.cursor().prev_span(); in expr_break()
2736 input.advance_to(&ahead); in expr_break()
2737 let expr = if Expr::peek(input) && (allow_struct.0 || !input.peek(token::Brace)) { in expr_break()
2738 Some(input.parse()?) in expr_break()
2753 fn parse(input: ParseStream) -> Result<Self> { in parse()
2754 let attrs = input.call(Attribute::parse_outer)?; in parse()
2755 let member: Member = input.parse()?; in parse()
2756 let (colon_token, value) = if input.peek(Token![:]) || !member.is_named() { in parse()
2757 let colon_token: Token![:] = input.parse()?; in parse()
2758 let value: Expr = input.parse()?; in parse()
2782 fn parse(input: ParseStream) -> Result<Self> { in parse()
2784 let (qself, path) = path::parsing::qpath(input, expr_style)?; in parse()
2785 expr_struct_helper(input, qself, path) in parse()
2790 input: ParseStream, in expr_struct_helper()
2795 let brace_token = braced!(content in input); in expr_struct_helper()
2837 fn parse(input: ParseStream) -> Result<Self> { in parse()
2838 let unsafe_token: Token![unsafe] = input.parse()?; in parse()
2841 let brace_token = braced!(content in input); in parse()
2856 fn parse(input: ParseStream) -> Result<Self> { in parse()
2857 let mut attrs = input.call(Attribute::parse_outer)?; in parse()
2858 let label: Option<Label> = input.parse()?; in parse()
2861 let brace_token = braced!(content in input); in parse()
2874 fn expr_range(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprRange> { in expr_range()
2875 let limits: RangeLimits = input.parse()?; in expr_range()
2876 let end = parse_range_end(input, &limits, allow_struct)?; in expr_range()
2887 input: ParseStream, in parse_range_end()
2892 && (input.is_empty() in parse_range_end()
2893 || input.peek(Token![,]) in parse_range_end()
2894 || input.peek(Token![;]) in parse_range_end()
2895 || input.peek(Token![.]) && !input.peek(Token![..]) in parse_range_end()
2896 || input.peek(Token![?]) in parse_range_end()
2897 || input.peek(Token![=>]) in parse_range_end()
2898 || !allow_struct.0 && input.peek(token::Brace) in parse_range_end()
2899 || input.peek(Token![=]) in parse_range_end()
2900 || input.peek(Token![+]) in parse_range_end()
2901 || input.peek(Token![/]) in parse_range_end()
2902 || input.peek(Token![%]) in parse_range_end()
2903 || input.peek(Token![^]) in parse_range_end()
2904 || input.peek(Token![>]) in parse_range_end()
2905 || input.peek(Token![<=]) in parse_range_end()
2906 || input.peek(Token![!=]) in parse_range_end()
2907 || input.peek(Token![-=]) in parse_range_end()
2908 || input.peek(Token![*=]) in parse_range_end()
2909 || input.peek(Token![&=]) in parse_range_end()
2910 || input.peek(Token![|=]) in parse_range_end()
2911 || input.peek(Token![<<=]) in parse_range_end()
2912 || input.peek(Token![as])) in parse_range_end()
2916 let end = parse_binop_rhs(input, allow_struct, Precedence::Range)?; in parse_range_end()
2924 fn parse(input: ParseStream) -> Result<Self> { in parse()
2925 let lookahead = input.lookahead1(); in parse()
2928 let dot_dot_dot = dot_dot && input.peek(Token![...]); in parse()
2930 input.parse().map(RangeLimits::Closed) in parse()
2932 input.parse().map(RangeLimits::HalfOpen) in parse()
2941 pub(crate) fn parse_obsolete(input: ParseStream) -> Result<Self> { in parse_obsolete()
2942 let lookahead = input.lookahead1(); in parse_obsolete()
2945 let dot_dot_dot = dot_dot && input.peek(Token![...]); in parse_obsolete()
2947 input.parse().map(RangeLimits::Closed) in parse_obsolete()
2949 let dot3: Token![...] = input.parse()?; in parse_obsolete()
2952 input.parse().map(RangeLimits::HalfOpen) in parse_obsolete()
2961 fn parse(input: ParseStream) -> Result<Self> { in parse()
2965 let attrs = input.call(Attribute::parse_outer)?; in parse()
2968 let (qself, path) = path::parsing::qpath(input, expr_style)?; in parse()
2976 fn parse(input: ParseStream) -> Result<Self> { in parse()
2977 if input.peek(Ident) { in parse()
2978 input.parse().map(Member::Named) in parse()
2979 } else if input.peek(LitInt) { in parse()
2980 input.parse().map(Member::Unnamed) in parse()
2982 Err(input.error("expected identifier or integer")) in parse()
2989 pub(crate) fn parse_multiple(input: ParseStream) -> Result<Vec<Self>> { in parse_multiple()
2991 while !input.is_empty() { in parse_multiple()
2992 arms.push(input.call(Arm::parse)?); in parse_multiple()
3001 fn parse(input: ParseStream) -> Result<Arm> { in parse()
3004 attrs: input.call(Attribute::parse_outer)?, in parse()
3005 pat: Pat::parse_multi_with_leading_vert(input)?, in parse()
3007 if input.peek(Token![if]) { in parse()
3008 let if_token: Token![if] = input.parse()?; in parse()
3009 let guard: Expr = input.parse()?; in parse()
3015 fat_arrow_token: input.parse()?, in parse()
3017 let body = Expr::parse_with_earlier_boundary_rule(input)?; in parse()
3022 if requires_comma && !input.is_empty() { in parse()
3023 Some(input.parse()?) in parse()
3025 input.parse()? in parse()
3034 fn parse(input: ParseStream) -> Result<Self> { in parse()
3035 let lit: LitInt = input.parse()?; in parse()
3087 fn parse(input: ParseStream) -> Result<Self> { in parse()
3088 let lookahead = input.lookahead1(); in parse()
3090 Ok(PointerMutability::Const(input.parse()?)) in parse()
3092 Ok(PointerMutability::Mut(input.parse()?)) in parse()
3099 fn check_cast(input: ParseStream) -> Result<()> { in check_cast()
3100 let kind = if input.peek(Token![.]) && !input.peek(Token![..]) { in check_cast()
3101 if input.peek2(Token![await]) { in check_cast()
3103 } else if input.peek2(Ident) && (input.peek3(token::Paren) || input.peek3(Token![::])) { in check_cast()
3108 } else if input.peek(Token![?]) { in check_cast()
3110 } else if input.peek(token::Bracket) { in check_cast()
3112 } else if input.peek(token::Paren) { in check_cast()
3118 Err(input.error(msg)) in check_cast()