brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/parser/Statement.d.ts

@@ -1,382 +1,658 @@
-import type { Token, Identifier } from '../lexer';
-import { TokenKind } from '../lexer';
-import type { Expression, NamespacedVariableNameExpression, FunctionExpression, AnnotationExpression } from './Expression';
-import type { Range } from 'vscode-languageserver';
+import type { Token, Identifier } from '../lexer/Token';
+import type { DottedGetExpression, FunctionParameterExpression, TypecastExpression, TypeExpression } from './Expression';
+import { FunctionExpression } from './Expression';
+import { VariableExpression } from './Expression';
+import type { Location } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
 import { ParseMode } from './Parser';
 import type { WalkVisitor, WalkOptions } from '../astUtils/visitors';
-import { InternalWalkMode } from '../astUtils/visitors';
-import type { TranspileResult, TypedefProvider } from '../interfaces';
+import type { GetTypeOptions } from '../interfaces';
+import { type TranspileResult, type TypedefProvider } from '../interfaces';
+import type { BscType } from '../types/BscType';
 import { SymbolTable } from '../SymbolTable';
-/**
- * A BrightScript statement
- */
-export declare abstract class Statement {
-    /**
-     *  The starting and ending location of the statement.
-     **/
-    abstract range: Range;
-    /**
-     * Statement annotations
-     */
-    annotations: AnnotationExpression[];
-    abstract transpile(state: BrsTranspileState): TranspileResult;
-    /**
-     * When being considered by the walk visitor, this describes what type of element the current class is.
-     */
-    visitMode: InternalWalkMode;
-    abstract walk(visitor: WalkVisitor, options: WalkOptions): any;
-}
+import type { Expression } from './AstNode';
+import { AstNodeKind, Statement } from './AstNode';
+import { ClassType } from '../types/ClassType';
+import { NamespaceType } from '../types/NamespaceType';
+import { InterfaceType } from '../types/InterfaceType';
+import { TypedFunctionType } from '../types/TypedFunctionType';
 export declare class EmptyStatement extends Statement {
+    constructor(options?: {
+        range?: Location;
+    });
     /**
      * Create a negative range to indicate this is an interpolated location
      */
-    range: Range;
-    constructor(
-    /**
-     * Create a negative range to indicate this is an interpolated location
-     */
-    range?: Range);
+    readonly location?: Location;
+    readonly kind = AstNodeKind.EmptyStatement;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): EmptyStatement;
 }
 /**
  * This is a top-level statement. Consider this the root of the AST
  */
 export declare class Body extends Statement implements TypedefProvider {
-    statements: Statement[];
-    constructor(statements?: Statement[]);
-    get range(): Range;
+    constructor(options?: {
+        statements?: Statement[];
+    });
+    readonly statements: Statement[];
+    readonly kind = AstNodeKind.Body;
+    readonly symbolTable: SymbolTable;
+    get location(): Location;
+    set location(value: Location);
+    private _location;
     transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): any[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): Body;
 }
 export declare class AssignmentStatement extends Statement {
-    readonly name: Identifier;
-    readonly equals: Token;
+    constructor(options: {
+        name: Identifier;
+        equals?: Token;
+        value: Expression;
+        as?: Token;
+        typeExpression?: TypeExpression;
+    });
+    readonly tokens: {
+        readonly equals?: Token;
+        readonly name: Identifier;
+        readonly as?: Token;
+    };
     readonly value: Expression;
-    readonly containingFunction: FunctionExpression;
-    constructor(name: Identifier, equals: Token, value: Expression, containingFunction: FunctionExpression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
+    readonly typeExpression?: TypeExpression;
+    readonly kind = AstNodeKind.AssignmentStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): AssignmentStatement;
+}
+export declare class AugmentedAssignmentStatement extends Statement {
+    constructor(options: {
+        item: Expression;
+        operator: Token;
+        value: Expression;
+    });
+    readonly tokens: {
+        readonly operator?: Token;
+    };
+    readonly item: Expression;
+    readonly value: Expression;
+    readonly kind = AstNodeKind.AugmentedAssignmentStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): AugmentedAssignmentStatement;
 }
 export declare class Block extends Statement {
+    constructor(options: {
+        statements: Statement[];
+    });
     readonly statements: Statement[];
-    readonly startingRange: Range;
-    constructor(statements: Statement[], startingRange: Range);
-    readonly range: Range;
+    readonly kind = AstNodeKind.Block;
+    private buildLocation;
+    get location(): Location;
+    set location(value: Location);
+    private _location;
     transpile(state: BrsTranspileState): TranspileResult;
+    get leadingTrivia(): Token[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): Block;
 }
 export declare class ExpressionStatement extends Statement {
+    constructor(options: {
+        expression: Expression;
+    });
     readonly expression: Expression;
-    constructor(expression: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
-    walk(visitor: WalkVisitor, options: WalkOptions): void;
-}
-export declare class CommentStatement extends Statement implements Expression, TypedefProvider {
-    comments: Token[];
-    constructor(comments: Token[]);
-    range: Range;
-    get text(): string;
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): any[];
+    readonly kind = AstNodeKind.ExpressionStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ExpressionStatement;
 }
