🥮 mooncakes.io

    tsparser

    Yet another TypeScript parser.

    parser
    typescript
    ts
    Download zip
    Author
    Version
    0.1.2
    License
    Apache-2.0
    Repository
    Last updated
    7 months ago
    Downloads
    18

    #sennenki/tsparser

    Yet another TypeScript parser.

    Currently ECMA versions and file formats other than .ts and .d.ts are not supported.

    Usage:

    // Construct a Parser instance

    ///|
    let parser = Parser::new(source)
    // Specify file name
    // The second argument of parse_source_file will be used in the output SourceFile struct
    // Usually it's expected to be the same as the argument of Parser::new

    ///|
    let result = parser.parse_source_file("filename.ts", source) catch {
      ParseError(span~, kind~) as e =>
        match kind {
          // Pattern match on the caught error to inspect the exact reason of parsing failure
          UnexpectedToken(token_kind) => ...
          // ...
          // Or just print the error message as ParseError implements Show
          _ => abort(e)
        }
    }

    ParseError

    source
    pub suberror ParseError {
      ParseError(Span, ParseErrorKind)
    }

    impl Eq for ParseError
    impl Show for ParseError

    AccessibilityModifier

    source
    pub enum AccessibilityModifier {
      Public
      Private
      Protected
    }

    Accessibility modifiers (mutually exclusive)

    ArrayBindingElement

    source
    pub enum ArrayBindingElement {
      BindingElement(BindingElement)
      OmittedExpr
    }

    ArrowFunction

    source
    pub struct ArrowFunction {
      is_async : Bool
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
      body : ArrowFunctionBody
    }

    Arrow function (e.g., x => x + 1, (x) => { return x })
    impl Eq for ArrowFunction

    ArrowFunction::new

    source
    fn ArrowFunction::new(is_async : Bool, type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?, body : ArrowFunctionBody) -> ArrowFunction

    ArrowFunctionBody

    source
    pub enum ArrowFunctionBody {
      Expr(Expr)
      Block(Array[Stmt])
    }

    Arrow function body

    AsExpr

    source
    pub struct AsExpr {
      expression : Expr
      type_node : TypeNode
    }

    Type assertion and as expressions
    impl Eq for AsExpr
    impl Show for AsExpr

    AsExpr::new

    source
    fn AsExpr::new(expression : Expr, type_node : TypeNode) -> AsExpr

    BigIntLiteral

    source
    pub struct BigIntLiteral {
      text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
      span : Span
    }

    BigInt literal
    impl Eq for BigIntLiteral

    BigIntLiteral::new

    source
    fn BigIntLiteral::new(text : String, span : Span) -> BigIntLiteral

    BinaryExpr

    source
    pub struct BinaryExpr {
      left : Expr
      operator : BinaryOperator
      right : Expr
    }

    Binary Expr (e.g., a + b, x === y)
    impl Eq for BinaryExpr
    impl Show for BinaryExpr

    BinaryExpr::new

    source
    fn BinaryExpr::new(left : Expr, operator : BinaryOperator, right : Expr) -> BinaryExpr

    BinaryOperator

    source
    pub enum BinaryOperator {
      Equals
      PlusEquals
      MinusEquals
      AsteriskEquals
      AsteriskAsteriskEquals
      SlashEquals
      PercentEquals
      AmpersandEquals
      BarEquals
      CaretEquals
      ShiftLeftEquals
      ShiftRightEquals
      ShiftRightUnsignedEquals
      AmpersandAmpersandEquals
      BarBarEquals
      QuestionQuestionEquals
      Plus
      Minus
      Asterisk
      Slash
      Percent
      AsteriskAsterisk
      ShiftLeft
      ShiftRight
      ShiftRightUnsigned
      LessThan
      GreaterThan
      LessThanEquals
      GreaterThanEquals
      In
      InstanceOf
      EqualsEquals
      ExclamationEquals
      EqualsEqualsEquals
      ExclamationEqualsEquals
      BitwiseAnd
      BitwiseXor
      BitwiseOr
      AmpersandAmpersand
      BarBar
      QuestionQuestion
    }

    Binary operator kinds (simplified - extend as needed)

    BindingElement

    source
    pub struct BindingElement {
      property_name : PropertyName?
      is_rest : Bool
      name : BindingName
      initializer : Expr?
    }

    BindingElement::new

    source
    fn BindingElement::new(name : BindingName, property_name : PropertyName?, is_rest : Bool, initializer : Expr?) -> BindingElement

    BindingName

    source
    pub enum BindingName {
      Identifier(Identifier)
      ObjectBindingPattern(NodeArray[BindingElement])
      ArrayBindingPattern(NodeArray[ArrayBindingElement])
    }

    Binding name - used in destructuring
    impl Eq for BindingName
    impl Show for BindingName

    CallExpr

    source
    pub struct CallExpr {
      expression : Expr
      is_null_coalescing : Bool
      type_arguments : NodeArray[TypeNode]?
      arguments : NodeArray[Expr]
    }

    Call Expr (e.g., func(args))
    impl Eq for CallExpr
    impl Show for CallExpr

    CallExpr::new

    source
    fn CallExpr::new(expression : Expr, type_arguments : NodeArray[TypeNode]?, arguments : NodeArray[Expr], is_null_coalescing : Bool) -> CallExpr

    CallSignatureDecl

    source
    pub struct CallSignatureDecl {
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
    }

    CallSignatureDecl::new

    source
    fn CallSignatureDecl::new(type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?) -> CallSignatureDecl

    CaseBlock

    source
    pub struct CaseBlock {
      clauses : NodeArray[CaseOrDefaultClause]
    }

    impl Eq for CaseBlock
    impl Show for CaseBlock

    CaseBlock::new

    source

    CaseClause

    source
    pub struct CaseClause {
      expression : Expr
      stmts : NodeArray[Stmt]
    }

    impl Eq for CaseClause
    impl Show for CaseClause

    CaseClause::new

    source
    fn CaseClause::new(expression : Expr, stmts : NodeArray[Stmt]) -> CaseClause

    CaseOrDefaultClause

    source
    pub enum CaseOrDefaultClause {
      CaseClause(CaseClause)
      DefaultClause(NodeArray[Stmt])
    }

    CatchClause

    source
    pub struct CatchClause {
      variable_declaration : VariableDecl?
      block : Array[Stmt]
    }

    impl Eq for CatchClause
    impl Show for CatchClause

    CatchClause::new

    source
    fn CatchClause::new(variable_declaration : VariableDecl?, block : Array[Stmt]) -> CatchClause

    ClassDecl

    source
    pub struct ClassDecl {
      doc_comment : String?
      decorators : NodeArray[Expr]?
      modifiers : TopLevelModifiers
      name : Identifier?
      type_parameters : NodeArray[TypeParameterDecl]?
      heritage_clauses : NodeArray[HeritageClause]?
      members : NodeArray[ClassElement]
    }

    Class Decl
    impl Eq for ClassDecl
    impl Show for ClassDecl

    ClassDecl::new

    source
    fn ClassDecl::new(doc_comment : String?, decorators : NodeArray[Expr]?, modifiers : TopLevelModifiers, name : Identifier?, type_parameters : NodeArray[TypeParameterDecl]?, heritage_clauses : NodeArray[HeritageClause]?, members : NodeArray[ClassElement]) -> ClassDecl

    ClassElement

    source
    pub enum ClassElement {
      PropertyDecl(PropertyDecl)
      MethodDecl(MethodDecl)
      Constructor(ConstructorDecl)
      GetAccessor(GetAccessorDecl)
      SetAccessor(SetAccessorDecl)
      IndexSignature(IndexSignatureDecl)
      SemicolonClassElement
      ClassStaticBlockDecl(ClassStaticBlockDecl)
    }

    Class elements
    impl Eq for ClassElement

    ClassExpr

    source
    pub struct ClassExpr {
      name : Identifier?
      type_parameters : NodeArray[TypeParameterDecl]?
      heritage_clauses : NodeArray[HeritageClause]?
      members : NodeArray[ClassElement]
    }

    Class expression (e.g., class Foo {}, class extends Base {})
    impl Eq for ClassExpr
    impl Show for ClassExpr

    ClassExpr::new

    source
    fn ClassExpr::new(name : Identifier?, type_parameters : NodeArray[TypeParameterDecl]?, heritage_clauses : NodeArray[HeritageClause]?, members : NodeArray[ClassElement]) -> ClassExpr

    ClassMemberModifiers

    source
    pub struct ClassMemberModifiers {
      accessibility : AccessibilityModifier?
      is_static : Bool
      is_abstract : Bool
      is_readonly : Bool
      is_override : Bool
      is_accessor : Bool
      is_async : Bool
    }

    Modifiers for class members

    ClassMemberModifiers::new

    source

    ClassStaticBlockDecl

    source
    pub struct ClassStaticBlockDecl {
      body : Array[Stmt]
    }

    ClassStaticBlockDecl::new

    source

    ConditionalExpr

    source
    pub struct ConditionalExpr {
      condition : Expr
      when_true : Expr
      when_false : Expr
    }

    Conditional Expr (e.g., cond ? a : b)

    ConditionalExpr::new

    source
    fn ConditionalExpr::new(condition : Expr, when_true : Expr, when_false : Expr) -> ConditionalExpr

    ConditionalTypeNode

    source
    pub struct ConditionalTypeNode {
      check_type : TypeNode
      extends_type : TypeNode
      true_type : TypeNode
      false_type : TypeNode
    }

    Conditional type (e.g., T extends U ? X : Y)

    ConditionalTypeNode::new

    source
    fn ConditionalTypeNode::new(check_type : TypeNode, extends_type : TypeNode, true_type : TypeNode, false_type : TypeNode) -> ConditionalTypeNode

    ConstructSignatureDecl

    source
    pub struct ConstructSignatureDecl {
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
    }

    ConstructSignatureDecl::new

    source
    fn ConstructSignatureDecl::new(type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?) -> ConstructSignatureDecl

    ConstructorDecl

    source
    pub struct ConstructorDecl {
      doc_comment : String?
      modifiers : ClassMemberModifiers
      parameters : NodeArray[ParameterDecl]
      body : Array[Stmt]?
    }

    ConstructorDecl::new

    source
    fn ConstructorDecl::new(doc_comment : String?, modifiers : ClassMemberModifiers, parameters : NodeArray[ParameterDecl], body : Array[Stmt]?) -> ConstructorDecl

    ConstructorTypeNode

    source
    pub struct ConstructorTypeNode {
      is_abstract : Bool
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
    }

    ConstructorTypeNode::new

    source
    fn ConstructorTypeNode::new(is_abstract : Bool, type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?) -> ConstructorTypeNode

    DoStmt

    source
    pub struct DoStmt {
      statement : Stmt
      expression : Expr
    }

    Do Stmt
    impl Eq for DoStmt
    impl Show for DoStmt

    DoStmt::new

    source
    fn DoStmt::new(statement : Stmt, expression : Expr) -> DoStmt

    ElementAccessExpr

    source
    pub struct ElementAccessExpr {
      expression : Expr
      is_null_coalescing : Bool
      argument_expression : Expr
    }

    Elem access Expr (e.g., obj[index])

    ElementAccessExpr::new

    source
    fn ElementAccessExpr::new(expression : Expr, argument_expression : Expr, is_null_coalescing : Bool) -> ElementAccessExpr

    EntityName

    source
    pub enum EntityName {
      Identifier(Identifier)
      QualifiedName(QualifiedName)
    }

    EntityName - either an Identifier or QualifiedName
    impl Eq for EntityName
    impl Show for EntityName

    EnumDecl

    source
    pub struct EnumDecl {
      doc_comment : String?
      modifiers : TopLevelModifiers
      name : Identifier
      members : NodeArray[EnumMember]
    }

    Enum Decl
    impl Eq for EnumDecl
    impl Show for EnumDecl

    EnumDecl::new

    source
    fn EnumDecl::new(doc_comment : String?, modifiers : TopLevelModifiers, name : Identifier, members : NodeArray[EnumMember]) -> EnumDecl

    EnumMember

    source
    pub struct EnumMember {
      doc_comment : String?
      name : PropertyName
      initializer : Expr?
    }

    impl Eq for EnumMember
    impl Show for EnumMember

    EnumMember::new

    source
    fn EnumMember::new(doc_comment : String?, name : PropertyName, initializer : Expr?) -> EnumMember

    ExportAssignment

    source
    pub struct ExportAssignment {
      modifiers : NodeArray[ModifierKind]?
      is_export_equals : Bool
      expression : Expr
    }

    ExportAssignment::new

    source
    fn ExportAssignment::new(modifiers : NodeArray[ModifierKind]?, is_export_equals : Bool, expression : Expr) -> ExportAssignment

    ExportDecl

    source
    pub struct ExportDecl {
      modifiers : NodeArray[ModifierKind]?
      is_type_only : Bool
      export_clause : NamedExportBindings?
      module_specifier : Expr?
      attributes : ImportAttributes?
    }

    Export Decl
    impl Eq for ExportDecl
    impl Show for ExportDecl

    ExportDecl::new

    source
    fn ExportDecl::new(modifiers : NodeArray[ModifierKind]?, is_type_only : Bool, export_clause : NamedExportBindings?, module_specifier : Expr?, attributes : ImportAttributes?) -> ExportDecl

    ExportSpecifier

    source
    pub struct ExportSpecifier {
      is_type_only : Bool
      property_name : Identifier?
      name : Identifier
    }

    ExportSpecifier::new

    source
    fn ExportSpecifier::new(is_type_only : Bool, property_name : Identifier?, name : Identifier) -> ExportSpecifier

    Expr

    source
    pub struct Expr {
      kind : ExprKind
      span : Span
    }

    Expression AST node
    impl Eq for Expr
    impl Show for Expr

    Expr::new

    source
    fn Expr::new(kind : ExprKind, span : Span) -> Expr

    ExprKind

    source
    pub enum ExprKind {
      Identifier(Identifier)
      NumericLiteral(NumericLiteral)
      StringLiteral(StringLiteral)
      BinaryExpr(BinaryExpr)
      PrefixUnaryExpr(PrefixUnaryExpr)
      PostfixUnaryExpr(PostfixUnaryExpr)
      PropertyAccessExpr(PropertyAccessExpr)
      ElementAccessExpr(ElementAccessExpr)
      CallExpr(CallExpr)
      NewExpr(NewExpr)
      ImportExpr(NodeArray[Expr])
      ArrayLiteralExpr(NodeArray[Expr])
      ObjectLiteralExpr(NodeArray[ObjectLiteralElementLike])
      FunctionExpr(FunctionExpr)
      ArrowFunction(ArrowFunction)
      ConditionalExpr(ConditionalExpr)
      TemplateExpr(TemplateExpr)
      TaggedTemplateExpr(TaggedTemplateExpr)
      AsExpr(AsExpr)
      ParenthesizedExpr(Expr)
      SatisfiesExpr(SatisfiesExpr)
      TypeAssertionExpr(TypeAssertionExpr)
      NonNullExpr(Expr)
      MetaProperty(MetaPropertyKind)
      CommaListExpr(NodeArray[Expr])
      ThisExpr
      SuperExpr
      NullLiteral
      TrueLiteral
      FalseLiteral
      RegularExprLiteral(RegularExprLiteral)
      NoSubstitutionTemplateLiteral(NoSubstitutionTemplateLiteral)
      DeleteExpr(Expr)
      TypeOfExpr(Expr)
      VoidExpr(Expr)
      AwaitExpr(Expr)
      YieldExpr(YieldExpr)
      SpreadElement(Expr)
      OmittedExpr
      ClassExpr(ClassExpr)
    }

    Expression node kinds
    impl Eq for ExprKind
    impl Show for ExprKind

    ExprWithTypeArguments

    source
    pub struct ExprWithTypeArguments {
      expression : Expr
      type_arguments : NodeArray[TypeNode]?
    }

    ExprWithTypeArguments::new

    source
    fn ExprWithTypeArguments::new(expression : Expr, type_arguments : NodeArray[TypeNode]?) -> ExprWithTypeArguments

    ForInStmt

    source
    pub struct ForInStmt {
      initializer : ForInitializer
      expression : Expr
      statement : Stmt
    }

    For-in Stmt
    impl Eq for ForInStmt
    impl Show for ForInStmt

    ForInStmt::new

    source
    fn ForInStmt::new(initializer : ForInitializer, expression : Expr, statement : Stmt) -> ForInStmt

    ForInitializer

    source
    pub enum ForInitializer {
      VariableDeclList(NodeArray[VariableDecl])
      UsingDeclList(NodeArray[UsingDecl], Bool)
      Expr(Expr)
    }

    ForOfStmt

    source
    pub struct ForOfStmt {
      initializer : ForInitializer
      expression : Expr
      statement : Stmt
      is_await : Bool
    }

    For-of Stmt
    impl Eq for ForOfStmt
    impl Show for ForOfStmt

    ForOfStmt::new

    source
    fn ForOfStmt::new(initializer : ForInitializer, expression : Expr, statement : Stmt, is_await : Bool) -> ForOfStmt

    ForStmt

    source
    pub struct ForStmt {
      initializer : ForInitializer?
      condition : Expr?
      incrementor : Expr?
      statement : Stmt
    }

    For Stmt
    impl Eq for ForStmt
    impl Show for ForStmt

    ForStmt::new

    source
    fn ForStmt::new(initializer : ForInitializer?, condition : Expr?, incrementor : Expr?, statement : Stmt) -> ForStmt

    FunctionDecl

    source
    pub struct FunctionDecl {
      doc_comment : String?
      modifiers : TopLevelModifiers
      is_async : Bool
      is_generator : Bool
      name : Identifier?
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
      body : Array[Stmt]?
    }

    Function Decl
    impl Eq for FunctionDecl

    FunctionDecl::new

    source
    fn FunctionDecl::new(doc_comment : String?, modifiers : TopLevelModifiers, is_async : Bool, is_generator : Bool, name : Identifier?, type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?, body : Array[Stmt]?) -> FunctionDecl

    FunctionExpr

    source
    pub struct FunctionExpr {
      is_async : Bool
      is_generator : Bool
      name : Identifier?
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
      body : Array[Stmt]?
    }

    Function expression (e.g., function foo() {}, function*() {})
    impl Eq for FunctionExpr

    FunctionExpr::new

    source
    fn FunctionExpr::new(is_async : Bool, is_generator : Bool, name : Identifier?, type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?, body : Array[Stmt]?) -> FunctionExpr

    FunctionTypeNode

    source
    pub struct FunctionTypeNode {
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
    }

    FunctionTypeNode::new

    source
    fn FunctionTypeNode::new(type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?) -> FunctionTypeNode

    GetAccessorDecl

    source
    pub struct GetAccessorDecl {
      doc_comment : String?
      decorators : NodeArray[Expr]?
      modifiers : ClassMemberModifiers
      name : PropertyName
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
      body : Array[Stmt]?
    }

    GetAccessorDecl::new

    source
    fn GetAccessorDecl::new(doc_comment : String?, decorators : NodeArray[Expr]?, modifiers : ClassMemberModifiers, name : PropertyName, parameters : NodeArray[ParameterDecl], type_node : TypeNode?, body : Array[Stmt]?) -> GetAccessorDecl

    HeritageClause

    source
    pub struct HeritageClause {
      kind : HeritageKind
      types : NodeArray[ExprWithTypeArguments]
    }

    Heritage clause (extends/implements)

    HeritageClause::new

    source

    HeritageKind

    source
    pub enum HeritageKind {
      Extends
      Implements
    }

    Heritage clause kinds
    impl Eq for HeritageKind

    Identifier

    source
    pub struct Identifier {
      text : String
      has_extended_unicode_escape : Bool
      is_in_jsdoc_namespace : Bool
      span : Span
    }

    Identifier node
    impl Eq for Identifier
    impl Show for Identifier

    Identifier::new

    source
    fn Identifier::new(text : String, span : Span) -> Identifier

    IfStmt

    source
    pub struct IfStmt {
      expression : Expr
      then_statement : Stmt
      else_statement : Stmt?
    }

    If Stmt
    impl Eq for IfStmt
    impl Show for IfStmt

    IfStmt::new

    source
    fn IfStmt::new(expression : Expr, then_statement : Stmt, else_statement : Stmt?) -> IfStmt

    ImportAttribute

    source
    pub struct ImportAttribute {
      name : ImportAttributeName
      value : Expr
    }

    ImportAttribute::new

    source

    ImportAttributeName

    source
    pub enum ImportAttributeName {
      Identifier(Identifier)
      StringLiteral(StringLiteral)
    }

    ImportAttributes

    source
    pub struct ImportAttributes {
      elements : NodeArray[ImportAttribute]
    }

    ImportAttributes::new

    source

    ImportClause

    source
    pub struct ImportClause {
      is_type_only : Bool
      name : Identifier?
      named_bindings : NamedImportBindings?
    }

    impl Eq for ImportClause

    ImportClause::new

    source
    fn ImportClause::new(is_type_only : Bool, name : Identifier?, named_bindings : NamedImportBindings?) -> ImportClause

    ImportDecl

    source
    pub struct ImportDecl {
      import_clause : ImportClause?
      module_specifier : Expr
      attributes : ImportAttributes?
      phase : ImportPhase
    }

    impl Eq for ImportDecl
    impl Show for ImportDecl

    ImportDecl::new

    source
    fn ImportDecl::new(import_clause : ImportClause?, module_specifier : Expr, attributes : ImportAttributes?, phase : ImportPhase) -> ImportDecl

    ImportEqualsDecl

    source
    pub struct ImportEqualsDecl {
      is_type_only : Bool
      name : Identifier
      module_ref : ImportEqualsModuleRef
    }

    ImportEqualsDecl::new

    source
    fn ImportEqualsDecl::new(is_type_only : Bool, name : Identifier, module_ref : ImportEqualsModuleRef) -> ImportEqualsDecl

    ImportEqualsModuleRef

    source
    pub enum ImportEqualsModuleRef {
      EntityName(EntityName)
      ExternalModuleRef(Expr)
    }

    ImportPhase

    source
    pub enum ImportPhase {
      Normal
      Type
      Defer
    }

    Import/Export declarations
    impl Eq for ImportPhase
    impl Show for ImportPhase

    ImportSpecifier

    source
    pub struct ImportSpecifier {
      is_type_only : Bool
      property_name : Identifier?
      name : Identifier
    }

    ImportSpecifier::new

    source
    fn ImportSpecifier::new(is_type_only : Bool, property_name : Identifier?, name : Identifier) -> ImportSpecifier

    ImportTypeNode

    source
    pub struct ImportTypeNode {
      argument : Expr
      qualifier : EntityName?
      type_arguments : NodeArray[TypeNode]?
    }

    Import type (e.g., import("x").Foo)

    ImportTypeNode::new

    source
    fn ImportTypeNode::new(argument : Expr, qualifier : EntityName?, type_arguments : NodeArray[TypeNode]?) -> ImportTypeNode

    IndexSignatureDecl

    source
    pub struct IndexSignatureDecl {
      is_readonly : Bool
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode
    }

    IndexSignatureDecl::new

    source
    fn IndexSignatureDecl::new(is_readonly : Bool, parameters : NodeArray[ParameterDecl], type_node : TypeNode) -> IndexSignatureDecl

    IndexedAccessTypeNode

    source
    pub struct IndexedAccessTypeNode {
      object_type : TypeNode
      index_type : TypeNode
    }

    Indexed access type (e.g., T[K])

    IndexedAccessTypeNode::new

    source
    fn IndexedAccessTypeNode::new(object_type : TypeNode, index_type : TypeNode) -> IndexedAccessTypeNode

    InterfaceDecl

    source
    pub struct InterfaceDecl {
      doc_comment : String?
      modifiers : TopLevelModifiers
      name : Identifier
      type_parameters : NodeArray[TypeParameterDecl]?
      heritage_clauses : NodeArray[HeritageClause]?
      members : NodeArray[TypeElement]
    }

    Interface Decl
    impl Eq for InterfaceDecl

    InterfaceDecl::new

    source
    fn InterfaceDecl::new(doc_comment : String?, modifiers : TopLevelModifiers, name : Identifier, type_parameters : NodeArray[TypeParameterDecl]?, heritage_clauses : NodeArray[HeritageClause]?, members : NodeArray[TypeElement]) -> InterfaceDecl

    LabeledStmt

    source
    pub struct LabeledStmt {
      label : Identifier
      statement : Stmt
    }

    Labeled Stmt
    impl Eq for LabeledStmt
    impl Show for LabeledStmt

    LabeledStmt::new

    source
    fn LabeledStmt::new(label : Identifier, statement : Stmt) -> LabeledStmt

    LexKind

    source
    pub enum LexKind {
      Identifier(String)
      PrivateIdentifier(String)
      Number(String)
      String(String)
      Regex(String)
      DocComment(String)
      NoSubTemplate(String, String)
      TemplateHead(String, String)
      TemplateMiddle(String, String)
      TemplateTail(String, String)
      KeywordLet
      KeywordConst
      KeywordVar
      KeywordUsing
      KeywordFunction
      KeywordReturn
      KeywordIf
      KeywordElse
      KeywordWhile
      KeywordFor
      KeywordDo
      KeywordBreak
      KeywordContinue
      KeywordSwitch
      KeywordCase
      KeywordDefault
      KeywordDebugger
      KeywordTry
      KeywordCatch
      KeywordFinally
      KeywordThrow
      KeywordWith
      KeywordNew
      KeywordClass
      KeywordInterface
      KeywordType
      KeywordEnum
      KeywordModule
      KeywordNamespace
      KeywordImport
      KeywordExport
      KeywordAssert
      KeywordGlobal
      KeywordFrom
      KeywordExtends
      KeywordImplements
      KeywordIn
      KeywordInstanceof
      KeywordOf
      KeywordAs
      KeywordSatisfies
      KeywordDelete
      KeywordTypeof
      KeywordVoid
      KeywordAwait
      KeywordYield
      KeywordThis
      KeywordSuper
      KeywordTrue
      KeywordFalse
      KeywordNull
      LParen
      RParen
      LBrace
      RBrace
      LBracket
      RBracket
      Comma
      Dot
      DotDotDot
      Semicolon
      Colon
      Question
      QuestionDot
      Plus
      PlusPlus
      PlusEq
      Minus
      MinusMinus
      MinusEq
      Star
      StarStar
      StarEq
      StarStarEq
      Slash
      SlashEq
      Percent
      PercentEq
      Bang
      Tilde
      Eq
      EqEq
      Arrow
      EqEqEq
      BangEq
      BangEqEq
      Lt
      LtLt
      LtLtEq
      LtSlash
      Gt
      GtGt
      GtGtGt
      GtGtEq
      GtGtGtEq
      LtEq
      GtEq
      Ampersand
      AmpAmp
      AmpersandEq
      AmpAmpEq
      Bar
      BarBar
      BarEq
      BarBarEq
      Caret
      CaretEq
      QuestionQuestion
      QuestionQuestionEq
      At
      Eof
    }

    impl Eq for LexKind

    LexToken

    source
    pub struct LexToken {
      kind : LexKind
      start : Int
      end : Int
      has_leading_line_break : Bool
    }

    impl Show for LexToken

    MappedTypeNode

    source
    pub struct MappedTypeNode {
      is_readonly : Bool
      type_parameter : TypeParameterDecl
      name_type : TypeNode?
      is_optional : Bool
      type_node : TypeNode?
    }

    Mapped type (e.g., { [K in keyof T]?: U })

    MappedTypeNode::new

    source
    fn MappedTypeNode::new(is_readonly : Bool, type_parameter : TypeParameterDecl, name_type : TypeNode?, is_optional : Bool, type_node : TypeNode?) -> MappedTypeNode

    MetaPropertyKind

    source
    pub enum MetaPropertyKind {
      NewTarget
      ImportMeta
    }

    Meta property (e.g., new.target, import.meta)

    MethodDecl

    source
    pub struct MethodDecl {
      doc_comment : String?
      decorators : NodeArray[Expr]?
      modifiers : ClassMemberModifiers
      is_generator : Bool
      name : PropertyName
      is_optional : Bool
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
      body : Array[Stmt]?
    }

    impl Eq for MethodDecl
    impl Show for MethodDecl

    MethodDecl::new

    source
    fn MethodDecl::new(doc_comment : String?, decorators : NodeArray[Expr]?, modifiers : ClassMemberModifiers, is_generator : Bool, name : PropertyName, is_optional : Bool, type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?, body : Array[Stmt]?) -> MethodDecl

    MethodSignature

    source
    pub struct MethodSignature {
      doc_comment : String?
      name : PropertyName
      is_optional : Bool
      type_parameters : NodeArray[TypeParameterDecl]?
      parameters : NodeArray[ParameterDecl]
      type_node : TypeNode?
    }

    MethodSignature::new

    source
    fn MethodSignature::new(doc_comment : String?, name : PropertyName, is_optional : Bool, type_parameters : NodeArray[TypeParameterDecl]?, parameters : NodeArray[ParameterDecl], type_node : TypeNode?) -> MethodSignature

    ModifierKind

    source
    pub enum ModifierKind {
      Abstract
      Accessor
      Async
      Const
      Declare
      Default
      Export
      In
      Public
      Private
      Protected
      Readonly
      Override
      Out
      Static
    }

    Legacy ModifierKind enum (kept for backward compatibility during migration)
    impl Eq for ModifierKind

    ModuleBody

    source
    pub enum ModuleBody {
      ModuleBlock(NodeArray[Stmt])
      ModuleDecl(ModuleDecl)
    }

    impl Eq for ModuleBody
    impl Show for ModuleBody

    ModuleDecl

    source
    pub struct ModuleDecl {
      doc_comment : String?
      modifiers : TopLevelModifiers
      name : ModuleName
      body : ModuleBody?
    }

    Module/Namespace Decl
    impl Eq for ModuleDecl
    impl Show for ModuleDecl

    ModuleDecl::new

    source
    fn ModuleDecl::new(doc_comment : String?, modifiers : TopLevelModifiers, name : ModuleName, body : ModuleBody?) -> ModuleDecl

    ModuleName

    source
    pub enum ModuleName {
      Identifier(Identifier)
      StringLiteral(StringLiteral)
    }

    impl Eq for ModuleName
    impl Show for ModuleName

    NamedExportBindings

    source
    pub enum NamedExportBindings {
      NamespaceExport(Identifier)
      NamedExports(NodeArray[ExportSpecifier])
    }

    NamedImportBindings

    source
    pub enum NamedImportBindings {
      NamespaceImport(Identifier)
      NamedImports(NodeArray[ImportSpecifier])
    }

    NamespaceExportDecl

    source
    pub struct NamespaceExportDecl {
      name : Identifier
    }

    NamespaceExportDecl::new

    source

    NewExpr

    source
    pub struct NewExpr {
      expression : Expr
      type_arguments : NodeArray[TypeNode]?
      arguments : NodeArray[Expr]?
    }

    New Expr (e.g., new Class())
    impl Eq for NewExpr
    impl Show for NewExpr

    NewExpr::new

    source
    fn NewExpr::new(expression : Expr, type_arguments : NodeArray[TypeNode]?, arguments : NodeArray[Expr]?) -> NewExpr

    NoSubstitutionTemplateLiteral

    source
    pub struct NoSubstitutionTemplateLiteral {
      text : String
      raw_text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
    }

    Template literal

    NoSubstitutionTemplateLiteral::new

    source
    fn NoSubstitutionTemplateLiteral::new(text : String, raw_text : String) -> NoSubstitutionTemplateLiteral

    NodeArray

    source
    pub struct NodeArray[T] {
      elements : Array[T]
      start : Span
      end : Span
      has_trailing_comma : Bool
      is_missing_list : Bool
    }

    Node array - a list of nodes with text range information
    impl Eq for NodeArray[T]
    impl Show for NodeArray[T]

    NodeArray::get

    source
    fn[T] NodeArray::get(self : NodeArray[T], index : Int) -> T?

    NodeArray::iter

    source
    fn[T] NodeArray::iter(self : NodeArray[T]) -> Iter[T]

    NodeArray::length

    source
    fn[T] NodeArray::length(self : NodeArray[T]) -> Int

    NumericLiteral

    source
    pub struct NumericLiteral {
      text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
      is_octal_literal : Bool
      span : Span
    }

    Numeric literal

    NumericLiteral::new

    source
    fn NumericLiteral::new(text : String, span : Span) -> NumericLiteral

    ObjectLiteralElementLike

    source
    pub enum ObjectLiteralElementLike {
      PropertyAssignment(PropertyAssignment)
      ShorthandPropertyAssignment(ShorthandPropertyAssignment)
      SpreadAssignment(Expr)
      MethodDecl(MethodDecl)
      GetAccessor(GetAccessorDecl)
      SetAccessor(SetAccessorDecl)
    }

    Object literal Elem types

    ParameterDecl

    source
    pub struct ParameterDecl {
      modifiers : ParameterModifiers
      is_rest : Bool
      name : BindingName
      is_optional : Bool
      type_node : TypeNode?
      initializer : Expr?
      span : Span
    }

    Param Decl
    impl Eq for ParameterDecl

    ParameterDecl::new

    source
    fn ParameterDecl::new(name : BindingName, modifiers : ParameterModifiers, is_rest : Bool, is_optional : Bool, type_node : TypeNode?, initializer : Expr?, span : Span) -> ParameterDecl

    ParameterModifiers

    source
    pub struct ParameterModifiers {
      accessibility : AccessibilityModifier?
      is_readonly : Bool
    }

    Modifiers for constructor parameters (can be property declarations)

    ParameterModifiers::new

    source

    ParseErrorKind

    source
    pub enum ParseErrorKind {
      UnexpectedToken(LexKind)
      UnexpectedPrimary(LexKind)
      ExpectedToken(LexKind, LexKind)
      ExpectedNumericLiteralAfterMinus(LexKind)
      ExpectedStringLiteralInImportType(LexKind)
      ExpectedStringLiteralInModuleSpecifier(LexKind)
      ExpectedTemplateLiteralTypeSpan(LexKind)
      ExpectedTemplateSpan(LexKind)
      InvalidBinaryOperator(LexKind)
      InvalidNamespaceNameStringLiteral(LexKind)
      StringLiteralModuleNameOnlyInDeclare
      InvalidModuleBody
      ModuleBodyRequiredWithoutDeclare
      DecoratorsNotAllowedHere
      LineBreakAfterThrow
      LineBreakAfterTypeKeyword
      ForAwaitMustUseOf(LexKind)
      TopLevelAwaitOnlyInModule
      MissingFunctionBodyOrSemicolon(LexKind)
      LeadingCommaInImportAttributes
      LeadingCommaInNamedImports
      LeadingCommaInNamedExports
      MissingDeclarationAfterModifiers(LexKind)
      DuplicateModifier(ModifierKind)
      InvalidVarianceOrder(ModifierKind, ModifierKind)
      YieldOnlyInGenerator
      RestParameterMustBeLastInParameterList
      RestBindingMustBeLastInPattern
      DeclarationFileStatementNotAllowed
      ExportAssignmentOnlyInDeclarationFile
      ExportAssignmentCannotBeUsedWithOtherExports
      ExportNamespaceOnlyInDeclarationFile
      ExportNamespaceOnlyInModule
      AwaitOnlyInAsyncFunction
      AwaitUsingOnlyInAsyncFunction
      ForAwaitOnlyInAsyncFunction
      ForAwaitOnlyInModule
      AwaitUsingOnlyInModule
      IdentifierAfterNumericLiteral
      NumericSeparatorAtEnd
      InvalidChar(Char)
      UnterminatedString
      InvalidSlice(Int)
      MultipleAccessibilityModifiers
      InvalidModifierForClassMember(ModifierKind)
      InvalidModifierForParameter(ModifierKind)
      InvalidModifierForTopLevel(ModifierKind)
      InvalidModifierForTypeParameter(ModifierKind)
      AbstractAndStaticCannotCombine
      AbstractMembersCannotBePrivate
      AbstractAndAsyncCannotCombine
      AccessorAndAbstractCannotCombine
      AbstractOnlyValidOnClasses
      ConstOnlyValidOnEnums
      InferTypeOnlyInConditionalExtends
    }

    Parser

    source
    pub struct Parser {
      tokens : Array[LexToken]
      index : Int
      line_starts : Array[Int]
      is_module : Bool
      script_kind : ScriptKind
      in_generator : Int
      in_function : Int
      in_async_function : Int
      in_conditional_extends : Int
      has_import_syntax : Bool
      has_export_syntax : Bool
      has_non_namespace_export : Bool
      has_export_assignment : Bool
      export_namespace_range : (Int, Int)?
      top_level_await_range : (Int, Int)?
      for_await_range : (Int, Int)?
      await_using_range : (Int, Int)?
      pending_doc_comment : String?
      allow_doc_comments : Bool
    }

    impl Show for Parser

    Parser::new

    source
    fn Parser::new(text : String, script_kind? : ScriptKind, is_module? : Bool) -> Parser raise ParseError

    Parser::parse_source_file

    source
    fn Parser::parse_source_file(self : Parser, file_name : String, text : String) -> SourceFile raise ParseError

    PostfixUnaryExpr

    source
    pub struct PostfixUnaryExpr {
      operand : Expr
      operator : UnaryOperator
    }

    Postfix unary Expr (e.g., x++, y--)

    PostfixUnaryExpr::new

    source
    fn PostfixUnaryExpr::new(operand : Expr, operator : UnaryOperator) -> PostfixUnaryExpr

    PrefixUnaryExpr

    source
    pub struct PrefixUnaryExpr {
      operator : UnaryOperator
      operand : Expr
    }

    Prefix unary Expr (e.g., ++x, -y, !z)

    PrefixUnaryExpr::new

    source
    fn PrefixUnaryExpr::new(operator : UnaryOperator, operand : Expr) -> PrefixUnaryExpr

    PropertyAccessExpr

    source
    pub struct PropertyAccessExpr {
      expression : Expr
      is_null_coalescing : Bool
      name : Identifier
    }

    Property access Expr (e.g., obj.prop)

    PropertyAccessExpr::new

    source
    fn PropertyAccessExpr::new(expression : Expr, name : Identifier, is_null_coalescing : Bool) -> PropertyAccessExpr

    PropertyAssignment

    source
    pub struct PropertyAssignment {
      name : PropertyName
      initializer : Expr
    }

    Property assignment (e.g., a: expr)

    PropertyAssignment::new

    source
    fn PropertyAssignment::new(name : PropertyName, initializer : Expr) -> PropertyAssignment

    PropertyDecl

    source
    pub struct PropertyDecl {
      doc_comment : String?
      decorators : NodeArray[Expr]?
      modifiers : ClassMemberModifiers
      name : PropertyName
      is_optional : Bool
      is_definite : Bool
      type_node : TypeNode?
      initializer : Expr?
    }

    impl Eq for PropertyDecl

    PropertyDecl::new

    source
    fn PropertyDecl::new(doc_comment : String?, decorators : NodeArray[Expr]?, modifiers : ClassMemberModifiers, name : PropertyName, is_optional : Bool, is_definite : Bool, type_node : TypeNode?, initializer : Expr?) -> PropertyDecl

    PropertyName

    source
    pub enum PropertyName {
      Identifier(Identifier)
      StringLiteral(StringLiteral)
      NumericLiteral(NumericLiteral)
      ComputedPropertyName(Expr)
      PrivateIdentifier(String)
    }

    Property name - can be various types
    impl Eq for PropertyName

    PropertySignature

    source
    pub struct PropertySignature {
      doc_comment : String?
      is_readonly : Bool
      name : PropertyName
      is_optional : Bool
      type_node : TypeNode?
    }

    Type elements for interfaces and type literals

    PropertySignature::new

    source
    fn PropertySignature::new(doc_comment : String?, is_readonly : Bool, name : PropertyName, is_optional : Bool, type_node : TypeNode?) -> PropertySignature

    QualifiedName

    source
    pub struct QualifiedName {
      left : EntityName
      right : Identifier
    }

    Qualified name (e.g., A.B.C)
    impl Eq for QualifiedName

    QualifiedName::new

    source
    fn QualifiedName::new(left : EntityName, right : Identifier) -> QualifiedName

    RegularExprLiteral

    source
    pub struct RegularExprLiteral {
      text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
      span : Span
    }

    Regular Expr literal

    RegularExprLiteral::new

    source
    fn RegularExprLiteral::new(text : String, span : Span) -> RegularExprLiteral

    SatisfiesExpr

    source
    pub struct SatisfiesExpr {
      expression : Expr
      type_node : TypeNode
    }

    Satisfies Expr (e.g., expr satisfies T)
    impl Eq for SatisfiesExpr

    SatisfiesExpr::new

    source
    fn SatisfiesExpr::new(expression : Expr, type_node : TypeNode) -> SatisfiesExpr

    ScriptKind

    source
    pub(all) enum ScriptKind {
      Unknown
      JS
      JSX
      TS
      TSX
      TSDeclarations
      External
      JSON
      Deferred
    }

    Script kind
    impl Eq for ScriptKind
    impl Show for ScriptKind

    ScriptTarget

    source
    pub(all) enum ScriptTarget {
      ES3
      ES5
      ES2015
      ES2016
      ES2017
      ES2018
      ES2019
      ES2020
      ES2021
      ES2022
      ES2023
      ESNext
      Latest
    }

    Script target (ECMAScript version)
    impl Eq for ScriptTarget

    SetAccessorDecl

    source
    pub struct SetAccessorDecl {
      doc_comment : String?
      decorators : NodeArray[Expr]?
      modifiers : ClassMemberModifiers
      name : PropertyName
      parameters : NodeArray[ParameterDecl]
      body : Array[Stmt]?
    }

    SetAccessorDecl::new

    source
    fn SetAccessorDecl::new(doc_comment : String?, decorators : NodeArray[Expr]?, modifiers : ClassMemberModifiers, name : PropertyName, parameters : NodeArray[ParameterDecl], body : Array[Stmt]?) -> SetAccessorDecl

    ShorthandPropertyAssignment

    source
    pub struct ShorthandPropertyAssignment {
      name : Identifier
      object_assignment_initializer : Expr?
    }

    Shorthand property assignment (e.g., {a})

    ShorthandPropertyAssignment::new

    source

    SourceFile

    source
    pub struct SourceFile {
      stmts : NodeArray[Stmt]
      file_name : String
      text : String
      script_kind : ScriptKind
      is_module : Bool
    }

    Source file - the root of the AST
    impl Show for SourceFile

    Span

    source
    pub struct Span {
      start : Int
      end : Int
      line : Int
      column : Int
      end_line : Int
      end_column : Int
    }

    Core AST node types and structures
    impl Eq for Span
    impl Show for Span

    Span::with_line_info

    source
    fn Span::with_line_info(start : Int, end : Int, line : Int, column : Int, end_line : Int, end_column : Int) -> Span

    Stmt

    source
    pub struct Stmt {
      kind : StmtKind
      span : Span
    }

    Statement AST node
    impl Eq for Stmt
    impl Show for Stmt

    Stmt::new

    source
    fn Stmt::new(kind : StmtKind, span : Span) -> Stmt

    StmtKind

    source
    pub enum StmtKind {
      Block(Array[Stmt])
      VariableStmt(VariableStmt)
      UsingStmt(UsingStmt)
      ExprStmt(Expr)
      IfStmt(IfStmt)
      DoStmt(DoStmt)
      WhileStmt(WhileStmt)
      ForStmt(ForStmt)
      ForInStmt(ForInStmt)
      ForOfStmt(ForOfStmt)
      ContinueStmt(Identifier?)
      BreakStmt(Identifier?)
      ReturnStmt(Expr?)
      WithStmt(WithStmt)
      SwitchStmt(SwitchStmt)
      LabeledStmt(LabeledStmt)
      ThrowStmt(Expr)
      TryStmt(TryStmt)
      DebuggerStmt
      FunctionDecl(FunctionDecl)
      ClassDecl(ClassDecl)
      InterfaceDecl(InterfaceDecl)
      TypeAliasDecl(TypeAliasDecl)
      EnumDecl(EnumDecl)
      ModuleDecl(ModuleDecl)
      ImportDecl(ImportDecl)
      ImportEqualsDecl(ImportEqualsDecl)
      ExportDecl(ExportDecl)
      ExportAssignment(ExportAssignment)
      NamespaceExportDecl(NamespaceExportDecl)
      EmptyStmt
    }

    Statement node kinds
    impl Eq for StmtKind
    impl Show for StmtKind

    StringLiteral

    source
    pub struct StringLiteral {
      text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
      is_octal_literal : Bool
      span : Span
    }

    String literal
    impl Eq for StringLiteral

    StringLiteral::new

    source
    fn StringLiteral::new(text : String, span : Span) -> StringLiteral

    SwitchStmt

    source
    pub struct SwitchStmt {
      expression : Expr
      case_block : CaseBlock
    }

    Switch Stmt
    impl Eq for SwitchStmt
    impl Show for SwitchStmt

    SwitchStmt::new

    source
    fn SwitchStmt::new(expression : Expr, case_block : CaseBlock) -> SwitchStmt

    TaggedTemplateExpr

    source
    pub struct TaggedTemplateExpr {
      tag : Expr
      type_arguments : NodeArray[TypeNode]?
      template : Expr
    }

    Tagged template Expr (e.g., tagtext)

    TaggedTemplateExpr::new

    source
    fn TaggedTemplateExpr::new(tag : Expr, type_arguments : NodeArray[TypeNode]?, template : Expr) -> TaggedTemplateExpr

    TemplateExpr

    source
    pub struct TemplateExpr {
      head : TemplateHead
      template_spans : NodeArray[TemplateSpan]
    }

    Template Expr with substitutions
    impl Eq for TemplateExpr

    TemplateExpr::new

    source
    fn TemplateExpr::new(head : TemplateHead, template_spans : NodeArray[TemplateSpan]) -> TemplateExpr

    TemplateHead

    source
    pub struct TemplateHead {
      text : String
      raw_text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
    }

    Template head
    impl Eq for TemplateHead

    TemplateHead::new

    source
    fn TemplateHead::new(text : String, raw_text : String) -> TemplateHead

    TemplateLiteralTypeNode

    source
    pub struct TemplateLiteralTypeNode {
      head : TemplateHead
      template_spans : NodeArray[TemplateLiteralTypeSpan]
    }

    TemplateLiteralTypeNode::new

    source

    TemplateLiteralTypeSpan

    source
    pub struct TemplateLiteralTypeSpan {
      type_node : TypeNode
      literal : TemplateMiddleOrTemplateTail
    }

    TemplateLiteralTypeSpan::new

    source

    TemplateMiddle

    source
    pub struct TemplateMiddle {
      text : String
      raw_text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
    }

    Template middle

    TemplateMiddle::new

    source
    fn TemplateMiddle::new(text : String, raw_text : String) -> TemplateMiddle

    TemplateMiddleOrTemplateTail

    source
    pub enum TemplateMiddleOrTemplateTail {
      TemplateMiddle(TemplateMiddle)
      TemplateTail(TemplateTail)
    }

    TemplateSpan

    source
    pub struct TemplateSpan {
      expression : Expr
      literal : TemplateMiddleOrTemplateTail
    }

    impl Eq for TemplateSpan

    TemplateSpan::new

    source
    fn TemplateSpan::new(expression : Expr, literal : TemplateMiddleOrTemplateTail) -> TemplateSpan

    TemplateTail

    source
    pub struct TemplateTail {
      text : String
      raw_text : String
      is_unterminated : Bool
      has_extended_unicode_escape : Bool
    }

    Template tail
    impl Eq for TemplateTail

    TemplateTail::new

    source
    fn TemplateTail::new(text : String, raw_text : String) -> TemplateTail

    TopLevelModifiers

    source
    pub struct TopLevelModifiers {
      is_export : Bool
      is_default : Bool
      is_declare : Bool
    }

    Modifiers for top-level declarations

    TopLevelModifiers::new

    source

    TryStmt

    source
    pub struct TryStmt {
      try_block : Array[Stmt]
      catch_clause : CatchClause?
      finally_block : Array[Stmt]?
    }

    Try Stmt
    impl Eq for TryStmt
    impl Show for TryStmt

    TryStmt::new

    source
    fn TryStmt::new(try_block : Array[Stmt], catch_clause : CatchClause?, finally_block : Array[Stmt]?) -> TryStmt

    TupleElement

    source
    pub struct TupleElement {
      label : Identifier?
      is_optional : Bool
      is_rest : Bool
      type_node : TypeNode
      span : Span
    }

    impl Eq for TupleElement

    TupleElement::new

    source
    fn TupleElement::new(label : Identifier?, is_optional : Bool, is_rest : Bool, type_node : TypeNode, span : Span) -> TupleElement

    TypeAliasDecl

    source
    pub struct TypeAliasDecl {
      doc_comment : String?
      modifiers : TopLevelModifiers
      name : Identifier
      type_parameters : NodeArray[TypeParameterDecl]?
      type_node : TypeNode
    }

    Type alias Decl
    impl Eq for TypeAliasDecl

    TypeAliasDecl::new

    source
    fn TypeAliasDecl::new(doc_comment : String?, modifiers : TopLevelModifiers, name : Identifier, type_parameters : NodeArray[TypeParameterDecl]?, type_node : TypeNode) -> TypeAliasDecl

    TypeAssertionExpr

    source
    pub struct TypeAssertionExpr {
      type_node : TypeNode
      expression : Expr
    }

    TypeAssertionExpr::new

    source
    fn TypeAssertionExpr::new(type_node : TypeNode, expression : Expr) -> TypeAssertionExpr

    TypeElement

    source
    pub enum TypeElement {
      PropertySignature(PropertySignature)
      MethodSignature(MethodSignature)
      CallSignature(CallSignatureDecl)
      ConstructSignature(ConstructSignatureDecl)
      IndexSignature(IndexSignatureDecl)
      GetAccessor(GetAccessorDecl)
      SetAccessor(SetAccessorDecl)
    }

    TypeElement enum for interface and type literal members
    impl Eq for TypeElement
    impl Show for TypeElement

    TypeKeyword

    source
    pub enum TypeKeyword {
      Any
      Unknown
      Number
      BigInt
      Object
      Boolean
      String
      Symbol
      Void
      Undefined
      Null
      Never
    }

    Type keyword kinds
    impl Eq for TypeKeyword
    impl Show for TypeKeyword

    TypeNode

    source
    pub struct TypeNode {
      kind : TypeNodeKind
      span : Span
    }

    Type AST node
    impl Eq for TypeNode
    impl Show for TypeNode

    TypeNode::new

    source
    fn TypeNode::new(kind : TypeNodeKind, span : Span) -> TypeNode

    TypeNodeKind

    source
    pub enum TypeNodeKind {
      KeywordType(TypeKeyword)
      TypeReference(TypeReferenceNode)
      ArrayType(TypeNode)
      TupleType(NodeArray[TupleElement])
      UnionType(NodeArray[TypeNode])
      IntersectionType(NodeArray[TypeNode])
      FunctionType(FunctionTypeNode)
      ConstructorType(ConstructorTypeNode)
      TypeLiteral(NodeArray[TypeElement])
      LiteralType(Expr)
      ThisType
      ParenthesizedType(TypeNode)
      TypeQuery(TypeQueryNode)
      TypeOperator(TypeOperatorNode)
      IndexedAccessType(IndexedAccessTypeNode)
      ConditionalType(ConditionalTypeNode)
      MappedType(MappedTypeNode)
      InferType(TypeParameterDecl)
      ImportType(ImportTypeNode)
      TemplateLiteralType(TemplateLiteralTypeNode)
    }

    Type node kinds
    impl Eq for TypeNodeKind

    TypeOperatorKind

    source
    pub enum TypeOperatorKind {
      KeyOf
      Readonly
      Unique
    }

    TypeOperatorNode

    source
    pub struct TypeOperatorNode {
      operator : TypeOperatorKind
      type_node : TypeNode
    }

    Type operator (e.g., keyof, readonly, unique)

    TypeOperatorNode::new

    source
    fn TypeOperatorNode::new(operator : TypeOperatorKind, type_node : TypeNode) -> TypeOperatorNode

    TypeParameterDecl

    source
    pub struct TypeParameterDecl {
      modifiers : TypeParameterModifiers
      name : Identifier
      constraint : TypeNode?
      default_type : TypeNode?
    }

    Type Param Decl

    TypeParameterDecl::new

    source
    fn TypeParameterDecl::new(name : Identifier, modifiers : TypeParameterModifiers, constraint : TypeNode?, default_type : TypeNode?) -> TypeParameterDecl

    TypeParameterModifiers

    source
    pub struct TypeParameterModifiers {
      variance : VarianceModifier?
      is_const : Bool
    }

    Modifiers for type parameters

    TypeParameterModifiers::new

    source

    TypeQueryExprName

    source
    pub enum TypeQueryExprName {
      EntityName(EntityName)
      ImportType(ImportTypeNode)
    }

    TypeQueryNode

    source
    pub struct TypeQueryNode {
      expr_name : TypeQueryExprName
      type_arguments : NodeArray[TypeNode]?
    }

    Type query (typeof)
    impl Eq for TypeQueryNode

    TypeQueryNode::new

    source
    fn TypeQueryNode::new(expr_name : TypeQueryExprName, type_arguments : NodeArray[TypeNode]?) -> TypeQueryNode

    TypeReferenceNode

    source
    pub struct TypeReferenceNode {
      type_name : EntityName
      type_arguments : NodeArray[TypeNode]?
    }

    TypeReferenceNode::new

    source
    fn TypeReferenceNode::new(type_name : EntityName, type_arguments : NodeArray[TypeNode]?) -> TypeReferenceNode

    UnaryOperator

    source
    pub enum UnaryOperator {
      PlusPlus
      MinusMinus
      Plus
      Minus
      Tilde
      Exclamation
    }

    Unary operator kinds
    impl Eq for UnaryOperator

    UsingDecl

    source
    pub struct UsingDecl {
      name : Identifier
      type_node : TypeNode?
      initializer : Expr?
    }

    Using Decl (e.g., using x = foo())
    impl Eq for UsingDecl
    impl Show for UsingDecl

    UsingDecl::new

    source
    fn UsingDecl::new(name : Identifier, type_node : TypeNode?, initializer : Expr?) -> UsingDecl

    UsingStmt

    source
    pub struct UsingStmt {
      modifiers : NodeArray[ModifierKind]?
      declaration_list : NodeArray[UsingDecl]
      is_await : Bool
    }

    impl Eq for UsingStmt
    impl Show for UsingStmt

    UsingStmt::new

    source
    fn UsingStmt::new(modifiers : NodeArray[ModifierKind]?, declaration_list : NodeArray[UsingDecl], is_await : Bool) -> UsingStmt

    VariableDecl

    source
    pub struct VariableDecl {
      kind : VariableDeclKind
      name : BindingName
      type_node : TypeNode?
      initializer : Expr?
    }

    Variable Decl (e.g., const x = 1)
    impl Eq for VariableDecl

    VariableDecl::new

    source
    fn VariableDecl::new(kind : VariableDeclKind, name : BindingName, type_node : TypeNode?, initializer : Expr?) -> VariableDecl

    VariableDeclKind

    source
    pub enum VariableDeclKind {
      Let
      Const
      Var
    }

    VariableStmt

    source
    pub struct VariableStmt {
      doc_comment : String?
      modifiers : NodeArray[ModifierKind]?
      declaration_list : NodeArray[VariableDecl]
    }

    impl Eq for VariableStmt

    VariableStmt::new

    source
    fn VariableStmt::new(doc_comment : String?, modifiers : NodeArray[ModifierKind]?, declaration_list : NodeArray[VariableDecl]) -> VariableStmt

    VarianceModifier

    source
    pub enum VarianceModifier {
      In
      Out
      InOut
    }

    Variance modifiers for type parameters (mutually exclusive)

    WhileStmt

    source
    pub struct WhileStmt {
      expression : Expr
      statement : Stmt
    }

    While Stmt
    impl Eq for WhileStmt
    impl Show for WhileStmt

    WhileStmt::new

    source
    fn WhileStmt::new(expression : Expr, statement : Stmt) -> WhileStmt

    WithStmt

    source
    pub struct WithStmt {
      expression : Expr
      statement : Stmt
    }

    With Stmt
    impl Eq for WithStmt
    impl Show for WithStmt

    WithStmt::new

    source
    fn WithStmt::new(expression : Expr, statement : Stmt) -> WithStmt

    YieldExpr

    source
    pub struct YieldExpr {
      is_delegate : Bool
      expression : Expr?
    }

    Yield Expr
    impl Eq for YieldExpr
    impl Show for YieldExpr

    YieldExpr::new

    source
    fn YieldExpr::new(is_delegate : Bool, expression : Expr?) -> YieldExpr

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io