Enum mamba::check::ast::NodeTy

source ·

pub enum NodeTy {
Show 81 variants    Import {
        from: Option<Box<ASTTy>>,
        import: Vec<ASTTy>,
        alias: Vec<ASTTy>,
    },
    Class {
        ty: StringName,
        args: Vec<ASTTy>,
        parents: Vec<ASTTy>,
        body: Option<Box<ASTTy>>,
    },
    Parent {
        ty: StringName,
        args: Vec<ASTTy>,
    },
    Reassign {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
        op: NodeOp,
    },
    VariableDef {
        mutable: bool,
        var: Box<ASTTy>,
        ty: Option<Name>,
        expr: Option<Box<ASTTy>>,
        forward: Vec<ASTTy>,
    },
    FunDef {
        pure: bool,
        id: Box<ASTTy>,
        args: Vec<ASTTy>,
        ret: Option<Name>,
        raises: Vec<ASTTy>,
        body: Option<Box<ASTTy>>,
    },
    AnonFun {
        args: Vec<ASTTy>,
        body: Box<ASTTy>,
    },
    Raises {
        expr_or_stmt: Box<ASTTy>,
        errors: Vec<ASTTy>,
    },
    Raise {
        error: Box<ASTTy>,
    },
    Handle {
        expr_or_stmt: Box<ASTTy>,
        cases: Vec<ASTTy>,
    },
    With {
        resource: Box<ASTTy>,
        alias: Option<(Box<ASTTy>, bool, Option<Name>)>,
        expr: Box<ASTTy>,
    },
    FunctionCall {
        name: StringName,
        args: Vec<ASTTy>,
    },
    PropertyCall {
        instance: Box<ASTTy>,
        property: Box<ASTTy>,
    },
    Id {
        lit: String,
    },
    ExpressionType {
        expr: Box<ASTTy>,
        mutable: bool,
        ty: Option<Name>,
    },
    TypeDef {
        ty: StringName,
        isa: Option<Name>,
        body: Option<Box<ASTTy>>,
    },
    TypeAlias {
        ty: StringName,
        isa: Name,
        conditions: Vec<ASTTy>,
    },
    Condition {
        cond: Box<ASTTy>,
        el: Option<Box<ASTTy>>,
    },
    FunArg {
        vararg: bool,
        mutable: bool,
        var: Box<ASTTy>,
        ty: Option<Name>,
        default: Option<Box<ASTTy>>,
    },
    Dict {
        elements: Vec<(ASTTy, ASTTy)>,
    },
    DictBuilder {
        from: Box<ASTTy>,
        to: Box<ASTTy>,
        conditions: Vec<ASTTy>,
    },
    Set {
        elements: Vec<ASTTy>,
    },
    SetBuilder {
        item: Box<ASTTy>,
        conditions: Vec<ASTTy>,
    },
    List {
        elements: Vec<ASTTy>,
    },
    ListBuilder {
        item: Box<ASTTy>,
        conditions: Vec<ASTTy>,
    },
    Tuple {
        elements: Vec<ASTTy>,
    },
    Range {
        from: Box<ASTTy>,
        to: Box<ASTTy>,
        inclusive: bool,
        step: Option<Box<ASTTy>>,
    },
    Slice {
        from: Box<ASTTy>,
        to: Box<ASTTy>,
        inclusive: bool,
        step: Option<Box<ASTTy>>,
    },
    Index {
        item: Box<ASTTy>,
        range: Box<ASTTy>,
    },
    Block {
        statements: Vec<ASTTy>,
    },
    Real {
        lit: String,
    },
    Int {
        lit: String,
    },
    ENum {
        num: String,
        exp: String,
    },
    Str {
        lit: String,
        expressions: Vec<ASTTy>,
    },
    DocStr {
        lit: String,
    },
    Bool {
        lit: bool,
    },
    Add {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    AddU {
        expr: Box<ASTTy>,
    },
    Sub {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    SubU {
        expr: Box<ASTTy>,
    },
    Mul {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Div {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    FDiv {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Mod {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Pow {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Sqrt {
        expr: Box<ASTTy>,
    },
    BAnd {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    BOr {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    BXOr {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    BOneCmpl {
        expr: Box<ASTTy>,
    },
    BLShift {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    BRShift {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Le {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Ge {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Leq {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Geq {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Is {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    IsN {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Eq {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Neq {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    IsA {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    IsNA {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Not {
        expr: Box<ASTTy>,
    },
    And {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    Or {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    IfElse {
        cond: Box<ASTTy>,
        then: Box<ASTTy>,
        el: Option<Box<ASTTy>>,
    },
    Match {
        cond: Box<ASTTy>,
        cases: Vec<ASTTy>,
    },
    Case {
        cond: Box<ASTTy>,
        body: Box<ASTTy>,
    },
    For {
        expr: Box<ASTTy>,
        col: Box<ASTTy>,
        body: Box<ASTTy>,
    },
    In {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    While {
        cond: Box<ASTTy>,
        body: Box<ASTTy>,
    },
    Break,
    Continue,
    Return {
        expr: Box<ASTTy>,
    },
    ReturnEmpty,
    Underscore,
    Undefined,
    Pass,
    Question {
        left: Box<ASTTy>,
        right: Box<ASTTy>,
    },
    QuestionOp {
        expr: Box<ASTTy>,
    },
    Empty,
}