-export declare class ExitForStatement extends Statement {
-    readonly tokens: {
-        exitFor: Token;
-    };
-    constructor(tokens: {
-        exitFor: Token;
+export declare class ExitStatement extends Statement {
+    constructor(options?: {
+        exit?: Token;
+        loopType: Token;
     });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
-    walk(visitor: WalkVisitor, options: WalkOptions): void;
-}
-export declare class ExitWhileStatement extends Statement {
     readonly tokens: {
-        exitWhile: Token;
+        readonly exit: Token;
+        readonly loopType?: Token;
     };
-    constructor(tokens: {
-        exitWhile: Token;
-    });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    readonly kind = AstNodeKind.ExitStatement;
+    readonly location?: Location;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ExitStatement;
 }
 export declare class FunctionStatement extends Statement implements TypedefProvider {
-    name: Identifier;
-    func: FunctionExpression;
-    namespaceName: NamespacedVariableNameExpression;
-    constructor(name: Identifier, func: FunctionExpression, namespaceName: NamespacedVariableNameExpression);
-    readonly range: Range;
+    constructor(options: {
+        name: Identifier;
+        func: FunctionExpression;
+    });
+    readonly tokens: {
+        readonly name: Identifier;
+    };
+    readonly func: FunctionExpression;
+    readonly kind: AstNodeKind;
+    readonly location: Location | undefined;
     /**
      * Get the name of this expression based on the parse mode
      */
     getName(parseMode: ParseMode): string;
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): any[];
+    get leadingTrivia(): Token[];
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): TypedFunctionType;
+    clone(): FunctionStatement;
 }
 export declare class IfStatement extends Statement {
-    readonly tokens: {
-        if: Token;
+    constructor(options: {
+        if?: Token;
         then?: Token;
         else?: Token;
         endIf?: Token;
+        condition: Expression;
+        thenBranch: Block;
+        elseBranch?: IfStatement | Block;
+    });
+    readonly tokens: {
+        readonly if?: Token;
+        readonly then?: Token;
+        readonly else?: Token;
+        readonly endIf?: Token;
     };
     readonly condition: Expression;
     readonly thenBranch: Block;
     readonly elseBranch?: IfStatement | Block;
-    readonly isInline?: boolean;
-    constructor(tokens: {
-        if: Token;
-        then?: Token;
-        else?: Token;
-        endIf?: Token;
-    }, condition: Expression, thenBranch: Block, elseBranch?: IfStatement | Block, isInline?: boolean);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly kind = AstNodeKind.IfStatement;
+    readonly location: Location | undefined;
+    get isInline(): boolean;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): any;
 }
 export declare class IncrementStatement extends Statement {
+    constructor(options: {
+        value: Expression;
+        operator: Token;
+    });
     readonly value: Expression;
-    readonly operator: Token;
-    constructor(value: Expression, operator: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    readonly tokens: {
+        readonly operator: Token;
+    };
+    readonly kind = AstNodeKind.IncrementStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-}
-/** Used to indent the current `print` position to the next 16-character-width output zone. */
-export interface PrintSeparatorTab extends Token {
-    kind: TokenKind.Comma;
-}
-/** Used to insert a single whitespace character at the current `print` position. */
-export interface PrintSeparatorSpace extends Token {
-    kind: TokenKind.Semicolon;
+    get leadingTrivia(): Token[];
+    clone(): IncrementStatement;
 }
 /**
  * Represents a `print` statement within BrightScript.
  */
 export declare class PrintStatement extends Statement {
-    readonly tokens: {
-        print: Token;
-    };
-    readonly expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>;
     /**
      * Creates a new internal representation of a BrightScript `print` statement.
-     * @param expressions an array of expressions or `PrintSeparator`s to be
-     *                    evaluated and printed.
+     * @param options the options for this statement
+     * @param options.print a print token
+     * @param options.expressions an array of expressions to be evaluated and printed. Wrap PrintSeparator tokens (`;` or `,`) in `PrintSeparatorExpression`
      */
-    constructor(tokens: {
-        print: Token;
-    }, expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    constructor(options: {
+        print?: Token;
+        expressions: Array<Expression>;
+    });
+    readonly tokens: {
+        readonly print?: Token;
+    };
+    readonly expressions: Array<Expression>;
+    readonly kind = AstNodeKind.PrintStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): PrintStatement;
 }
 export declare class DimStatement extends Statement {
-    dimToken: Token;
-    identifier?: Identifier;
-    openingSquare?: Token;
-    dimensions?: Expression[];
-    closingSquare?: Token;
-    constructor(dimToken: Token, identifier?: Identifier, openingSquare?: Token, dimensions?: Expression[], closingSquare?: Token);
-    range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    constructor(options: {
+        dim?: Token;
+        name: Identifier;
+        openingSquare?: Token;
+        dimensions: Expression[];
+        closingSquare?: Token;
+    });
+    readonly tokens: {
+        readonly dim?: Token;
+        readonly name: Identifier;
+        readonly openingSquare?: Token;
+        readonly closingSquare?: Token;
+    };
+    readonly dimensions: Expression[];
+    readonly kind = AstNodeKind.DimStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): DimStatement;
 }
 export declare class GotoStatement extends Statement {
-    readonly tokens: {
-        goto: Token;
-        label: Token;
-    };
-    constructor(tokens: {
-        goto: Token;
+    constructor(options: {
+        goto?: Token;
         label: Token;
     });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    readonly tokens: {
+        readonly goto?: Token;
+        readonly label: Token;
+    };
+    readonly kind = AstNodeKind.GotoStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): GotoStatement;
 }
 export declare class LabelStatement extends Statement {
+    constructor(options: {
+        name: Token;
+        colon?: Token;
+    });
     readonly tokens: {
-        identifier: Token;
-        colon: Token;
+        readonly name: Token;
+        readonly colon: Token;
     };
-    constructor(tokens: {
-        identifier: Token;
-        colon: Token;
-    });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    readonly kind = AstNodeKind.LabelStatement;
+    readonly location: Location | undefined;
+    get leadingTrivia(): Token[];
+    transpile(state: BrsTranspileState): TranspileResult[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): LabelStatement;
 }
 export declare class ReturnStatement extends Statement {
+    constructor(options?: {
+        return?: Token;
+        value?: Expression;
+    });
     readonly tokens: {
-        return: Token;
+        readonly return?: Token;
     };
     readonly value?: Expression;
-    constructor(tokens: {
-        return: Token;
-    }, value?: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly kind = AstNodeKind.ReturnStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ReturnStatement;
 }
 export declare class EndStatement extends Statement {
+    constructor(options?: {
+        end?: Token;
+    });
     readonly tokens: {
-        end: Token;
+        readonly end?: Token;
     };
-    constructor(tokens: {
-        end: Token;
-    });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    readonly kind = AstNodeKind.EndStatement;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): TranspileResult[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): EndStatement;
 }
 export declare class StopStatement extends Statement {
+    constructor(options?: {
+        stop?: Token;
+    });
     readonly tokens: {
-        stop: Token;
+        readonly stop?: Token;
     };
-    constructor(tokens: {
-        stop: Token;
-    });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    readonly kind = AstNodeKind.StopStatement;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): TranspileResult[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): StopStatement;
 }
 export declare class ForStatement extends Statement {
-    forToken: Token;
-    counterDeclaration: AssignmentStatement;
-    toToken: Token;
-    finalValue: Expression;
-    body: Block;
-    endForToken: Token;
-    stepToken?: Token;
-    increment?: Expression;
-    constructor(forToken: Token, counterDeclaration: AssignmentStatement, toToken: Token, finalValue: Expression, body: Block, endForToken: Token, stepToken?: Token, increment?: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    constructor(options: {
+        for?: Token;
+        counterDeclaration: AssignmentStatement;
+        to?: Token;
+        finalValue: Expression;
+        body: Block;
+        endFor?: Token;
+        step?: Token;
+        increment?: Expression;
+    });
+    readonly tokens: {
+        readonly for?: Token;
+        readonly to?: Token;
+        readonly endFor?: Token;
+        readonly step?: Token;
+    };
+    readonly counterDeclaration: AssignmentStatement;
+    readonly finalValue: Expression;
+    readonly body: Block;
+    readonly increment?: Expression;
+    readonly kind = AstNodeKind.ForStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): ForStatement;
 }
 export declare class ForEachStatement extends Statement {
-    forEachToken: Token;
-    item: Identifier;
-    inToken: Token;
-    target: Expression;
-    body: Block;
-    endForToken: Token;
-    constructor(forEachToken: Token, item: Identifier, inToken: Token, target: Expression, body: Block, endForToken: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    constructor(options: {
+        forEach?: Token;
+        item: Token;
+        as?: Token;
+        typeExpression?: TypeExpression;
+        in?: Token;
+        target: Expression;
+        body: Block;
+        endFor?: Token;
+    });
+    readonly tokens: {
+        readonly forEach?: Token;
+        readonly item: Token;
+        readonly as: Token;
+        readonly in?: Token;
+        readonly endFor?: Token;
+    };
+    readonly body: Block;
+    readonly target: Expression;
+    readonly typeExpression?: TypeExpression;
+    readonly kind = AstNodeKind.ForEachStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    getLoopVariableType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): ForEachStatement;
 }
 export declare class WhileStatement extends Statement {
+    constructor(options: {
+        while?: Token;
+        endWhile?: Token;
+        condition: Expression;
+        body: Block;
+    });
     readonly tokens: {
-        while: Token;
-        endWhile: Token;
+        readonly while?: Token;
+        readonly endWhile?: Token;
     };
     readonly condition: Expression;
     readonly body: Block;
-    constructor(tokens: {
-        while: Token;
-        endWhile: Token;
-    }, condition: Expression, body: Block);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly kind = AstNodeKind.WhileStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): WhileStatement;
 }
 export declare class DottedSetStatement extends Statement {
+    constructor(options: {
+        obj: Expression;
+        name: Identifier;
+        value: Expression;
+        dot?: Token;
+        equals?: Token;
+    });
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly equals?: Token;
+        readonly dot?: Token;
+    };
     readonly obj: Expression;
