Enum AlephTree

Source

pub enum AlephTree {
Show 191 variants    Unit,
    Break,
    Continue,
    Ellipsis,
    Int {
        value: String,
    },
    Float {
        value: String,
    },
    Bool {
        value: String,
    },
    String {
        value: String,
    },
    Ident {
        value: String,
    },
    Bytes {
        elems: Vec<u8>,
    },
    Complex {
        real: String,
        imag: String,
    },
    HexLiteral {
        value: String,
    },
    Figurative {
        figurative_type: String,
    },
    Tuple {
        elems: Vec<Box<AlephTree>>,
    },
    Array {
        elems: Vec<Box<AlephTree>>,
    },
    Record {
        fields: Vec<Box<AlephTree>>,
    },
    Field {
        name: String,
        value: Box<AlephTree>,
    },
    Neg {
        expr: Box<AlephTree>,
    },
    Not {
        bool_expr: Box<AlephTree>,
    },
    BitNot {
        expr: Box<AlephTree>,
    },
    Abs {
        expr: Box<AlephTree>,
    },
    Add {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Sub {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Mul {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Div {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Mod {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    DivMod {
        dividend: Box<AlephTree>,
        divisor: Box<AlephTree>,
    },
    MulDiv {
        n1: Box<AlephTree>,
        n2: Box<AlephTree>,
        n3: Box<AlephTree>,
    },
    MulDivMod {
        n1: Box<AlephTree>,
        n2: Box<AlephTree>,
        n3: Box<AlephTree>,
    },
    Pow {
        base: Box<AlephTree>,
        exponent: Box<AlephTree>,
    },
    Min {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    Max {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    And {
        bool_expr1: Box<AlephTree>,
        bool_expr2: Box<AlephTree>,
    },
    Or {
        bool_expr1: Box<AlephTree>,
        bool_expr2: Box<AlephTree>,
    },
    Xor {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    BitAnd {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    BitOr {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    BitXor {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LShift {
        expr: Box<AlephTree>,
        amount: Box<AlephTree>,
    },
    RShift {
        expr: Box<AlephTree>,
        amount: Box<AlephTree>,
    },
    Eq {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    NotEq {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LT {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LE {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    GT {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    GE {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    In {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    If {
        condition: Box<AlephTree>,
        then: Box<AlephTree>,
        els: Box<AlephTree>,
    },
    While {
        init_expr: Box<AlephTree>,
        condition: Box<AlephTree>,
        loop_expr: Box<AlephTree>,
        post_expr: Box<AlephTree>,
    },
    For {
        var: String,
        start: Box<AlephTree>,
        end: Box<AlephTree>,
        step: Option<Box<AlephTree>>,
        body: Box<AlephTree>,
        reverse: bool,
    },
    Loop {
        name: Option<String>,
        body: Vec<Box<AlephTree>>,
    },
    DoLoop {
        loop_var: Option<String>,
        start: Option<Box<AlephTree>>,
        end: Option<Box<AlephTree>>,
        by: Option<Box<AlephTree>>,
        while_cond: Option<Box<AlephTree>>,
        until_cond: Option<Box<AlephTree>>,
        body: Vec<Box<AlephTree>>,
    },
    Case {
        expr: Box<AlephTree>,
        cases: Vec<Box<AlephTree>>,
        default_case: Option<Box<AlephTree>>,
    },
    CaseBranch {
        pattern: Box<AlephTree>,
        body: Vec<Box<AlephTree>>,
    },
    Match {
        expr: Box<AlephTree>,
        case_list: Vec<Box<AlephTree>>,
    },
    MatchLine {
        condition: Box<AlephTree>,
        case_expr: Box<AlephTree>,
    },
    ProcedureDef {
        name: String,
        proc_type: Option<String>,
        parameters: Vec<Box<AlephTree>>,
        return_type: Option<Box<AlephTree>>,
        attributes: Vec<String>,
        declarations: Vec<Box<AlephTree>>,
        body: Vec<Box<AlephTree>>,
    },
    Parameter {
        name: String,
        param_type: Option<Box<AlephTree>>,
        mode: Option<String>,
        default: Option<Box<AlephTree>>,
    },
    VarDecl {
        name: String,
        level: Option<String>,
        var_type: Option<Box<AlephTree>>,
        initial_value: Option<Box<AlephTree>>,
        is_constant: bool,
        is_aliased: bool,
        storage: Option<String>,
        occurs: Option<String>,
        usage: Option<String>,
        attributes: Vec<String>,
    },
    StructDecl {
        name: String,
        level: Option<String>,
        members: Vec<Box<AlephTree>>,
        attributes: Vec<String>,
    },
    TypeDecl {
        name: String,
        definition: Box<AlephTree>,
        attributes: Vec<String>,
    },
    Let {
        var: String,
        is_pointer: String,
        value: Box<AlephTree>,
        expr: Box<AlephTree>,
    },
    LetRec {
        name: String,
        args: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
    },
    Var {
        var: String,
        is_pointer: String,
    },
    TypeRef {
        name: String,
        qualifiers: Vec<String>,
    },
    ArrayType {
        element_type: Box<AlephTree>,
        dimensions: Vec<Box<AlephTree>>,
    },
    PointerType {
        target_type: Box<AlephTree>,
        is_all: bool,
    },
    RangeType {
        start: Box<AlephTree>,
        end: Box<AlephTree>,
    },
    EnumType {
        values: Vec<String>,
    },
    RecordType {
        fields: Vec<Box<AlephTree>>,
    },
    FieldDecl {
        name: String,
        field_type: Box<AlephTree>,
        attributes: Vec<String>,
    },
    SubtypeDecl {
        name: String,
        base_type: Box<AlephTree>,
        constraint: Option<Box<AlephTree>>,
    },
    Get {
        array_name: String,
        elem: Box<AlephTree>,
    },
    Put {
        array_name: String,
        elem: Box<AlephTree>,
        value: Box<AlephTree>,
        insert: String,
    },
    Remove {
        array_name: String,
        elem: Box<AlephTree>,
        is_value: String,
    },
    Length {
        var: String,
    },
    Slice {
        array: Box<AlephTree>,
        start: Option<Box<AlephTree>>,
        end: Option<Box<AlephTree>>,
    },
    Alloc {
        var: Box<AlephTree>,
        target: Option<Box<AlephTree>>,
    },
    Free {
        var: Box<AlephTree>,
    },
    Fetch {
        addr: Box<AlephTree>,
        fetch_type: Option<String>,
    },
    Store {
        value: Box<AlephTree>,
        addr: Box<AlephTree>,
        store_type: Option<String>,
    },
    StoreOp {
        value: Box<AlephTree>,
        addr: Box<AlephTree>,
        op: String,
    },
    App {
        object_name: String,
        fun: Box<AlephTree>,
        param_list: Vec<Box<AlephTree>>,
    },
    Call {
        target: Box<AlephTree>,
        parameters: Option<Vec<Box<AlephTree>>>,
        returning: Option<Box<AlephTree>>,
        on_error: Option<Box<AlephTree>>,
    },
    Stmts {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    Block {
        statements: Vec<Box<AlephTree>>,
    },
    Assignment {
        target: Box<AlephTree>,
        value: Box<AlephTree>,
    },
    Return {
        value: Box<AlephTree>,
    },
    GoTo {
        target: String,
        depending_on: Option<Box<AlephTree>>,
    },
    Label {
        name: String,
        label_type: Option<String>,
    },
    Exit,
    Move {
        source: Box<AlephTree>,
        targets: Vec<Box<AlephTree>>,
    },
    Compute {
        target: Box<AlephTree>,
        expression: Box<AlephTree>,
        on_error: Option<Box<AlephTree>>,
    },
    Print {
        items: Vec<Box<AlephTree>>,
        destination: Option<String>,
        format: Option<Vec<Box<AlephTree>>>,
        options: Vec<String>,
    },
    Input {
        targets: Vec<Box<AlephTree>>,
        source: Option<String>,
        options: Vec<String>,
    },
    FileOpen {
        file: String,
        mode: String,
        attributes: Vec<String>,
    },
    FileClose {
        files: Vec<String>,
    },
    FileRead {
        file_name: String,
        into: Option<Box<AlephTree>>,
        key: Option<Box<AlephTree>>,
        on_end: Option<Box<AlephTree>>,
        not_on_end: Option<Box<AlephTree>>,
    },
    FileWrite {
        record_name: String,
        from: Option<Box<AlephTree>>,
        options: Vec<String>,
    },
    FileConfig {
        file_name: String,
        assign_to: Option<String>,
        access_mode: Option<String>,
        organization_mode: Option<String>,
        record_description: Option<Vec<Box<AlephTree>>>,
        block_contains: Option<String>,
        record_contains: Option<String>,
    },
    StringOp {
        operation: String,
        sources: Vec<Box<AlephTree>>,
        delimiter: Option<Box<AlephTree>>,
        targets: Vec<Box<AlephTree>>,
        pointer: Option<Box<AlephTree>>,
        clauses: Vec<Box<AlephTree>>,
    },
    Iprt {
        name: String,
        items: Vec<String>,
    },
    Export {
        items: Vec<Box<AlephTree>>,
        export_type: Option<String>,
    },
    Module {
        name: String,
        module_type: String,
        id: Option<String>,
        declarations: Vec<Box<AlephTree>>,
        body: Option<Vec<Box<AlephTree>>>,
        initialization: Option<Vec<Box<AlephTree>>>,
    },
    Division {
        division_type: String,
        sections: Vec<Box<AlephTree>>,
    },
    Section {
        name: String,
        section_type: Option<String>,
        content: Vec<Box<AlephTree>>,
    },
    Clss {
        name: String,
        attribute_list: Vec<String>,
        extends: Option<Box<AlephTree>>,
        implements: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
    },
    New {
        constructor: Box<AlephTree>,
        args: Vec<Box<AlephTree>>,
    },
    This,
    Super {
        member: Option<String>,
    },
    Member {
        object: Box<AlephTree>,
        member: String,
        is_optional: bool,
    },
    Spread {
        expr: Box<AlephTree>,
        spread_type: String,
    },
    Destructure {
        pattern: Box<AlephTree>,
        value: Box<AlephTree>,
        destructure_type: String,
    },
    TryCatch {
        try_block: Box<AlephTree>,
        catch_clauses: Vec<Box<AlephTree>>,
        finally_block: Option<Box<AlephTree>>,
    },
    CatchClause {
        exception_types: Vec<String>,
        var: Option<String>,
        body: Box<AlephTree>,
    },
    OnCondition {
        condition: String,
        options: Vec<String>,
        handler: Box<AlephTree>,
    },
    Raise {
        condition: Box<AlephTree>,
    },
    Signal {
        condition: String,
    },
    Revert {
        condition: String,
    },
    ExceptionDecl {
        name: String,
    },
    Comment {
        value: String,
    },
    CommentMulti {
        value: String,
    },
    Assert {
        condition: Box<AlephTree>,
        message: Box<AlephTree>,
    },
    Generic {
        name: String,
        generic_type: String,
        generic_params: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
    },
    GenericParam {
        name: String,
        param_kind: String,
        constraint: Option<Box<AlephTree>>,
        default: Option<Box<AlephTree>>,
    },
    Instantiation {
        name: String,
        generic_name: String,
        actual_params: Vec<Box<AlephTree>>,
    },
    Attribute {
        prefix: Box<AlephTree>,
        attribute: String,
        args: Option<Vec<Box<AlephTree>>>,
    },
    Pragma {
        name: String,
        args: Vec<Box<AlephTree>>,
    },
    RepresentationClause {
        name: String,
        clause_type: String,
        specification: Box<AlephTree>,
    },
    Renaming {
        new_name: String,
        old_name: Box<AlephTree>,
        rename_type: Option<Box<AlephTree>>,
    },
    Execute {
        target: Box<AlephTree>,
        exec_type: Option<String>,
    },
    Perform {
        target: Option<String>,
        from: Option<String>,
        through: Option<String>,
        times: Option<Box<AlephTree>>,
        until: Option<Box<AlephTree>>,
        varying: Option<Box<AlephTree>>,
        inline: Option<Vec<Box<AlephTree>>>,
    },
    StackOp {
        operation: String,
        args: Vec<Box<AlephTree>>,
    },
    TaskType {
        name: String,
        parameters: Option<Vec<Box<AlephTree>>>,
        entries: Vec<Box<AlephTree>>,
        body: Vec<Box<AlephTree>>,
    },
    ProtectedType {
        name: String,
        parameters: Option<Vec<Box<AlephTree>>>,
        declarations: Vec<Box<AlephTree>>,
    },
    ProtectedBody {
        name: String,
        bodies: Vec<Box<AlephTree>>,
    },
    Accept {
        entry_name: String,
        parameters: Option<Vec<Box<AlephTree>>>,
        body: Option<Vec<Box<AlephTree>>>,
    },
    Select {
        alternatives: Vec<Box<AlephTree>>,
        else_clause: Option<Vec<Box<AlephTree>>>,
    },
    SelectiveAccept {
        guard_condition: Option<Box<AlephTree>>,
        accept_stmt: Box<AlephTree>,
        statements: Vec<Box<AlephTree>>,
    },
    Delay {
        delay_type: String,
        expression: Box<AlephTree>,
    },
    Abort {
        targets: Vec<String>,
    },
    Aggregate {
        components: Vec<Box<AlephTree>>,
    },
    ComponentAssoc {
        choices: Option<Vec<Box<AlephTree>>>,
        expression: Box<AlephTree>,
    },
    Qualified {
        type_name: Box<AlephTree>,
        expression: Box<AlephTree>,
    },
    MemoryOp {
        operation: String,
        args: Vec<Box<AlephTree>>,
    },
    DataOp {
        operation: String,
        value: Box<AlephTree>,
    },
    Emit {
        value: Box<AlephTree>,
        emit_type: Option<String>,
    },
    Immediate,
    Recursive,
    Forget {
        target: String,
    },
    Postpone {
        word: String,
    },
    Literal {
        value: Box<AlephTree>,
    },
    CompileTime {
        expression: Box<AlephTree>,
    },
    CreateDoes {
        name: String,
        allot_size: Option<Box<AlephTree>>,
        does_body: Option<Vec<Box<AlephTree>>>,
    },
    Introspect {
        operation: String,
        target: Option<String>,
    },
    Convert {
        value: Box<AlephTree>,
        from_type: String,
        to_type: String,
    },
    Await {
        expr: Box<AlephTree>,
    },
    Async {
        body: Box<AlephTree>,
    },
    Yield {
        value: Option<Box<AlephTree>>,
    },
    Typeof {
        expr: Box<AlephTree>,
    },
    Instanceof {
        expr: Box<AlephTree>,
        type_expr: Box<AlephTree>,
    },
    Nullish {
        expr: Box<AlephTree>,
        default: Box<AlephTree>,
    },
    Optional {
        base: Box<AlephTree>,
        optional_type: String,
    },
    Decorator {
        name: String,
        args: Vec<Box<AlephTree>>,
        target: Box<AlephTree>,
    },
    TableOp {
        operation: String,
        table: Box<AlephTree>,
        index: Option<Box<AlephTree>>,
        value: Option<Box<AlephTree>>,
    },
    Global {
        name: String,
        global_type: Box<AlephTree>,
        mutable: bool,
        initial_value: Option<Box<AlephTree>>,
    },
    Local {
        name: String,
        local_type: Box<AlephTree>,
    },
    Br {
        depth: Box<AlephTree>,
        condition: Option<Box<AlephTree>>,
    },
    Unreachable,
    Nop,
    UnionType {
        variants: Vec<Box<AlephTree>>,
    },
    Trait {
        name: String,
        type_params: Vec<Box<AlephTree>>,
        super_traits: Vec<Box<AlephTree>>,
        items: Vec<Box<AlephTree>>,
    },
    Impl {
        trait_ref: Option<Box<AlephTree>>,
        for_type: Box<AlephTree>,
        items: Vec<Box<AlephTree>>,
    },
    Channel {
        name: String,
        channel_type: Box<AlephTree>,
        capacity: Option<Box<AlephTree>>,
    },
    Send {
        channel: Box<AlephTree>,
        value: Box<AlephTree>,
    },
    Receive {
        channel: Box<AlephTree>,
        timeout: Option<Box<AlephTree>>,
    },
    Spawn {
        target: Box<AlephTree>,
        args: Vec<Box<AlephTree>>,
    },
    Macro {
        name: String,
        parameters: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
        macro_type: Option<String>,
    },
    MacroInvoke {
        name: String,
        args: Vec<Box<AlephTree>>,
    },
    Pipe {
        expr: Box<AlephTree>,
        operations: Vec<Box<AlephTree>>,
    },
    Comprehension {
        comp_type: String,
        expr: Box<AlephTree>,
        clauses: Vec<Box<AlephTree>>,
    },
    CompClause {
        clause_type: String,
        pattern: Option<Box<AlephTree>>,
        iter: Option<Box<AlephTree>>,
        condition: Option<Box<AlephTree>>,
    },
    With {
        resources: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
    },
    Query {
        query_type: String,
        select: Option<Box<AlephTree>>,
        from: Option<Vec<Box<AlephTree>>>,
        where_clause: Option<Box<AlephTree>>,
        joins: Vec<Box<AlephTree>>,
        group_by: Option<Vec<Box<AlephTree>>>,
        having: Option<Box<AlephTree>>,
        order_by: Option<Vec<Box<AlephTree>>>,
        limit: Option<Box<AlephTree>>,
        offset: Option<Box<AlephTree>>,
    },
    Join {
        join_type: String,
        source: Box<AlephTree>,
        condition: Box<AlephTree>,
    },
    Constraint {
        constraint_type: String,
        expressions: Vec<Box<AlephTree>>,
    },
    Clause {
        head: Box<AlephTree>,
        body: Vec<Box<AlephTree>>,
    },
    Unify {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    Lifetime {
        name: String,
        constraint: Option<Box<AlephTree>>,
    },
    Borrow {
        expr: Box<AlephTree>,
        mutable: bool,
        lifetime: Option<String>,
    },
    Unsafe {
        body: Box<AlephTree>,
    },
}