Enum CSharpExpr 

pub enum CSharpExpr {
    Lit(CSharpLit),
    Var(String),
    BinOp {
        op: String,
        lhs: Box<CSharpExpr>,
        rhs: Box<CSharpExpr>,
    },
    UnaryOp {
        op: String,
        operand: Box<CSharpExpr>,
    },
    Call {
        callee: Box<CSharpExpr>,
        args: Vec<CSharpExpr>,
    },
    MethodCall {
        receiver: Box<CSharpExpr>,
        method: String,
        type_args: Vec<CSharpType>,
        args: Vec<CSharpExpr>,
    },
    New {
        ty: CSharpType,
        args: Vec<CSharpExpr>,
    },
    Lambda {
        params: Vec<(String, Option<CSharpType>)>,
        body: Box<CSharpExpr>,
    },
    Ternary {
        cond: Box<CSharpExpr>,
        then_expr: Box<CSharpExpr>,
        else_expr: Box<CSharpExpr>,
    },
    Null,
    Default(Option<CSharpType>),
    NameOf(String),
    TypeOf(CSharpType),
    Await(Box<CSharpExpr>),
    Throw(Box<CSharpExpr>),
    Is {
        expr: Box<CSharpExpr>,
        pattern: String,
    },
    As {
        expr: Box<CSharpExpr>,
        ty: CSharpType,
    },
    Member(Box<CSharpExpr>, String),
    Index(Box<CSharpExpr>, Box<CSharpExpr>),
    SwitchExpr {
        scrutinee: Box<CSharpExpr>,
        arms: Vec<CSharpSwitchArm>,
    },
    Interpolated(Vec<CSharpInterpolationPart>),
    CollectionExpr(Vec<CSharpExpr>),
}

C# expression AST for code generation.

Variants

Lit(CSharpLit)

A literal value: 42, "hello", true, null

Var(String)

A variable or identifier: x, myVar, MyType

BinOp

Binary operator: lhs + rhs, a == b

Fields

op: String

lhs: Box<CSharpExpr>

rhs: Box<CSharpExpr>

UnaryOp

Unary operator: !x, -n, ~flags

Fields

op: String

operand: Box<CSharpExpr>

Call

Static/free function call: Math.Abs(x), Foo(a, b)

Fields

callee: Box<CSharpExpr>

args: Vec<CSharpExpr>

MethodCall

Method call on a receiver: list.Where(pred)

Fields

receiver: Box<CSharpExpr>

method: String

type_args: Vec<CSharpType>

args: Vec<CSharpExpr>

New

Object creation: new Foo(a, b)

Fields

ty: CSharpType

args: Vec<CSharpExpr>

Lambda

Lambda / anonymous function: x => x + 1 or (x, y) => x + y

Fields

params: Vec<(String, Option<CSharpType>)>

body: Box<CSharpExpr>

Ternary

Ternary conditional: cond ? then_expr : else_expr

Fields

cond: Box<CSharpExpr>

then_expr: Box<CSharpExpr>

else_expr: Box<CSharpExpr>

Null

null literal (convenience alias)

Default(Option<CSharpType>)

default(T) or default

NameOf(String)

nameof(x) expression

TypeOf(CSharpType)

typeof(T) expression

Await(Box<CSharpExpr>)

await expr

Throw(Box<CSharpExpr>)

throw new Exception(msg) as expression (C# 7+)

Is

expr is Pattern / expr is Type varName

Fields

expr: Box<CSharpExpr>

pattern: String

As

expr as Type

Fields

expr: Box<CSharpExpr>

ty: CSharpType

Member(Box<CSharpExpr>, String)

Member access: obj.Field

Index(Box<CSharpExpr>, Box<CSharpExpr>)

Index access: arr[idx]

SwitchExpr

Switch expression: expr switch { arm1, arm2, ... }

Fields

scrutinee: Box<CSharpExpr>

arms: Vec<CSharpSwitchArm>

Interpolated(Vec<CSharpInterpolationPart>)

String interpolation: $"Hello {name}!"

CollectionExpr(Vec<CSharpExpr>)

Collection expression: [a, b, c] (C# 12)

Trait Implementations

impl Clone for CSharpExpr

fn clone(&self) -> CSharpExpr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CSharpExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for CSharpExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CSharpExpr

fn eq(&self, other: &CSharpExpr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CSharpExpr