-    readonly name: Identifier;
     readonly value: Expression;
-    constructor(obj: Expression, name: Identifier, value: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
+    readonly kind = AstNodeKind.DottedSetStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): DottedSetStatement;
 }
 export declare class IndexedSetStatement extends Statement {
+    constructor(options: {
+        obj: Expression;
+        indexes: Expression[];
+        value: Expression;
+        openingSquare?: Token;
+        closingSquare?: Token;
+        equals?: Token;
+    });
+    readonly tokens: {
+        readonly openingSquare?: Token;
+        readonly closingSquare?: Token;
+        readonly equals?: Token;
+    };
     readonly obj: Expression;
-    readonly index: Expression;
+    readonly indexes: Expression[];
     readonly value: Expression;
-    readonly openingSquare: Token;
-    readonly closingSquare: Token;
-    constructor(obj: Expression, index: Expression, value: Expression, openingSquare: Token, closingSquare: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
+    readonly kind = AstNodeKind.IndexedSetStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): IndexedSetStatement;
 }
 export declare class LibraryStatement extends Statement implements TypedefProvider {
-    readonly tokens: {
-        library: Token;
-        filePath: Token | undefined;
-    };
-    constructor(tokens: {
+    constructor(options: {
         library: Token;
-        filePath: Token | undefined;
+        filePath?: Token;
     });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): any[];
+    readonly tokens: {
+        readonly library: Token;
+        readonly filePath?: Token;
+    };
+    readonly kind = AstNodeKind.LibraryStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): LibraryStatement;
 }
 export declare class NamespaceStatement extends Statement implements TypedefProvider {
-    keyword: Token;
-    nameExpression: NamespacedVariableNameExpression;
-    body: Body;
-    endKeyword: Token;
-    readonly parentSymbolTable?: SymbolTable;
-    readonly symbolTable: SymbolTable;
-    constructor(keyword: Token, nameExpression: NamespacedVariableNameExpression, body: Body, endKeyword: Token, parentSymbolTable?: SymbolTable);
+    constructor(options: {
+        namespace?: Token;
+        nameExpression: VariableExpression | DottedGetExpression;
+        body: Body;
+        endNamespace?: Token;
+    });
+    readonly tokens: {
+        readonly namespace?: Token;
+        readonly endNamespace?: Token;
+    };
+    readonly nameExpression: VariableExpression | DottedGetExpression;
+    readonly body: Body;
+    readonly kind = AstNodeKind.NamespaceStatement;
     /**
      * The string name for this namespace
      */
-    name: string;
-    get range(): Range;
+    get name(): string;
+    get location(): Location;
+    private _location;
+    cacheLocation(): Location;
     getName(parseMode: ParseMode): string;
-    transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): string[];
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    getNameParts(): Identifier[];
+    transpile(state: BrsTranspileState): TranspileResult[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): NamespaceType;
+    clone(): NamespaceStatement;
 }
 export declare class ImportStatement extends Statement implements TypedefProvider {
-    readonly importToken: Token;
-    readonly filePathToken: Token;
-    constructor(importToken: Token, filePathToken: Token);
-    filePath: string;
-    range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    constructor(options: {
+        import?: Token;
+        path?: Token;
+    });
+    readonly tokens: {
+        readonly import?: Token;
+        readonly path: Token;
+    };
+    readonly kind = AstNodeKind.ImportStatement;
+    readonly location: Location;
+    readonly filePath: string;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
     /**
      * Get the typedef for this statement
      */
     getTypedef(state: BrsTranspileState): string[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ImportStatement;
 }
-export declare class ClassStatement extends Statement implements TypedefProvider {
-    readonly classKeyword: Token;
+export declare class InterfaceStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        interface: Token;
+        name: Identifier;
+        extends?: Token;
+        parentInterfaceName?: TypeExpression;
+        body: Statement[];
+        endInterface?: Token;
+    });
+    readonly parentInterfaceName?: TypeExpression;
+    readonly body: Statement[];
+    readonly kind = AstNodeKind.InterfaceStatement;
+    readonly tokens: {
+        readonly interface?: Token;
+        readonly name: Identifier;
+        readonly extends?: Token;
+        readonly endInterface?: Token;
+    };
+    readonly location: Location | undefined;
+    get fields(): InterfaceFieldStatement[];
+    get methods(): InterfaceMethodStatement[];
+    hasParentInterface(): boolean;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
     /**
-     * The name of the class (without namespace prefix)
+     * The name of the interface WITH its leading namespace (if applicable)
      */
