Lines Matching refs:Expr
114 pub enum Expr {
277 pub elems: Punctuated<Expr, Token![,]>,
286 pub left: Box<Expr>,
288 pub right: Box<Expr>,
308 pub base: Box<Expr>,
319 pub left: Box<Expr>,
321 pub right: Box<Expr>,
343 pub expr: Option<Box<Expr>>,
352 pub func: Box<Expr>,
354 pub args: Punctuated<Expr, Token![,]>,
363 pub expr: Box<Expr>,
383 pub body: Box<Expr>,
413 pub base: Box<Expr>,
428 pub expr: Box<Expr>,
443 pub expr: Box<Expr>,
457 pub cond: Box<Expr>,
459 pub else_branch: Option<(Token![else], Box<Expr>)>,
468 pub expr: Box<Expr>,
470 pub index: Box<Expr>,
491 pub expr: Box<Expr>,
530 pub expr: Box<Expr>,
541 pub receiver: Box<Expr>,
546 pub args: Punctuated<Expr, Token![,]>,
556 pub expr: Box<Expr>,
578 pub start: Option<Box<Expr>>,
580 pub end: Option<Box<Expr>>,
592 pub expr: Box<Expr>,
603 pub expr: Box<Expr>,
613 pub expr: Box<Expr>,
615 pub len: Box<Expr>,
625 pub expr: Option<Box<Expr>>,
642 pub rest: Option<Box<Expr>>,
651 pub expr: Box<Expr>,
672 pub elems: Punctuated<Expr, Token![,]>,
682 pub expr: Box<Expr>,
703 pub cond: Box<Expr>,
714 pub expr: Option<Box<Expr>>,
718 impl Expr { impl
738 pub const PLACEHOLDER: Self = Expr::Path(ExprPath {
830 pub fn parse_without_eager_brace(input: ParseStream) -> Result<Expr> { in parse_without_eager_brace() argument
892 pub fn parse_with_earlier_boundary_rule(input: ParseStream) -> Result<Expr> { in parse_with_earlier_boundary_rule() argument
929 Expr::Array(ExprArray { attrs, .. }) in replace_attrs()
930 | Expr::Assign(ExprAssign { attrs, .. }) in replace_attrs()
931 | Expr::Async(ExprAsync { attrs, .. }) in replace_attrs()
932 | Expr::Await(ExprAwait { attrs, .. }) in replace_attrs()
933 | Expr::Binary(ExprBinary { attrs, .. }) in replace_attrs()
934 | Expr::Block(ExprBlock { attrs, .. }) in replace_attrs()
935 | Expr::Break(ExprBreak { attrs, .. }) in replace_attrs()
936 | Expr::Call(ExprCall { attrs, .. }) in replace_attrs()
937 | Expr::Cast(ExprCast { attrs, .. }) in replace_attrs()
938 | Expr::Closure(ExprClosure { attrs, .. }) in replace_attrs()
939 | Expr::Const(ExprConst { attrs, .. }) in replace_attrs()
940 | Expr::Continue(ExprContinue { attrs, .. }) in replace_attrs()
941 | Expr::Field(ExprField { attrs, .. }) in replace_attrs()
942 | Expr::ForLoop(ExprForLoop { attrs, .. }) in replace_attrs()
943 | Expr::Group(ExprGroup { attrs, .. }) in replace_attrs()
944 | Expr::If(ExprIf { attrs, .. }) in replace_attrs()
945 | Expr::Index(ExprIndex { attrs, .. }) in replace_attrs()
946 | Expr::Infer(ExprInfer { attrs, .. }) in replace_attrs()
947 | Expr::Let(ExprLet { attrs, .. }) in replace_attrs()
948 | Expr::Lit(ExprLit { attrs, .. }) in replace_attrs()
949 | Expr::Loop(ExprLoop { attrs, .. }) in replace_attrs()
950 | Expr::Macro(ExprMacro { attrs, .. }) in replace_attrs()
951 | Expr::Match(ExprMatch { attrs, .. }) in replace_attrs()
952 | Expr::MethodCall(ExprMethodCall { attrs, .. }) in replace_attrs()
953 | Expr::Paren(ExprParen { attrs, .. }) in replace_attrs()
954 | Expr::Path(ExprPath { attrs, .. }) in replace_attrs()
955 | Expr::Range(ExprRange { attrs, .. }) in replace_attrs()
956 | Expr::RawAddr(ExprRawAddr { attrs, .. }) in replace_attrs()
957 | Expr::Reference(ExprReference { attrs, .. }) in replace_attrs()
958 | Expr::Repeat(ExprRepeat { attrs, .. }) in replace_attrs()
959 | Expr::Return(ExprReturn { attrs, .. }) in replace_attrs()
960 | Expr::Struct(ExprStruct { attrs, .. }) in replace_attrs()
961 | Expr::Try(ExprTry { attrs, .. }) in replace_attrs()
962 | Expr::TryBlock(ExprTryBlock { attrs, .. }) in replace_attrs()
963 | Expr::Tuple(ExprTuple { attrs, .. }) in replace_attrs()
964 | Expr::Unary(ExprUnary { attrs, .. }) in replace_attrs()
965 | Expr::Unsafe(ExprUnsafe { attrs, .. }) in replace_attrs()
966 | Expr::While(ExprWhile { attrs, .. }) in replace_attrs()
967 | Expr::Yield(ExprYield { attrs, .. }) => mem::replace(attrs, new), in replace_attrs()
968 Expr::Verbatim(_) => Vec::new(), in replace_attrs()
1106 pub expr: Expr,
1143 pub guard: Option<(Token![if], Box<Expr>)>,
1145 pub body: Box<Expr>,
1189 Expr, ExprBinary, ExprCall, ExprCast, ExprField, ExprGroup, ExprIndex, ExprLit, ExprMacro,
1230 impl Parse for Expr { implementation
1241 pub(super) fn parse_with_earlier_boundary_rule(input: ParseStream) -> Result<Expr> { in parse_with_earlier_boundary_rule() argument
1252 Expr::If(input.parse()?) in parse_with_earlier_boundary_rule()
1254 Expr::While(input.parse()?) in parse_with_earlier_boundary_rule()
1258 Expr::ForLoop(input.parse()?) in parse_with_earlier_boundary_rule()
1260 Expr::Loop(input.parse()?) in parse_with_earlier_boundary_rule()
1262 Expr::Match(input.parse()?) in parse_with_earlier_boundary_rule()
1264 Expr::TryBlock(input.parse()?) in parse_with_earlier_boundary_rule()
1266 Expr::Unsafe(input.parse()?) in parse_with_earlier_boundary_rule()
1268 Expr::Const(input.parse()?) in parse_with_earlier_boundary_rule()
1270 Expr::Block(input.parse()?) in parse_with_earlier_boundary_rule()
1314 mut lhs: Expr, in parse_expr() argument
1317 ) -> Result<Expr> { in parse_expr() argument
1320 if let Expr::Range(_) = lhs { in parse_expr()
1329 if let Expr::Range(_) = lhs { in parse_expr()
1334 if let Expr::Binary(lhs) = &lhs { in parse_expr()
1342 lhs = Expr::Binary(ExprBinary { in parse_expr()
1352 Expr::Range(_) => false, in parse_expr()
1358 lhs = Expr::Assign(ExprAssign { in parse_expr()
1367 lhs = Expr::Range(ExprRange { in parse_expr()
1379 lhs = Expr::Cast(ExprCast { in parse_expr()
1393 fn parse_expr(input: ParseStream, mut lhs: Expr, base: Precedence) -> Result<Expr> { in parse_expr() argument
1402 if let Expr::Binary(lhs) = &lhs { in parse_expr()
1410 lhs = Expr::Binary(ExprBinary { in parse_expr()
1422 lhs = Expr::Cast(ExprCast { in parse_expr()
1439 ) -> Result<Box<Expr>> { in parse_binop_rhs() argument
1488 ) -> Result<Expr> { in ambiguous_expr() argument
1517 fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { in unary_expr() argument
1541 Ok(Expr::RawAddr(ExprRawAddr { in unary_expr()
1552 Ok(Expr::Reference(ExprReference { in unary_expr()
1560 expr_unary(input, attrs, allow_struct).map(Expr::Unary) in unary_expr()
1567 fn unary_expr(input: ParseStream) -> Result<Expr> { in unary_expr() argument
1569 Ok(Expr::Reference(ExprReference { in unary_expr()
1576 Ok(Expr::Unary(ExprUnary { in unary_expr()
1598 ) -> Result<Expr> { in trailer_expr() argument
1602 if let Expr::Verbatim(tokens) = &mut e { in trailer_expr()
1605 if let Expr::Range(range) = e { in trailer_expr()
1625 fn trailer_helper(input: ParseStream, mut e: Expr) -> Result<Expr> { in trailer_helper() argument
1629 e = Expr::Call(ExprCall { in trailer_helper()
1633 args: content.parse_terminated(Expr::parse, Token![,])?, in trailer_helper()
1638 Expr::Range(_) => false, in trailer_helper()
1653 e = Expr::Await(ExprAwait { in trailer_helper()
1672 e = Expr::MethodCall(ExprMethodCall { in trailer_helper()
1679 args: content.parse_terminated(Expr::parse, Token![,])?, in trailer_helper()
1685 e = Expr::Field(ExprField { in trailer_helper()
1693 e = Expr::Index(ExprIndex { in trailer_helper()
1701 Expr::Range(_) => false, in trailer_helper()
1705 e = Expr::Try(ExprTry { in trailer_helper()
1718 fn trailer_expr(input: ParseStream) -> Result<Expr> { in trailer_expr() argument
1724 e = Expr::Call(ExprCall { in trailer_expr()
1728 args: content.parse_terminated(Expr::parse, Token![,])?, in trailer_expr()
1756 e = Expr::MethodCall(ExprMethodCall { in trailer_expr()
1763 args: content.parse_terminated(Expr::parse, Token![,])?, in trailer_expr()
1769 e = Expr::Field(ExprField { in trailer_expr()
1777 e = Expr::Index(ExprIndex { in trailer_expr()
1794 fn atom_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { in atom_expr() argument
1798 input.parse().map(Expr::Lit) in atom_expr()
1802 input.parse().map(Expr::Async) in atom_expr()
1804 input.parse().map(Expr::TryBlock) in atom_expr()
1813 expr_closure(input, allow_struct).map(Expr::Closure) in atom_expr()
1830 expr_break(input, allow_struct).map(Expr::Break) in atom_expr()
1832 input.parse().map(Expr::Continue) in atom_expr()
1834 input.parse().map(Expr::Return) in atom_expr()
1840 expr_let(input, allow_struct).map(Expr::Let) in atom_expr()
1842 input.parse().map(Expr::If) in atom_expr()
1844 input.parse().map(Expr::While) in atom_expr()
1846 input.parse().map(Expr::ForLoop) in atom_expr()
1848 input.parse().map(Expr::Loop) in atom_expr()
1850 input.parse().map(Expr::Match) in atom_expr()
1852 input.parse().map(Expr::Yield) in atom_expr()
1854 input.parse().map(Expr::Unsafe) in atom_expr()
1856 input.parse().map(Expr::Const) in atom_expr()
1858 input.parse().map(Expr::Block) in atom_expr()
1860 expr_range(input, allow_struct).map(Expr::Range) in atom_expr()
1862 input.parse().map(Expr::Infer) in atom_expr()
1871 fn atom_labeled(input: ParseStream) -> Result<Expr> { in atom_labeled() argument
1874 Expr::While(input.parse()?) in atom_labeled()
1876 Expr::ForLoop(input.parse()?) in atom_labeled()
1878 Expr::Loop(input.parse()?) in atom_labeled()
1880 Expr::Block(input.parse()?) in atom_labeled()
1885 Expr::While(ExprWhile { label, .. }) in atom_labeled()
1886 | Expr::ForLoop(ExprForLoop { label, .. }) in atom_labeled()
1887 | Expr::Loop(ExprLoop { label, .. }) in atom_labeled()
1888 | Expr::Block(ExprBlock { label, .. }) => *label = Some(the_label), in atom_labeled()
1895 fn atom_expr(input: ParseStream) -> Result<Expr> { in atom_expr() argument
1899 input.parse().map(Expr::Lit) in atom_expr()
1918 if content.parse::<Expr>().is_ok() && content.is_empty() { in atom_expr()
1921 return Ok(Expr::Verbatim(expr_block)); in atom_expr()
1929 fn expr_builtin(input: ParseStream) -> Result<Expr> { in expr_builtin() argument
1940 Ok(Expr::Verbatim(verbatim::between(&begin, input))) in expr_builtin()
1946 ) -> Result<Expr> { in path_or_macro_or_struct() argument
1963 ) -> Result<Expr> { in rest_of_path_or_macro_or_struct() argument
1971 return Ok(Expr::Macro(ExprMacro { 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()
1988 Ok(Expr::Path(ExprPath { in rest_of_path_or_macro_or_struct()
2005 fn paren_or_tuple(input: ParseStream) -> Result<Expr> { in paren_or_tuple() argument
2009 return Ok(Expr::Tuple(ExprTuple { in paren_or_tuple()
2016 let first: Expr = content.parse()?; in paren_or_tuple()
2018 return Ok(Expr::Paren(ExprParen { in paren_or_tuple()
2036 Ok(Expr::Tuple(ExprTuple { in paren_or_tuple()
2044 fn array_or_repeat(input: ParseStream) -> Result<Expr> { in array_or_repeat() argument
2048 return Ok(Expr::Array(ExprArray { in array_or_repeat()
2055 let first: Expr = content.parse()?; in array_or_repeat()
2068 Ok(Expr::Array(ExprArray { in array_or_repeat()
2075 let len: Expr = content.parse()?; in array_or_repeat()
2076 Ok(Expr::Repeat(ExprRepeat { in array_or_repeat()
2097 let first: Expr = content.parse()?; in parse()
2130 fn continue_parsing_early(mut expr: &Expr) -> bool { in continue_parsing_early()
2131 while let Expr::Group(group) = expr { in continue_parsing_early()
2135 Expr::If(_) in continue_parsing_early()
2136 | Expr::While(_) in continue_parsing_early()
2137 | Expr::ForLoop(_) in continue_parsing_early()
2138 | Expr::Loop(_) in continue_parsing_early()
2139 | Expr::Match(_) in continue_parsing_early()
2140 | Expr::TryBlock(_) in continue_parsing_early()
2141 | Expr::Unsafe(_) in continue_parsing_early()
2142 | Expr::Const(_) in continue_parsing_early()
2143 | Expr::Block(_) => false, in continue_parsing_early()
2161 ) -> Result<Expr> { in expr_group() argument
2163 let mut inner: Expr = group.content.parse()?; in expr_group()
2166 Expr::Path(mut expr) if expr.attrs.is_empty() => { in expr_group()
2176 Expr::Path(expr) if expr.path.segments.len() == grouped_len => { in expr_group()
2177 inner = Expr::Path(expr); in expr_group()
2185 Ok(Expr::Group(ExprGroup { in expr_group()
2238 let cond = input.call(Expr::parse_without_eager_brace)?; in parse()
2256 expr.else_branch = Some((else_token, Box::new(Expr::PLACEHOLDER))); in parse()
2261 Box::new(Expr::Block(ExprBlock { in parse()
2274 *prev.else_branch.as_mut().unwrap().1 = Expr::If(expr); in parse()
2304 let expr: Expr = input.call(Expr::parse_without_eager_brace)?; in parse()
2351 let expr = Expr::parse_without_eager_brace(input)?; in parse()
2380 let mut expr: Expr = input.parse()?;
2383 Expr::$variant(inner) => return Ok(inner),
2384 Expr::Group(next) => expr = *next.expr,
2486 if Expr::peek(input) { in parse()
2497 fn expr_become(input: ParseStream) -> Result<Expr> { in expr_become() argument
2500 input.parse::<Expr>()?; in expr_become()
2501 Ok(Expr::Verbatim(verbatim::between(&begin, input))) in expr_become()
2524 if Expr::peek(input) { in parse()
2564 let block = Expr::Block(ExprBlock { in expr_closure()
2646 let cond = Expr::parse_without_eager_brace(input)?; in parse()
2726 let _: Expr = input.parse()?; in expr_break()
2737 let expr = if Expr::peek(input) && (allow_struct.0 || !input.peek(token::Brace)) { in expr_break()
2758 let value: Expr = input.parse()?; in parse()
2761 let value = Expr::Path(ExprPath { in parse()
2890 ) -> Result<Option<Box<Expr>>> { in parse_range_end() argument
3009 let guard: Expr = input.parse()?; in parse()
3017 let body = Expr::parse_with_earlier_boundary_rule(input)?; in parse()
3050 fn multi_index(e: &mut Expr, dot_token: &mut Token![.], float: LitFloat) -> Result<bool> { in multi_index() argument
3066 let base = mem::replace(e, Expr::PLACEHOLDER); in multi_index()
3067 *e = Expr::Field(ExprField { in multi_index()
3137 Expr, ExprBinary, ExprCall, ExprCast, ExprField, ExprGroup, ExprIndex, ExprLit, ExprMacro,
3166 expr: &Expr, in print_subexpression() argument
3195 pub(crate) fn print_expr(expr: &Expr, tokens: &mut TokenStream, mut fixup: FixupContext) { in print_expr() argument
3207 Expr::Array(e) => e.to_tokens(tokens), in print_expr()
3209 Expr::Assign(e) => print_expr_assign(e, tokens, fixup), in print_expr()
3211 Expr::Async(e) => e.to_tokens(tokens), in print_expr()
3213 Expr::Await(e) => print_expr_await(e, tokens, fixup), in print_expr()
3214 Expr::Binary(e) => print_expr_binary(e, tokens, fixup), in print_expr()
3216 Expr::Block(e) => e.to_tokens(tokens), in print_expr()
3218 Expr::Break(e) => print_expr_break(e, tokens, fixup), in print_expr()
3219 Expr::Call(e) => print_expr_call(e, tokens, fixup), in print_expr()
3220 Expr::Cast(e) => print_expr_cast(e, tokens, fixup), in print_expr()
3222 Expr::Closure(e) => print_expr_closure(e, tokens, fixup), in print_expr()
3224 Expr::Const(e) => e.to_tokens(tokens), in print_expr()
3226 Expr::Continue(e) => e.to_tokens(tokens), in print_expr()
3227 Expr::Field(e) => print_expr_field(e, tokens, fixup), in print_expr()
3229 Expr::ForLoop(e) => e.to_tokens(tokens), in print_expr()
3230 Expr::Group(e) => e.to_tokens(tokens), in print_expr()
3232 Expr::If(e) => e.to_tokens(tokens), in print_expr()
3233 Expr::Index(e) => print_expr_index(e, tokens, fixup), in print_expr()
3235 Expr::Infer(e) => e.to_tokens(tokens), in print_expr()
3237 Expr::Let(e) => print_expr_let(e, tokens, fixup), in print_expr()
3238 Expr::Lit(e) => e.to_tokens(tokens), in print_expr()
3240 Expr::Loop(e) => e.to_tokens(tokens), in print_expr()
3241 Expr::Macro(e) => e.to_tokens(tokens), in print_expr()
3243 Expr::Match(e) => e.to_tokens(tokens), in print_expr()
3244 Expr::MethodCall(e) => print_expr_method_call(e, tokens, fixup), in print_expr()
3245 Expr::Paren(e) => e.to_tokens(tokens), in print_expr()
3246 Expr::Path(e) => e.to_tokens(tokens), in print_expr()
3248 Expr::Range(e) => print_expr_range(e, tokens, fixup), in print_expr()
3250 Expr::RawAddr(e) => print_expr_raw_addr(e, tokens, fixup), in print_expr()
3251 Expr::Reference(e) => print_expr_reference(e, tokens, fixup), in print_expr()
3253 Expr::Repeat(e) => e.to_tokens(tokens), in print_expr()
3255 Expr::Return(e) => print_expr_return(e, tokens, fixup), in print_expr()
3256 Expr::Struct(e) => e.to_tokens(tokens), in print_expr()
3258 Expr::Try(e) => print_expr_try(e, tokens, fixup), in print_expr()
3260 Expr::TryBlock(e) => e.to_tokens(tokens), in print_expr()
3261 Expr::Tuple(e) => e.to_tokens(tokens), in print_expr()
3262 Expr::Unary(e) => print_expr_unary(e, tokens, fixup), in print_expr()
3264 Expr::Unsafe(e) => e.to_tokens(tokens), in print_expr()
3265 Expr::Verbatim(e) => e.to_tokens(tokens), in print_expr()
3267 Expr::While(e) => e.to_tokens(tokens), in print_expr()
3269 Expr::Yield(e) => print_expr_yield(e, tokens, fixup), in print_expr()
3489 let needs_group = if let Expr::Field(func) = &*e.func { in print_expr_call()
3558 … || matches!(&*e.body, Expr::Block(body) if body.attrs.is_empty() && body.label.is_none()) in print_expr_closure()
3661 Expr::If(next) => { in to_tokens()
3664 Expr::Block(last) => { in to_tokens()
3813 PathStyle::Expr, in print_expr_method_call()
3835 path::printing::print_qpath(tokens, &self.qself, &self.path, PathStyle::Expr); in to_tokens()
3967 path::printing::print_qpath(tokens, &self.qself, &self.path, PathStyle::Expr); in to_tokens()