rust/xtask/src/ast_src.rs

//! Defines input for code generation process.

pub(crate) struct KindsSrc<'a> {
    pub(crate) punct: &'a [(&'a str, &'a str)],
    pub(crate) keywords: &'a [&'a str],
    pub(crate) contextual_keywords: &'a [&'a str],
    pub(crate) literals: &'a [&'a str],
    pub(crate) tokens: &'a [&'a str],
    pub(crate) nodes: &'a [&'a str],
}

pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
    punct: &[
        (";", "SEMI"),
        (",", "COMMA"),
        ("(", "L_PAREN"),
        (")", "R_PAREN"),
        ("{", "L_CURLY"),
        ("}", "R_CURLY"),
        ("[", "L_BRACK"),
        ("]", "R_BRACK"),
        ("<", "L_ANGLE"),
        (">", "R_ANGLE"),
        ("@", "AT"),
        ("#", "POUND"),
        ("~", "TILDE"),
        ("?", "QUESTION"),
        ("$", "DOLLAR"),
        ("&", "AMP"),
        ("|", "PIPE"),
        ("+", "PLUS"),
        ("*", "STAR"),
        ("/", "SLASH"),
        ("^", "CARET"),
        ("%", "PERCENT"),
        ("_", "UNDERSCORE"),
        (".", "DOT"),
        ("..", "DOTDOT"),
        ("...", "DOTDOTDOT"),
        ("..=", "DOTDOTEQ"),
        (":", "COLON"),
        ("::", "COLONCOLON"),
        ("=", "EQ"),
        ("==", "EQEQ"),
        ("=>", "FAT_ARROW"),
        ("!", "EXCL"),
        ("!=", "NEQ"),
        ("-", "MINUS"),
        ("->", "THIN_ARROW"),
        ("<=", "LTEQ"),
        (">=", "GTEQ"),
        ("+=", "PLUSEQ"),
        ("-=", "MINUSEQ"),
        ("|=", "PIPEEQ"),
        ("&=", "AMPEQ"),
        ("^=", "CARETEQ"),
        ("/=", "SLASHEQ"),
        ("*=", "STAREQ"),
        ("%=", "PERCENTEQ"),
        ("&&", "AMPAMP"),
        ("||", "PIPEPIPE"),
        ("<<", "SHL"),
        (">>", "SHR"),
        ("<<=", "SHLEQ"),
        (">>=", "SHREQ"),
    ],
    keywords: &[
        "as", "async", "await", "box", "break", "const", "continue", "crate", "dyn", "else",
        "enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "macro",
        "match", "mod", "move", "mut", "pub", "ref", "return", "self", "static", "struct", "super",
        "trait", "true", "try", "type", "unsafe", "use", "where", "while",
    ],
    contextual_keywords: &["auto", "default", "existential", "union", "raw"],
    literals: &[
        "INT_NUMBER",
        "FLOAT_NUMBER",
        "CHAR",
        "BYTE",
        "STRING",
        "RAW_STRING",
        "BYTE_STRING",
        "RAW_BYTE_STRING",
    ],
    tokens: &[
        "ERROR",
        "IDENT",
        "WHITESPACE",
        "LIFETIME",
        "COMMENT",
        "SHEBANG",
        "L_DOLLAR",
        "R_DOLLAR",
    ],
    nodes: &[
        "SOURCE_FILE",
        "STRUCT_DEF",
        "UNION_DEF",
        "ENUM_DEF",
        "FN_DEF",
        "RET_TYPE",
        "EXTERN_CRATE_ITEM",
        "MODULE",
        "USE_ITEM",
        "STATIC_DEF",
        "CONST_DEF",
        "TRAIT_DEF",
        "IMPL_DEF",
        "TYPE_ALIAS_DEF",
        "MACRO_CALL",
        "TOKEN_TREE",
        "MACRO_DEF",
        "PAREN_TYPE",
        "TUPLE_TYPE",
        "NEVER_TYPE",
        "PATH_TYPE",
        "POINTER_TYPE",
        "ARRAY_TYPE",
        "SLICE_TYPE",
        "REFERENCE_TYPE",
        "PLACEHOLDER_TYPE",
        "FN_POINTER_TYPE",
        "FOR_TYPE",
        "IMPL_TRAIT_TYPE",
        "DYN_TRAIT_TYPE",
        "OR_PAT",
        "PAREN_PAT",
        "REF_PAT",
        "BOX_PAT",
        "BIND_PAT",
        "PLACEHOLDER_PAT",
        "DOT_DOT_PAT",
        "PATH_PAT",
        "RECORD_PAT",
        "RECORD_FIELD_PAT_LIST",
        "RECORD_FIELD_PAT",
        "TUPLE_STRUCT_PAT",
        "TUPLE_PAT",
        "SLICE_PAT",
        "RANGE_PAT",
        "LITERAL_PAT",
        "MACRO_PAT",
        // atoms
        "TUPLE_EXPR",
        "ARRAY_EXPR",
        "PAREN_EXPR",
        "PATH_EXPR",
        "LAMBDA_EXPR",
        "IF_EXPR",
        "WHILE_EXPR",
        "CONDITION",
        "LOOP_EXPR",
        "FOR_EXPR",
        "CONTINUE_EXPR",
        "BREAK_EXPR",
        "LABEL",
        "BLOCK_EXPR",
        "RETURN_EXPR",
        "MATCH_EXPR",
        "MATCH_ARM_LIST",
        "MATCH_ARM",
        "MATCH_GUARD",
        "RECORD_LIT",
        "RECORD_FIELD_LIST",
        "RECORD_FIELD",
        "TRY_BLOCK_EXPR",
        "BOX_EXPR",
        // postfix
        "CALL_EXPR",
        "INDEX_EXPR",
        "METHOD_CALL_EXPR",
        "FIELD_EXPR",
        "AWAIT_EXPR",
        "TRY_EXPR",
        "CAST_EXPR",
        // unary
        "REF_EXPR",
        "PREFIX_EXPR",
        "RANGE_EXPR", // just weird
        "BIN_EXPR",
        "BLOCK",
        "EXTERN_BLOCK",
        "EXTERN_ITEM_LIST",
        "ENUM_VARIANT",
        "RECORD_FIELD_DEF_LIST",
        "RECORD_FIELD_DEF",
        "TUPLE_FIELD_DEF_LIST",
        "TUPLE_FIELD_DEF",
        "ENUM_VARIANT_LIST",
        "ITEM_LIST",
        "ATTR",
        "META_ITEM", // not an item actually
        "USE_TREE",
        "USE_TREE_LIST",
        "PATH",
        "PATH_SEGMENT",
        "LITERAL",
        "ALIAS",
        "VISIBILITY",
        "WHERE_CLAUSE",
        "WHERE_PRED",
        "ABI",
        "NAME",
        "NAME_REF",
        "LET_STMT",
        "EXPR_STMT",
        "TYPE_PARAM_LIST",
        "LIFETIME_PARAM",
        "TYPE_PARAM",
        "CONST_PARAM",
        "TYPE_ARG_LIST",
        "LIFETIME_ARG",
        "TYPE_ARG",
        "ASSOC_TYPE_ARG",
        "CONST_ARG",
        "PARAM_LIST",
        "PARAM",
        "SELF_PARAM",
        "ARG_LIST",
        "TYPE_BOUND",
        "TYPE_BOUND_LIST",
        // macro related
        "MACRO_ITEMS",
        "MACRO_STMTS",
    ],
};