-    readonly name: Identifier;
-    body: Statement[];
-    readonly end: Token;
-    readonly extendsKeyword?: Token;
-    readonly parentClassName?: NamespacedVariableNameExpression;
-    readonly namespaceName?: NamespacedVariableNameExpression;
-    constructor(classKeyword: Token, 
+    get fullName(): string;
     /**
-     * The name of the class (without namespace prefix)
+     * The name of the interface (without the namespace prefix)
+     */
+    get name(): string;
+    /**
+     * Get the name of this expression based on the parse mode
      */
-    name: Identifier, body: Statement[], end: Token, extendsKeyword?: Token, parentClassName?: NamespacedVariableNameExpression, namespaceName?: NamespacedVariableNameExpression);
     getName(parseMode: ParseMode): string;
-    memberMap: Record<string, ClassMemberStatement>;
-    methods: ClassMethodStatement[];
-    fields: ClassFieldStatement[];
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): InterfaceType;
+    clone(): InterfaceStatement;
+}
+export declare class InterfaceFieldStatement extends Statement implements TypedefProvider {
+    transpile(state: BrsTranspileState): TranspileResult;
+    constructor(options: {
+        name: Identifier;
+        as?: Token;
+        typeExpression?: TypeExpression;
+        optional?: Token;
+    });
+    readonly kind = AstNodeKind.InterfaceFieldStatement;
+    readonly typeExpression?: TypeExpression;
+    readonly location: Location | undefined;
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly as: Token;
+        readonly optional?: Token;
+    };
+    get leadingTrivia(): Token[];
+    get name(): string;
+    get isOptional(): boolean;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getTypedef(state: BrsTranspileState): TranspileResult;
+    getType(options: GetTypeOptions): BscType;
+    clone(): InterfaceFieldStatement;
+}
+export declare class InterfaceMethodStatement extends Statement implements TypedefProvider {
+    transpile(state: BrsTranspileState): TranspileResult;
+    constructor(options: {
+        functionType?: Token;
+        name: Identifier;
+        leftParen?: Token;
+        params?: FunctionParameterExpression[];
+        rightParen?: Token;
+        as?: Token;
+        returnTypeExpression?: TypeExpression;
+        optional?: Token;
+    });
+    readonly kind = AstNodeKind.InterfaceMethodStatement;
+    get location(): Location;
+    /**
+     * Get the name of this method.
+     */
+    getName(parseMode: ParseMode): string;
+    readonly tokens: {
+        readonly optional?: Token;
+        readonly functionType: Token;
+        readonly name: Identifier;
+        readonly leftParen?: Token;
+        readonly rightParen?: Token;
+        readonly as?: Token;
+    };
+    readonly params: FunctionParameterExpression[];
+    readonly returnTypeExpression?: TypeExpression;
+    get isOptional(): boolean;
+    get leadingTrivia(): Token[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getTypedef(state: BrsTranspileState): TranspileResult;
+    getType(options: GetTypeOptions): TypedFunctionType;
+    clone(): InterfaceMethodStatement;
+}
+export declare class ClassStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        class?: Token;
+        /**
+         * The name of the class (without namespace prefix)
+         */
+        name: Identifier;
+        body: Statement[];
+        endClass?: Token;
+        extends?: Token;
+        parentClassName?: TypeExpression;
+    });
+    readonly kind = AstNodeKind.ClassStatement;
+    readonly tokens: {
+        readonly class?: Token;
+        /**
+         * The name of the class (without namespace prefix)
+         */
+        readonly name: Identifier;
+        readonly endClass?: Token;
+        readonly extends?: Token;
+    };
+    readonly body: Statement[];
+    readonly parentClassName: TypeExpression;
+    getName(parseMode: ParseMode): string;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    readonly memberMap: Record<string, MemberStatement>;
+    readonly methods: MethodStatement[];
+    readonly fields: FieldStatement[];
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     getTypedef(state: BrsTranspileState): TranspileResult;
     /**
      * Find the parent index for this class's parent.
@@ -391,11 +667,18 @@ export declare class ClassStatement extends Statement implements TypedefProvider
      */
     getAncestors(state: BrsTranspileState): ClassStatement[];
     private getBuilderName;
