Enum ExprKind

Source

pub enum ExprKind {
Show 47 variants
    Literal(Literal),
    Var {
        def_id: HirId,
        name: Symbol,
    },
    Binary {
        op: BinOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Unary {
        op: UnOp,
        expr: Box<Expr>,
    },
    Call {
        func: Box<Expr>,
        args: Vec<Expr>,
    },
    MethodCall {
        receiver: Box<Expr>,
        method: Symbol,
        args: Vec<Expr>,
    },
    Field {
        expr: Box<Expr>,
        field: Symbol,
        field_idx: usize,
    },
    Index {
        expr: Box<Expr>,
        index: Box<Expr>,
    },
    MultiDimIndex {
        expr: Box<Expr>,
        indices: Vec<HirIndexComponent>,
    },
    Tuple {
        elements: Vec<Expr>,
    },
    Array {
        elements: Vec<Expr>,
    },
    ArrayRepeat {
        element: Box<Expr>,
        count: u64,
    },
    Struct {
        def_id: HirId,
        fields: Vec<FieldInit>,
        variant_name: Option<Symbol>,
    },
    Block(Block),
    If {
        condition: Box<Expr>,
        then_block: Block,
        else_block: Option<Box<Expr>>,
    },
    Match {
        expr: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Loop {
        body: Block,
    },
    While {
        condition: Box<Expr>,
        body: Block,
    },
    For {
        pattern: Pattern,
        iter: Box<Expr>,
        body: Block,
    },
    Return {
        value: Option<Box<Expr>>,
    },
    Break {
        value: Option<Box<Expr>>,
    },
    Continue,
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
    },
    Ref {
        mutable: bool,
        expr: Box<Expr>,
    },
    Deref {
        expr: Box<Expr>,
    },
    Cast {
        expr: Box<Expr>,
        target_ty: Ty,
    },
    Spawn {
        expr: Box<Expr>,
    },
    SpawnWithDeadline {
        deadline: Box<Expr>,
        body: Block,
    },
    TaskGroup {
        body: Block,
    },
    TaskGroupAll {
        body: Block,
    },
    Channel {
        element_ty: Ty,
        capacity: Box<Expr>,
    },
    Select {
        arms: Vec<HirSelectArm>,
    },
    SelectBiased {
        arms: Vec<HirSelectArm>,
    },
    Gpu {
        body: Block,
    },
    Distributed {
        body: Block,
    },
    EnergyBudgetBlock {
        budget: EnergyBudgetConstraint,
        body: Block,
    },
    ThermalAdapt {
        arms: Vec<HirThermalArm>,
    },
    Await {
        expr: Box<Expr>,
    },
    Try {
        expr: Box<Expr>,
    },
    SpawnRemote {
        node: Box<Expr>,
        expr: Box<Expr>,
    },
    Cancelled,
    Path {
        segments: Vec<Symbol>,
    },
    Closure {
        params: Vec<Param>,
        return_ty: Ty,
        body: Box<Expr>,
        captures: Vec<Capture>,
        is_move: bool,
    },
    Perform {
        effect_name: Symbol,
        operation: Symbol,
        args: Vec<Expr>,
    },
    Handle {
        body: Block,
        handlers: Vec<HirEffectHandler>,
    },
    Parallel {
        pattern: Pattern,
        iter: Box<Expr>,
        body: Block,
    },
    Build {
        builder_ty: Ty,
        body: Block,
    },
}