pub(crate) struct AstSrc<'a> {
    pub(crate) nodes: &'a [AstNodeSrc<'a>],
    pub(crate) enums: &'a [AstEnumSrc<'a>],
    pub(crate) token_enums: &'a [AstEnumSrc<'a>],
}

pub(crate) struct AstNodeSrc<'a> {
    pub(crate) name: &'a str,
    pub(crate) traits: &'a [&'a str],
    pub(crate) fields: &'a [(&'a str, FieldSrc<'a>)],
}

pub(crate) enum FieldSrc<'a> {
    Shorthand,
    Optional(&'a str),
    Many(&'a str),
}

pub(crate) struct AstEnumSrc<'a> {
    pub(crate) name: &'a str,
    pub(crate) traits: &'a [&'a str],
    pub(crate) variants: &'a [&'a str],
}

macro_rules! ast_nodes {
    ($(
        struct $name:ident$(: $($trait:ident),*)? {
            $($field_name:ident $(: $ty:tt)?),*$(,)?
        }
    )*) => {
        [$(
            AstNodeSrc {
                name: stringify!($name),
                traits: &[$($(stringify!($trait)),*)?],
                fields: &[$(
                    (stringify!($field_name), field_ty!($field_name $($ty)?))
                ),*],

            }
        ),*]
    };
}