+    private getMethodIdentifier;
+    getConstructorType(): TypedFunctionType;
     /**
      * Get the constructor function for this class (if exists), or undefined if not exist
      */
     private getConstructorFunction;
-    private getEmptyNewFunction;
+    /**
+     * Return the parameters for the first constructor function for this class
+     * @param ancestors The list of ancestors for this class
+     * @returns The parameters for the first constructor function for this class
+     */
+    private getConstructorParams;
     /**
      * Determine if the specified field was declared in one of the ancestor classes
      */
@@ -406,6 +689,15 @@ export declare class ClassStatement extends Statement implements TypedefProvider
      * without instantiating the parent constructor at that point in time.
      */
     private getTranspiledBuilder;
+    /**
+     * Returns a copy of the class' body, with the constructor function added if it doesn't exist.
+     */
+    private getTranspiledClassBody;
+    /**
+     * These are the methods that are defined in this class. They are transpiled outside of the class body
+     * to ensure they don't appear as "$anon_#" in stack traces and crash logs.
+     */
+    private getTranspiledMethods;
     /**
      * The class function is the function with the same name as the class. This is the function that
      * consumers should call to create a new instance of that class.
@@ -413,14 +705,31 @@ export declare class ClassStatement extends Statement implements TypedefProvider
      */
     private getTranspiledClassFunction;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): ClassType;
