Enum ExprKind 

pub enum ExprKind {
    Int(i64),
    Float(f64),
    Unit {
        value: String,
        unit: String,
    },
    Str(Vec<StrSeg>),
    RawStr(String),
    Char(char),
    Bool(bool),
    Null,
    Ident(String),
    This,
    Base,
    It,
    Declare {
        ty: Option<Type>,
        name: Name,
        mutable: bool,
    },
    TypeOf(Type),
    NameOf(Box<Expr>),
    Checked {
        expr: Box<Expr>,
        checked: bool,
    },
    Default(Option<Type>),
    Mc(VersionCond),
    Tuple {
        items: Vec<Expr>,
        names: Vec<Option<Name>>,
    },
    Collection(Vec<Element>),
    New {
        ty: Option<Type>,
        args: Option<Vec<Arg>>,
        init: Vec<(Name, Expr)>,
        items: Vec<Stmt>,
    },
    NewArray {
        elem: Option<Type>,
        rank: usize,
        sizes: Vec<Expr>,
        init: Option<Vec<ArrayItem>>,
    },
    Lambda {
        params: Vec<LambdaParam>,
        body: LambdaBody,
        asynchronous: bool,
    },
    Unary {
        op: UnOp,
        expr: Box<Expr>,
    },
    Cast {
        ty: Type,
        expr: Box<Expr>,
    },
    Binary {
        op: BinOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Range {
        from: Box<Expr>,
        to: Box<Expr>,
        inclusive: bool,
    },
    Is {
        expr: Box<Expr>,
        pattern: Box<Pattern>,
    },
    As {
        expr: Box<Expr>,
        ty: Type,
    },
    Has {
        expr: Box<Expr>,
        ty: Type,
    },
    Conditional {
        cond: Box<Expr>,
        then: Box<Expr>,
        otherwise: Box<Expr>,
    },
    With {
        expr: Box<Expr>,
        inits: Vec<(Name, Expr)>,
    },
    Switch {
        expr: Box<Expr>,
        arms: Vec<Arm>,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<Arg>,
    },
    Index {
        expr: Box<Expr>,
        args: Vec<Expr>,
        safe: bool,
    },
    TypeArgs {
        expr: Box<Expr>,
        args: Vec<Type>,
    },
    Member {
        expr: Box<Expr>,
        name: Name,
        safe: bool,
    },
    Macro {
        name: Name,
        args: Vec<Expr>,
    },
    Move(Box<Expr>),
    NotNull(Box<Expr>),
    Error,
}

Variants

Int(i64)

Float(f64)

Unit

Fields

value: String

unit: String

Str(Vec<StrSeg>)

RawStr(String)

Char(char)

Bool(bool)

Null

Ident(String)

This

Base

base: this as its base class (base.Tick()).

It

Declare

out let x, out i32 x: a local declared where a method gives it.

Fields

ty: Option<Type>

name: Name

mutable: bool

TypeOf(Type)

typeof(T): its System.Type.

NameOf(Box<Expr>)

nameof(x.Y): its last name, as a string.

Checked

checked(e) (checked) or unchecked(e): e’s whole-number arithmetic panicking on overflow, or wrapping (C#’s).

Fields

expr: Box<Expr>

checked: bool

Default(Option<Type>)

default, default(T): the type’s zero value.

Mc(VersionCond)

mc >= 1.21: the running game’s version.

Tuple

(a, b), (X: 1, Y: 2): a tuple, its items’ names where written.

Fields

items: Vec<Expr>

names: Vec<Option<Name>>

Collection(Vec<Element>)

[a, b], [k => v], [..xs]: a list, a set or a map by its target.

New

new Pos(1, 2, 3), new(4), new Battery { Count = 2 }.

Fields

ty: Option<Type>

args: Option<Vec<Arg>>

init: Vec<(Name, Expr)>

items: Vec<Stmt>

A collection initializer’s items, each a statement on the object made (members::MADE): $made.Add(1);, $made.Add(k, v);, $made[k] = v;.

NewArray

new i32[n], new i32[2, 3], new i32[3][], new[] { 1, 2 }, new i32[,] { { 1, 2 }, { 3, 4 } }: an array made. elem is its items’ type (none: the items’ own), rank its dimensions.

Fields

elem: Option<Type>

rank: usize

sizes: Vec<Expr>

init: Option<Vec<ArrayItem>>

Lambda

x => …, (a, b) => …, { … } after a call (it its parameter).

Fields

params: Vec<LambdaParam>

body: LambdaBody

asynchronous: bool

async x => …: it awaits; it gives a Task.

Unary

Fields

op: UnOp

expr: Box<Expr>

Cast

(i32)x.

Fields

ty: Type

expr: Box<Expr>

Binary

Fields

op: BinOp

left: Box<Expr>

right: Box<Expr>

Range

Fields

from: Box<Expr>

to: Box<Expr>

inclusive: bool

Is

x is Monster m, x is not null.

Fields

expr: Box<Expr>

pattern: Box<Pattern>

As

x as T: null when it isn’t one.

Fields

expr: Box<Expr>

ty: Type

Has

x has Charge.

Fields

expr: Box<Expr>

ty: Type

Conditional

c ? a : b.

Fields

cond: Box<Expr>

then: Box<Expr>

otherwise: Box<Expr>

With

x with { Y = 64 }: a copy, members changed.

Fields

expr: Box<Expr>

inits: Vec<(Name, Expr)>

Switch

x switch { … }.

Fields

expr: Box<Expr>

arms: Vec<Arm>

Call

Fields

callee: Box<Expr>

args: Vec<Arg>

Index

a[i], grid[x, y]: an indexer’s or an array’s element.

Fields

expr: Box<Expr>

args: Vec<Expr>

safe: bool

a?[i]: null when a is.

TypeArgs

f<T, U> before a call: the type arguments.

Fields

expr: Box<Expr>

args: Vec<Type>

Member

x.Name, x?.Name.

Fields

expr: Box<Expr>

name: Name

safe: bool

Macro

panic!(…): a built-in macro’s call (a declared macro’s is expanded before the parser sees it).

Fields

name: Name

args: Vec<Expr>

Move(Box<Expr>)

move x: x handed on, gone after.

NotNull(Box<Expr>)

x!: asserted not null.

Error

What couldn’t be parsed (reported already).

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl PartialEq for ExprKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ExprKind