macro_rules! field_ty {
    ($field_name:ident) => {
        FieldSrc::Shorthand
    };
    ($field_name:ident [$ty:ident]) => {
        FieldSrc::Many(stringify!($ty))
    };
    ($field_name:ident $ty:ident) => {
        FieldSrc::Optional(stringify!($ty))
    };
}

macro_rules! ast_enums {
    ($(
        enum $name:ident $(: $($trait:ident),*)? {
            $($variant:ident),*$(,)?
        }
    )*) => {
        [$(
            AstEnumSrc {
                name: stringify!($name),
                traits: &[$($(stringify!($trait)),*)?],
                variants: &[$(stringify!($variant)),*],

            }
        ),*]
    };
}

pub(crate) const AST_SRC: AstSrc = AstSrc {
    nodes: &ast_nodes! {
        struct SourceFile: ModuleItemOwner, AttrsOwner {
            modules: [Module],
        }

        struct FnDef: VisibilityOwner, NameOwner, TypeParamsOwner, DocCommentsOwner, AttrsOwner {
            Abi,
            ConstKw,
            DefaultKw,
            AsyncKw,
            UnsafeKw,
            FnKw,
            ParamList,
            RetType,
            body: BlockExpr,
            Semi
        }

        struct RetType { ThinArrow, TypeRef }

        struct StructDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner {
            StructKw,
            FieldDefList,
            Semi
        }

        struct UnionDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner {
            UnionKw,
            RecordFieldDefList,
        }

        struct RecordFieldDefList { LCurly, fields: [RecordFieldDef], RCurly }
        struct RecordFieldDef: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner { }

        struct TupleFieldDefList { LParen, fields: [TupleFieldDef], RParen }
        struct TupleFieldDef: VisibilityOwner, AttrsOwner {
            TypeRef,
        }

        struct EnumDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner {
            EnumKw,
            variant_list: EnumVariantList,
        }
        struct EnumVariantList {
            LCurly,
            variants: [EnumVariant],
            RCurly
        }
        struct EnumVariant: VisibilityOwner, NameOwner, DocCommentsOwner, AttrsOwner {
            FieldDefList,
            Eq,
            Expr
        }

        struct TraitDef: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner, TypeParamsOwner, TypeBoundsOwner {
            UnsafeKw,
            AutoKw,
            TraitKw,
            ItemList,
        }

        struct Module: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner {
            ModKw,
            ItemList,
            Semi
        }

        struct ItemList: ModuleItemOwner {
            LCurly,
            impl_items: [ImplItem],
            RCurly
        }

        struct ConstDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner {
            DefaultKw,
            ConstKw,
            Eq,
            body: Expr,
            Semi
        }

        struct StaticDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner {
            StaticKw,
            MutKw,
            Eq,
            body: Expr,
            Semi
        }

        struct TypeAliasDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeBoundsOwner {
            DefaultKw,
            TypeKw,
            Eq,
            TypeRef,
            Semi
        }

        struct ImplDef: TypeParamsOwner, AttrsOwner {
            DefaultKw,
            ConstKw,
            UnsafeKw,
            ImplKw,
            Excl,
            ForKw,
            ItemList,
        }

        struct ParenType { LParen, TypeRef, RParen }
        struct TupleType { LParen, fields: [TypeRef], RParen }
        struct NeverType { Excl }
        struct PathType { Path }
        struct PointerType { Star, ConstKw, MutKw, TypeRef }
        struct ArrayType { LBrack, TypeRef, Semi, Expr, RBrack }
        struct SliceType { LBrack, TypeRef, RBrack }
        struct ReferenceType { Amp, Lifetime, MutKw, TypeRef }
        struct PlaceholderType { Underscore }
        struct FnPointerType { Abi, UnsafeKw, FnKw, ParamList, RetType }
        struct ForType { ForKw, TypeParamList, TypeRef }
        struct ImplTraitType: TypeBoundsOwner { ImplKw }
        struct DynTraitType: TypeBoundsOwner { DynKw }

        struct TupleExpr: AttrsOwner { LParen, exprs: [Expr], RParen }
        struct ArrayExpr: AttrsOwner { LBrack, exprs: [Expr], Semi, RBrack }
        struct ParenExpr: AttrsOwner { LParen, Expr, RParen }
        struct PathExpr  { Path }
        struct LambdaExpr: AttrsOwner {
            StaticKw,
            AsyncKw,
            MoveKw,
            ParamList,
            RetType,
            body: Expr,
        }
        struct IfExpr: AttrsOwner { IfKw, Condition }
        struct LoopExpr: AttrsOwner, LoopBodyOwner { LoopKw }
        struct TryBlockExpr: AttrsOwner { TryKw, body: BlockExpr }
        struct ForExpr: AttrsOwner, LoopBodyOwner {
            ForKw,
            Pat,
            InKw,
            iterable: Expr,
        }
        struct WhileExpr: AttrsOwner, LoopBodyOwner { WhileKw, Condition }
        struct ContinueExpr: AttrsOwner { ContinueKw, Lifetime }
        struct BreakExpr: AttrsOwner { BreakKw, Lifetime, Expr }
        struct Label { Lifetime }
        struct BlockExpr: AttrsOwner { Label, UnsafeKw, Block  }
        struct ReturnExpr: AttrsOwner { Expr }
        struct CallExpr: ArgListOwner { Expr }
        struct MethodCallExpr: AttrsOwner, ArgListOwner {
            Expr, Dot, NameRef, TypeArgList,
        }
        struct IndexExpr: AttrsOwner { LBrack, RBrack }
        struct FieldExpr: AttrsOwner { Expr, Dot, NameRef }
        struct AwaitExpr: AttrsOwner { Expr, Dot, AwaitKw }
        struct TryExpr: AttrsOwner { TryKw, Expr }
        struct CastExpr: AttrsOwner { Expr, AsKw, TypeRef }
        struct RefExpr: AttrsOwner { Amp, RawKw, MutKw, Expr }
        struct PrefixExpr: AttrsOwner { PrefixOp, Expr }
        struct BoxExpr: AttrsOwner { BoxKw, Expr }
        struct RangeExpr: AttrsOwner { RangeOp }
        struct BinExpr: AttrsOwner { BinOp }
        struct Literal { LiteralToken }

        struct MatchExpr: AttrsOwner { MatchKw, Expr, MatchArmList }
        struct MatchArmList: AttrsOwner { LCurly, arms: [MatchArm], RCurly }
        struct MatchArm: AttrsOwner {
            pat: Pat,
            guard: MatchGuard,
            FatArrow,
            Expr,
        }
        struct MatchGuard { IfKw, Expr }

        struct RecordLit { Path, RecordFieldList}
        struct RecordFieldList {
            LCurly,
            fields: [RecordField],
            Dotdot,
            spread: Expr,
            RCurly
        }
        struct RecordField: AttrsOwner { NameRef, Colon, Expr }

        struct OrPat { pats: [Pat] }
        struct ParenPat { LParen, Pat, RParen }
        struct RefPat { Amp, MutKw, Pat }
        struct BoxPat { BoxKw, Pat }
        struct BindPat: AttrsOwner, NameOwner { RefKw, MutKw, At, Pat }
        struct PlaceholderPat { Underscore }
        struct DotDotPat { Dotdot }
        struct PathPat { Path }
        struct SlicePat { LBrack, args: [Pat], RBrack }
        struct RangePat { RangeSeparator }
        struct LiteralPat { Literal }
        struct MacroPat { MacroCall }

        struct RecordPat { RecordFieldPatList, Path }
        struct RecordFieldPatList {
            LCurly,
            pats: [RecordInnerPat],
            record_field_pats: [RecordFieldPat],
            bind_pats: [BindPat],
            Dotdot,
            RCurly
        }
        struct RecordFieldPat: AttrsOwner, NameOwner { Colon, Pat }

        struct TupleStructPat { Path, LParen, args: [Pat], RParen }
        struct TuplePat { LParen, args: [Pat], RParen }

        struct Visibility { PubKw, SuperKw, SelfKw, CrateKw }
        struct Name { Ident }
        struct NameRef { NameRefToken }

        struct MacroCall: NameOwner, AttrsOwner,DocCommentsOwner {
            Path, Excl, TokenTree, Semi
        }
        struct Attr { Pound, Excl, LBrack, Path, Eq, input: AttrInput, RBrack }
        struct TokenTree {}
        struct TypeParamList {
            LAngle,
            generic_params: [GenericParam],
            type_params: [TypeParam],
            lifetime_params: [LifetimeParam],
            const_params: [ConstParam],
            RAngle
        }
        struct TypeParam: NameOwner, AttrsOwner, TypeBoundsOwner {
            Eq,
            default_type: TypeRef,
        }
        struct ConstParam: NameOwner, AttrsOwner, TypeAscriptionOwner {
            Eq,
            default_val: Expr,
        }
        struct LifetimeParam: AttrsOwner { Lifetime}
        struct TypeBound { Lifetime, /* Question,  */ ConstKw, /* Question,  */ TypeRef}
        struct TypeBoundList { bounds: [TypeBound] }
        struct WherePred: TypeBoundsOwner { Lifetime, TypeRef }
        struct WhereClause { WhereKw, predicates: [WherePred] }
        struct Abi { String }
        struct ExprStmt: AttrsOwner { Expr, Semi }
        struct LetStmt: AttrsOwner, TypeAscriptionOwner {
            LetKw,
            Pat,
            Eq,
            initializer: Expr,
            Semi,
        }
        struct Condition { LetKw, Pat, Eq, Expr }
        struct Block: AttrsOwner, ModuleItemOwner {
            LCurly,
            statements: [Stmt],
            Expr,
            RCurly,
        }
        struct ParamList {
            LParen,
            SelfParam,
            params: [Param],
            RParen
        }
        struct SelfParam: TypeAscriptionOwner, AttrsOwner { Amp, Lifetime, SelfKw }
        struct Param: TypeAscriptionOwner, AttrsOwner {
            Pat,
            Dotdotdot
        }
        struct UseItem: AttrsOwner, VisibilityOwner {
            UseKw,
            UseTree,
        }
        struct UseTree {
            Path, Star, UseTreeList, Alias
        }
        struct Alias: NameOwner { AsKw }
        struct UseTreeList { LCurly, use_trees: [UseTree], RCurly }
        struct ExternCrateItem: AttrsOwner, VisibilityOwner {
            ExternKw, CrateKw, NameRef, Alias,
        }
        struct ArgList {
            LParen,
            args: [Expr],
            RParen
        }
        struct Path {
            segment: PathSegment,
            qualifier: Path,
        }
        struct PathSegment {
            Coloncolon, LAngle, NameRef, TypeArgList, ParamList, RetType, PathType, RAngle
        }
        struct TypeArgList {
            Coloncolon,
            LAngle,
            generic_args: [GenericArg],
            type_args: [TypeArg],
            lifetime_args: [LifetimeArg],
            assoc_type_args: [AssocTypeArg],
            const_args: [ConstArg],
            RAngle
        }
        struct TypeArg { TypeRef }
        struct AssocTypeArg : TypeBoundsOwner { NameRef, Eq, TypeRef }
        struct LifetimeArg { Lifetime }
        struct ConstArg { Literal, Eq, BlockExpr }

        struct MacroItems: ModuleItemOwner{ }

        struct MacroStmts {
            statements: [Stmt],
            Expr,
        }

        struct ExternItemList: ModuleItemOwner {
            LCurly,
            extern_items: [ExternItem],
            RCurly
        }

        struct ExternBlock {
            Abi,
            ExternItemList
        }

        struct MetaItem {
            Path, Eq, AttrInput, nested_meta_items: [MetaItem]
        }

        struct MacroDef {
            Name, TokenTree
        }
    },
    enums: &ast_enums! {
        enum NominalDef: NameOwner, TypeParamsOwner, AttrsOwner {
            StructDef, EnumDef, UnionDef,
        }

        enum GenericParam {
            LifetimeParam,
            TypeParam,
            ConstParam
        }

        enum GenericArg {
            LifetimeArg,
            TypeArg,
            ConstArg,
            AssocTypeArg
        }

        enum TypeRef {
            ParenType,
            TupleType,
            NeverType,
            PathType,
            PointerType,
            ArrayType,
            SliceType,
            ReferenceType,
            PlaceholderType,
            FnPointerType,
            ForType,
            ImplTraitType,
            DynTraitType,
        }

        enum ModuleItem: NameOwner, AttrsOwner, VisibilityOwner {
            StructDef,
            UnionDef,
            EnumDef,
            FnDef,
            TraitDef,
            TypeAliasDef,
            ImplDef,
            UseItem,
            ExternCrateItem,
            ConstDef,
            StaticDef,
            Module,
            MacroCall,
            ExternBlock
        }

        /* impl blocks can also contain MacroCall */
        enum ImplItem: NameOwner, AttrsOwner {
            FnDef, TypeAliasDef, ConstDef
        }

        /* extern blocks can also contain MacroCall */
        enum ExternItem: NameOwner, AttrsOwner, VisibilityOwner {
            FnDef, StaticDef
        }

        enum Expr: AttrsOwner {
            TupleExpr,
            ArrayExpr,
            ParenExpr,
            PathExpr,
            LambdaExpr,
            IfExpr,
            LoopExpr,
            ForExpr,
            WhileExpr,
            ContinueExpr,
            BreakExpr,
            Label,
            BlockExpr,
            ReturnExpr,
            MatchExpr,
            RecordLit,
            CallExpr,
            IndexExpr,
            MethodCallExpr,
            FieldExpr,
            AwaitExpr,
            TryExpr,
            TryBlockExpr,
            CastExpr,
            RefExpr,
            PrefixExpr,
            RangeExpr,
            BinExpr,
            Literal,
            MacroCall,
            BoxExpr,
        }

        enum Pat {
            OrPat,
            ParenPat,
            RefPat,
            BoxPat,
            BindPat,
            PlaceholderPat,
            DotDotPat,
            PathPat,
            RecordPat,
            TupleStructPat,
            TuplePat,
            SlicePat,
            RangePat,
            LiteralPat,
            MacroPat,
        }

        enum RecordInnerPat {
            RecordFieldPat,
            BindPat
        }

        enum AttrInput { Literal, TokenTree }
        enum Stmt {
            LetStmt,
            ExprStmt,
            // macro calls are parsed as expression statements */
        }

        enum FieldDefList {
            RecordFieldDefList,
            TupleFieldDefList,
        }
    },

    token_enums: &ast_enums! {
        enum LeftDelimiter { LParen, LBrack, LCurly }
        enum RightDelimiter { RParen, RBrack, RCurly }
        enum RangeSeparator { Dotdot, Dotdotdot, Dotdoteq}

        enum BinOp {
            Pipepipe,
            Ampamp,
            Eqeq,
            Neq,
            Lteq,
            Gteq,
            LAngle,
            RAngle,
            Plus,
            Star,
            Minus,
            Slash,
            Percent,
            Shl,
            Shr,
            Caret,
            Pipe,
            Amp,
            Eq,
            Pluseq,
            Slasheq,
            Stareq,
            Percenteq,
            Shreq,
            Shleq,
            Minuseq,
            Pipeeq,
            Ampeq,
            Careteq,
        }

        enum PrefixOp {
            Minus,
            Excl,
            Star
        }

        enum RangeOp {
            Dotdot,
            Dotdoteq
        }

        enum LiteralToken {
            IntNumber,
            FloatNumber,
            String,
            RawString,
            // TrueKw,
            // FalseKw,
            ByteString,
            RawByteString,
            Char,
            Byte
        }

        enum NameRefToken {
            Ident,
            IntNumber
        }
    },
};