+    clone(): ClassStatement;
 }
-export declare class ClassMethodStatement extends FunctionStatement {
-    readonly accessModifier: Token;
-    readonly override: Token;
-    constructor(accessModifier: Token, name: Identifier, func: FunctionExpression, override: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): string[];
+export declare class MethodStatement extends FunctionStatement {
+    constructor(options: {
+        modifiers?: Token | Token[];
+        name: Identifier;
+        func: FunctionExpression;
+        override?: Token;
+    });
+    readonly kind: AstNodeKind;
+    readonly modifiers: Token[];
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly override?: Token;
+    };
+    get accessModifier(): Token;
+    readonly location: Location | undefined;
+    /**
+     * Get the name of this method.
+     */
+    getName(parseMode: ParseMode): string;
+    get leadingTrivia(): Token[];
+    transpile(state: BrsTranspileState, name?: Identifier): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     /**
      * All child classes must call the parent constructor. The type checker will warn users when they don't call it in their own class,
      * but we still need to call it even if they have omitted it. This injects the super call if it's missing
@@ -431,43 +740,321 @@ export declare class ClassMethodStatement extends FunctionStatement {
      */
     private injectFieldInitializersForConstructor;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): MethodStatement;
 }
-export declare class ClassFieldStatement extends Statement implements TypedefProvider {
-    readonly accessModifier?: Token;
-    readonly name?: Identifier;
-    readonly as?: Token;
-    readonly type?: Token;
-    readonly equal?: Token;
+export declare class FieldStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        accessModifier?: Token;
+        name: Identifier;
+        as?: Token;
+        typeExpression?: TypeExpression;
+        equals?: Token;
+        initialValue?: Expression;
+        optional?: Token;
+    });
+    readonly tokens: {
+        readonly accessModifier?: Token;
+        readonly name: Identifier;
+        readonly as?: Token;
+        readonly equals?: Token;
+        readonly optional?: Token;
+    };
+    readonly typeExpression?: TypeExpression;
     readonly initialValue?: Expression;
-    constructor(accessModifier?: Token, name?: Identifier, as?: Token, type?: Token, equal?: Token, initialValue?: Expression);
+    readonly kind = AstNodeKind.FieldStatement;
     /**
      * Derive a ValueKind from the type token, or the initial value.
      * Defaults to `DynamicType`
      */
-    getType(): import("../types/ObjectType").ObjectType | import("../types/BooleanType").BooleanType | import("../types/InvalidType").InvalidType | import("../types/StringType").StringType | import("../types/VoidType").VoidType;
-    readonly range: Range;
+    getType(options: GetTypeOptions): BscType;
+    readonly location: Location | undefined;
+    get leadingTrivia(): Token[];
+    get isOptional(): boolean;
     transpile(state: BrsTranspileState): TranspileResult;
     getTypedef(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): FieldStatement;
 }
-export declare type ClassMemberStatement = ClassFieldStatement | ClassMethodStatement;
+export declare type MemberStatement = FieldStatement | MethodStatement;
 export declare class TryCatchStatement extends Statement {
-    tryToken: Token;
-    tryBranch?: Block;
-    catchToken?: Token;
-    exceptionVariable?: Identifier;
-    catchBranch?: Block;
-    endTryToken?: Token;
-    constructor(tryToken: Token, tryBranch?: Block, catchToken?: Token, exceptionVariable?: Identifier, catchBranch?: Block, endTryToken?: Token);
-    get range(): Range;
+    constructor(options?: {
+        try?: Token;
+        endTry?: Token;
+        tryBranch?: Block;
+        catchStatement?: CatchStatement;
+    });
+    readonly tokens: {
+        readonly try?: Token;
+        readonly endTry?: Token;
+    };
+    readonly tryBranch: Block;
+    readonly catchStatement: CatchStatement;
+    readonly kind = AstNodeKind.TryCatchStatement;
+    readonly location: Location | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): TryCatchStatement;
+}
+export declare class CatchStatement extends Statement {
+    constructor(options?: {
+        catch?: Token;
+        exceptionVariableExpression?: Expression;
+        catchBranch?: Block;
+    });
+    readonly tokens: {
+        readonly catch?: Token;
+    };
+    readonly exceptionVariableExpression?: Expression;
+    readonly catchBranch?: Block;
+    readonly kind = AstNodeKind.CatchStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): CatchStatement;
 }
 export declare class ThrowStatement extends Statement {
-    throwToken: Token;
-    expression?: Expression;
-    constructor(throwToken: Token, expression?: Expression);
-    range: Range;
+    constructor(options?: {
+        throw?: Token;
+        expression?: Expression;
+    });
+    readonly tokens: {
+        readonly throw?: Token;
+    };
+    readonly expression?: Expression;
+    readonly kind = AstNodeKind.ThrowStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ThrowStatement;
+}
+export declare class EnumStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        enum?: Token;
+        name: Identifier;
+        endEnum?: Token;
+        body: Array<EnumMemberStatement>;
+    });
+    readonly tokens: {
+        readonly enum?: Token;
+        readonly name: Identifier;
+        readonly endEnum?: Token;
+    };
+    readonly body: Array<EnumMemberStatement>;
+    readonly kind = AstNodeKind.EnumStatement;
+    get location(): Location | undefined;
+    getMembers(): EnumMemberStatement[];
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    /**
+     * Get a map of member names and their values.
+     * All values are stored as their AST LiteralExpression representation (i.e. string enum values include the wrapping quotes)
+     */
+    getMemberValueMap(): Map<string, string>;
+    getMemberValue(name: string): string;
+    /**
+     * The name of the enum (without the namespace prefix)
+     */
+    get name(): string;
+    /**
+     * The name of the enum WITH its leading namespace (if applicable)
+     */
+    get fullName(): string;
+    transpile(state: BrsTranspileState): any;
+    getTypedef(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): any;
+    clone(): EnumStatement;
+}
+export declare class EnumMemberStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        name: Identifier;
+        equals?: Token;
+        value?: Expression;
+    });
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly equals?: Token;
+    };
+    readonly value?: Expression;
+    readonly kind = AstNodeKind.EnumMemberStatement;
+    get location(): Location;
+    /**
+     * The name of the member
+     */
+    get name(): string;
+    get leadingTrivia(): Token[];
+    /**
+     * Get the value of this enum. Requires that `.parent` is set
+     */
+    getValue(): string;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): any;
+    clone(): EnumMemberStatement;
+}
+export declare class ConstStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        const?: Token;
+        name: Identifier;
+        equals?: Token;
+        value: Expression;
+    });
+    readonly tokens: {
+        readonly const: Token;
+        readonly name: Identifier;
+        readonly equals: Token;
+    };
+    readonly value: Expression;
+    readonly kind = AstNodeKind.ConstStatement;
+    readonly location: Location | undefined;
+    get name(): string;
+    get leadingTrivia(): Token[];
+    /**
+     * The name of the statement WITH its leading namespace (if applicable)
+     */
+    get fullName(): string;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    clone(): ConstStatement;
+}
+export declare class ContinueStatement extends Statement {
+    constructor(options: {
+        continue?: Token;
+        loopType: Token;
+    });
+    readonly tokens: {
+        readonly continue?: Token;
+        readonly loopType: Token;
+    };
+    readonly kind = AstNodeKind.ContinueStatement;
+    readonly location: Location | undefined;
     transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ContinueStatement;
+}
+export declare class TypecastStatement extends Statement {
+    constructor(options: {
+        typecast?: Token;
+        typecastExpression: TypecastExpression;
+    });
+    readonly tokens: {
+        readonly typecast?: Token;
+    };
+    readonly typecastExpression: TypecastExpression;
+    readonly kind = AstNodeKind.TypecastStatement;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    getType(options: GetTypeOptions): BscType;
+    clone(): TypecastStatement;
+}
+export declare class ConditionalCompileErrorStatement extends Statement {
+    constructor(options: {
+        hashError?: Token;
+        message: Token;
+    });
+    readonly tokens: {
+        readonly hashError?: Token;
+        readonly message: Token;
+    };
+    readonly kind = AstNodeKind.ConditionalCompileErrorStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ConditionalCompileErrorStatement;
+}
+export declare class AliasStatement extends Statement {
+    constructor(options: {
+        alias?: Token;
+        name: Token;
+        equals?: Token;
+        value: VariableExpression | DottedGetExpression;
+    });
+    readonly tokens: {
+        readonly alias?: Token;
+        readonly name: Token;
+        readonly equals?: Token;
+    };
+    readonly value: Expression;
+    readonly kind = AstNodeKind.AliasStatement;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): (string | TranspileResult)[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    getType(options: GetTypeOptions): BscType;
+    clone(): AliasStatement;
+}
+export declare class ConditionalCompileStatement extends Statement {
+    constructor(options: {
+        hashIf?: Token;
+        not?: Token;
+        condition: Token;
+        hashElse?: Token;
+        hashEndIf?: Token;
+        thenBranch: Block;
+        elseBranch?: ConditionalCompileStatement | Block;
+    });
+    readonly tokens: {
+        readonly hashIf?: Token;
+        readonly not?: Token;
+        readonly condition: Token;
+        readonly hashElse?: Token;
+        readonly hashEndIf?: Token;
+    };
+    readonly thenBranch: Block;
+    readonly elseBranch?: ConditionalCompileStatement | Block;
+    readonly kind = AstNodeKind.ConditionalCompileStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): any;
+    getBranchStatementIndex(stmt: Statement): 1 | -1 | 0;
+}
+export declare class ConditionalCompileConstStatement extends Statement {
+    constructor(options: {
+        hashConst?: Token;
+        assignment: AssignmentStatement;
+    });
+    readonly tokens: {
+        readonly hashConst?: Token;
+    };
+    readonly assignment: AssignmentStatement;
+    readonly kind = AstNodeKind.ConditionalCompileConstStatement;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode | TranspileResult)[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): ConditionalCompileConstStatement;
+}
+export declare class TypeStatement extends Statement {
+    constructor(options: {
+        type?: Token;
+        name: Token;
+        equals?: Token;
+        value: TypeExpression;
+    });
+    readonly tokens: {
+        readonly type?: Token;
+        readonly name: Token;
+        readonly equals?: Token;
+    };
+    readonly value: TypeExpression;
+    readonly kind = AstNodeKind.TypeStatement;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): any[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    getType(options: GetTypeOptions): BscType;
+    clone(): TypeStatement;
 }