brighterscript 1.0.0-alpha.25 → 1.0.0-alpha.26

package/dist/parser/Statement.d.ts

@@ -20,15 +20,13 @@ import { InterfaceType } from '../types/InterfaceType';
 import type { BscType } from '../types/BscType';
 import { TypedFunctionType } from '../types/TypedFunctionType';
 export declare class EmptyStatement extends Statement {
+    constructor(options?: {
+        range?: Range;
+    });
     /**
      * 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 kind = AstNodeKind.EmptyStatement;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -37,8 +35,10 @@ export declare class EmptyStatement extends Statement {
  * This is a top-level statement. Consider this the root of the AST
  */
 export declare class Body extends Statement implements TypedefProvider {
+    constructor(options?: {
+        statements?: Statement[];
+    });
     statements: Statement[];
-    constructor(statements?: Statement[]);
     readonly kind = AstNodeKind.Body;
     symbolTable: SymbolTable;
     get range(): Range;
@@ -47,12 +47,20 @@ export declare class Body extends Statement implements TypedefProvider {
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class AssignmentStatement extends Statement {
-    equals: Token;
-    name: Identifier;
+    constructor(options: {
+        name: Identifier;
+        equals?: Token;
+        value: Expression;
+        as?: Token;
+        typeExpression?: TypeExpression;
+    });
+    tokens: {
+        equals?: Token;
+        name: Identifier;
+        as?: Token;
+    };
     value: Expression;
-    asToken?: Token;
-    typeExpression?: TypeExpression;
-    constructor(equals: Token, name: Identifier, value: Expression, asToken?: Token, typeExpression?: TypeExpression);
+    typeExpression: TypeExpression;
     readonly kind = AstNodeKind.AssignmentStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
@@ -60,25 +68,34 @@ export declare class AssignmentStatement extends Statement {
     getType(options: GetTypeOptions): BscType;
 }
 export declare class Block extends Statement {
+    constructor(options: {
+        statements: Statement[];
+        startingRange: Range;
+    });
     readonly statements: Statement[];
     readonly startingRange: Range;
-    constructor(statements: Statement[], startingRange: Range);
     readonly kind = AstNodeKind.Block;
     readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ExpressionStatement extends Statement {
+    constructor(options: {
+        expression: Expression;
+    });
     readonly expression: Expression;
-    constructor(expression: Expression);
     readonly kind = AstNodeKind.ExpressionStatement;
     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[]);
+    constructor(options: {
+        comments: Token[];
+    });
+    tokens: {
+        comments: Token[];
+    };
     readonly kind = AstNodeKind.CommentStatement;
     range: Range;
     get text(): string;
@@ -87,33 +104,38 @@ export declare class CommentStatement extends Statement implements Expression, T
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ExitForStatement extends Statement {
+    constructor(options?: {
+        exitFor?: Token;
+    });
     readonly tokens: {
-        exitFor: Token;
+        exitFor?: Token;
     };
-    constructor(tokens: {
-        exitFor: Token;
-    });
     readonly kind = AstNodeKind.ExitForStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): SourceNode[];
+    transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ExitWhileStatement extends Statement {
+    constructor(options?: {
+        exitWhile?: Token;
+    });
     readonly tokens: {
-        exitWhile: Token;
+        exitWhile?: Token;
     };
-    constructor(tokens: {
-        exitWhile: Token;
-    });
     readonly kind = AstNodeKind.ExitWhileStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): SourceNode[];
+    transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class FunctionStatement extends Statement implements TypedefProvider {
-    name: Identifier;
+    constructor(options: {
+        name: Identifier;
+        func: FunctionExpression;
+    });
+    tokens: {
+        name: Identifier;
+    };
     func: FunctionExpression;
-    constructor(name: Identifier, func: FunctionExpression);
     readonly kind: AstNodeKind;
     readonly range: Range;
     /**
@@ -127,8 +149,18 @@ export declare class FunctionStatement extends Statement implements TypedefProvi
     getType(options: GetTypeOptions): TypedFunctionType;
 }
 export declare class IfStatement extends Statement {
+    constructor(options: {
+        if?: Token;
+        then?: Token;
+        else?: Token;
+        endIf?: Token;
+        condition: Expression;
+        thenBranch: Block;
+        elseBranch?: IfStatement | Block;
+        isInline?: boolean;
+    });
     readonly tokens: {
-        if: Token;
+        if?: Token;
         then?: Token;
         else?: Token;
         endIf?: Token;
@@ -137,21 +169,20 @@ export declare class IfStatement extends Statement {
     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 kind = AstNodeKind.IfStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class IncrementStatement extends Statement {
+    constructor(options: {
+        value: Expression;
+        operator: Token;
+    });
     readonly value: Expression;
-    readonly operator: Token;
-    constructor(value: Expression, operator: Token);
+    readonly tokens: {
+        operator: Token;
+    };
     readonly kind = AstNodeKind.IncrementStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
@@ -169,59 +200,69 @@ export interface PrintSeparatorSpace extends Token {
  * 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 tokens the tokens for this statement
-     * @param tokens.print a print token
-     * @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 or `PrintSeparator`s to be evaluated and printed.
      */
-    constructor(tokens: {
+    constructor(options: {
+        print: Token;
+        expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>;
+    });
+    readonly tokens: {
         print: Token;
-    }, expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>);
+    };
+    readonly expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>;
     readonly kind = AstNodeKind.PrintStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 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);
+    constructor(options: {
+        dim?: Token;
+        name: Identifier;
+        openingSquare?: Token;
+        dimensions: Expression[];
+        closingSquare?: Token;
+    });
+    readonly tokens: {
+        dim?: Token;
+        name: Identifier;
+        openingSquare?: Token;
+        closingSquare?: Token;
+    };
+    dimensions: Expression[];
     readonly kind = AstNodeKind.DimStatement;
     range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
 }
 export declare class GotoStatement extends Statement {
+    constructor(options: {
+        goto?: Token;
+        label: Token;
+    });
     readonly tokens: {
-        goto: Token;
+        goto?: Token;
         label: Token;
     };
-    constructor(tokens: {
-        goto: Token;
-        label: Token;
-    });
     readonly kind = AstNodeKind.GotoStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class LabelStatement extends Statement {
+    constructor(options: {
+        name: Token;
+        colon?: Token;
+    });
     readonly tokens: {
-        identifier: Token;
+        name: Token;
         colon: Token;
     };
-    constructor(tokens: {
-        identifier: Token;
-        colon: Token;
-    });
     readonly kind = AstNodeKind.LabelStatement;
     readonly range: Range;
     getLeadingTrivia(): Token[];
@@ -229,98 +270,122 @@ export declare class LabelStatement extends Statement {
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ReturnStatement extends Statement {
+    constructor(options?: {
+        return?: Token;
+        value?: Expression;
+    });
     readonly tokens: {
         return: Token;
     };
     readonly value?: Expression;
-    constructor(tokens: {
-        return: Token;
-    }, value?: Expression);
     readonly kind = AstNodeKind.ReturnStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class EndStatement extends Statement {
+    constructor(options?: {
+        end?: Token;
+    });
     readonly tokens: {
-        end: Token;
+        end?: Token;
     };
-    constructor(tokens: {
-        end: Token;
-    });
     readonly kind = AstNodeKind.EndStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class StopStatement extends Statement {
+    constructor(options?: {
+        stop?: Token;
+    });
     readonly tokens: {
-        stop: Token;
+        stop?: Token;
     };
-    constructor(tokens: {
-        stop: Token;
-    });
     readonly kind = AstNodeKind.StopStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ForStatement extends Statement {
-    forToken: Token;
+    constructor(options: {
+        for?: Token;
+        counterDeclaration: AssignmentStatement;
+        to?: Token;
+        finalValue: Expression;
+        body: Block;
+        endFor?: Token;
+        step?: Token;
+        increment?: Expression;
+    });
+    readonly tokens: {
+        for?: Token;
+        to?: Token;
+        endFor?: Token;
+        step?: 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 kind = AstNodeKind.ForStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ForEachStatement extends Statement {
+    constructor(options: {
+        forEach?: Token;
+        item: Token;
+        in?: Token;
+        target: Expression;
+        body: Block;
+        endFor?: Token;
+    });
     readonly tokens: {
-        forEach: Token;
-        in: Token;
-        endFor: Token;
+        forEach?: Token;
+        item: Token;
+        in?: Token;
+        endFor?: Token;
     };
-    readonly item: Token;
-    readonly target: Expression;
     readonly body: Block;
-    constructor(tokens: {
-        forEach: Token;
-        in: Token;
-        endFor: Token;
-    }, item: Token, target: Expression, body: Block);
+    readonly target: Expression;
     readonly kind = AstNodeKind.ForEachStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class WhileStatement extends Statement {
+    constructor(options: {
+        while?: Token;
+        endWhile?: Token;
+        condition: Expression;
+        body: Block;
+    });
     readonly tokens: {
-        while: Token;
-        endWhile: Token;
+        while?: Token;
+        endWhile?: Token;
     };
     readonly condition: Expression;
     readonly body: Block;
-    constructor(tokens: {
-        while: Token;
-        endWhile: Token;
-    }, condition: Expression, body: Block);
     readonly kind = AstNodeKind.WhileStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class DottedSetStatement extends Statement {
+    constructor(options: {
+        obj: Expression;
+        name: Identifier;
+        value: Expression;
+        dot?: Token;
+    });
+    readonly tokens: {
+        name: Identifier;
+        dot?: Token;
+    };
     readonly obj: Expression;
-    readonly name: Identifier;
     readonly value: Expression;
-    readonly dot?: Token;
-    constructor(obj: Expression, name: Identifier, value: Expression, dot?: Token);
     readonly kind = AstNodeKind.DottedSetStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
@@ -328,26 +393,34 @@ export declare class DottedSetStatement extends Statement {
     getType(options: GetTypeOptions): BscType;
 }
 export declare class IndexedSetStatement extends Statement {
+    constructor(options: {
+        obj: Expression;
+        indexes: Expression[];
+        value: Expression;
+        openingSquare?: Token;
+        closingSquare?: Token;
+    });
+    readonly tokens: {
+        openingSquare?: Token;
+        closingSquare?: 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 kind = AstNodeKind.IndexedSetStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
+    transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class LibraryStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        library: Token;
+        filePath?: Token;
+    });
     readonly tokens: {
         library: Token;
-        filePath: Token | undefined;
+        filePath?: Token;
     };
-    constructor(tokens: {
-        library: Token;
-        filePath: Token | undefined;
-    });
     readonly kind = AstNodeKind.LibraryStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
@@ -355,11 +428,18 @@ export declare class LibraryStatement extends Statement implements TypedefProvid
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class NamespaceStatement extends Statement implements TypedefProvider {
-    keyword: Token;
-    nameExpression: VariableExpression | DottedGetExpression;
+    constructor(options: {
+        namespace?: Token;
+        nameExpression: VariableExpression | DottedGetExpression;
+        body: Body;
+        endNamespace?: Token;
+    });
+    readonly tokens: {
+        namespace?: Token;
+        endNamespace?: Token;
+    };
+    readonly nameExpression: VariableExpression | DottedGetExpression;
     body: Body;
-    endKeyword: Token;
-    constructor(keyword: Token, nameExpression: VariableExpression | DottedGetExpression, body: Body, endKeyword: Token);
     readonly kind = AstNodeKind.NamespaceStatement;
     /**
      * The string name for this namespace
@@ -377,9 +457,14 @@ export declare class NamespaceStatement extends Statement implements TypedefProv
     getType(options: GetTypeOptions): NamespaceType;
 }
 export declare class ImportStatement extends Statement implements TypedefProvider {
-    readonly importToken: Token;
-    readonly filePathToken: Token;
-    constructor(importToken: Token, filePathToken: Token);
+    constructor(options: {
+        import?: Token;
+        filePath: Token;
+    });
+    readonly tokens: {
+        import?: Token;
+        filePath: Token;
+    };
     readonly kind = AstNodeKind.ImportStatement;
     range: Range;
     filePath: string;
@@ -391,15 +476,22 @@ export declare class ImportStatement extends Statement implements TypedefProvide
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class InterfaceStatement extends Statement implements TypedefProvider {
-    parentInterfaceName: TypeExpression;
+    constructor(options: {
+        interface: Token;
+        name: Identifier;
+        extends?: Token;
+        parentInterfaceName?: TypeExpression;
+        body: Statement[];
+        endInterface?: Token;
+    });
+    parentInterfaceName?: TypeExpression;
     body: Statement[];
-    constructor(interfaceToken: Token, name: Identifier, extendsToken: Token, parentInterfaceName: TypeExpression, body: Statement[], endInterfaceToken: Token);
     readonly kind = AstNodeKind.InterfaceStatement;
     tokens: {
-        interface: Token;
+        interface?: Token;
         name: Identifier;
-        extends: Token;
-        endInterface: Token;
+        extends?: Token;
+        endInterface?: Token;
     };
     range: Range;
     get fields(): InterfaceFieldStatement[];
@@ -424,10 +516,15 @@ export declare class InterfaceStatement extends Statement implements TypedefProv
     getType(options: GetTypeOptions): InterfaceType;
 }
 export declare class InterfaceFieldStatement extends Statement implements TypedefProvider {
-    typeExpression?: TypeExpression;
     transpile(state: BrsTranspileState): TranspileResult;
-    constructor(nameToken: Identifier, asToken: Token, typeExpression?: TypeExpression, optionalToken?: Token);
+    constructor(options: {
+        name: Identifier;
+        as?: Token;
+        typeExpression?: TypeExpression;
+        optional?: Token;
+    });
     readonly kind = AstNodeKind.InterfaceFieldStatement;
+    typeExpression?: TypeExpression;
     range: Range;
     tokens: {
         name: Identifier;
@@ -442,10 +539,17 @@ export declare class InterfaceFieldStatement extends Statement implements Typede
     getType(options: GetTypeOptions): BscType;
 }
 export declare class InterfaceMethodStatement extends Statement implements TypedefProvider {
-    params: FunctionParameterExpression[];
-    returnTypeExpression?: TypeExpression;
     transpile(state: BrsTranspileState): TranspileResult;
-    constructor(functionTypeToken: Token, nameToken: Identifier, leftParen: Token, params: FunctionParameterExpression[], rightParen: Token, asToken?: Token, returnTypeExpression?: TypeExpression, optionalToken?: Token);
+    constructor(options: {
+        functionType?: Token;
+        name: Identifier;
+        leftParen?: Token;
+        params?: FunctionParameterExpression[];
+        rightParen?: Token;
+        as?: Token;
+        returnTypeExpression?: TypeExpression;
+        optional?: Token;
+    });
     readonly kind = AstNodeKind.InterfaceMethodStatement;
     get range(): Range;
     /**
@@ -456,10 +560,12 @@ export declare class InterfaceMethodStatement extends Statement implements Typed
         optional?: Token;
         functionType: Token;
         name: Identifier;
-        leftParen: Token;
-        rightParen: Token;
-        as: Token;
+        leftParen?: Token;
+        rightParen?: Token;
+        as?: Token;
     };
+    params: FunctionParameterExpression[];
+    returnTypeExpression?: TypeExpression;
     get isOptional(): boolean;
     getLeadingTrivia(): Token[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -467,21 +573,29 @@ export declare class InterfaceMethodStatement extends Statement implements Typed
     getType(options: GetTypeOptions): TypedFunctionType;
 }
 export declare class ClassStatement extends Statement implements TypedefProvider {
-    readonly classKeyword: Token;
-    /**
-     * The name of the class (without namespace prefix)
-     */
-    readonly name: Identifier;
-    body: Statement[];
-    readonly end: Token;
-    readonly extendsKeyword?: Token;
-    readonly parentClassName?: TypeExpression;
-    constructor(classKeyword: Token, 
-    /**
-     * The name of the class (without namespace prefix)
-     */
-    name: Identifier, body: Statement[], end: Token, extendsKeyword?: Token, parentClassName?: TypeExpression);
+    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;
+    tokens: {
+        class?: Token;
+        /**
+         * The name of the class (without namespace prefix)
+         */
+        name: Identifier;
+        endClass?: Token;
+        extends?: Token;
+    };
+    readonly body: Statement[];
+    readonly parentClassName: TypeExpression;
     getName(parseMode: ParseMode): string;
     getLeadingTrivia(): Token[];
     memberMap: Record<string, MemberStatement>;
@@ -528,10 +642,18 @@ export declare class ClassStatement extends Statement implements TypedefProvider
     getType(options: GetTypeOptions): ClassType;
 }
 export declare class MethodStatement extends FunctionStatement {
-    override: Token;
-    constructor(modifiers: Token | Token[], name: Identifier, func: FunctionExpression, override: Token);
+    constructor(options: {
+        modifiers?: Token | Token[];
+        name: Identifier;
+        func: FunctionExpression;
+        override?: Token;
+    });
     readonly kind: AstNodeKind;
     modifiers: Token[];
+    readonly tokens: {
+        name: Identifier;
+        override?: Token;
+    };
     get accessModifier(): Token;
     readonly range: Range;
     /**
@@ -553,14 +675,24 @@ export declare class MethodStatement extends FunctionStatement {
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class FieldStatement extends Statement implements TypedefProvider {
-    readonly accessModifier?: Token;
-    readonly name?: Identifier;
-    readonly as?: Token;
-    readonly typeExpression?: TypeExpression;
-    readonly equal?: Token;
-    readonly initialValue?: Expression;
-    readonly optional?: Token;
-    constructor(accessModifier?: Token, name?: Identifier, as?: Token, typeExpression?: TypeExpression, equal?: Token, initialValue?: Expression, optional?: Token);
+    constructor(options: {
+        accessModifier?: Token;
+        name: Identifier;
+        as?: Token;
+        typeExpression?: TypeExpression;
+        equals?: Token;
+        initialValue?: Expression;
+        optional?: Token;
+    });
+    readonly tokens: {
+        accessModifier?: Token;
+        name: Identifier;
+        as?: Token;
+        equals?: Token;
+        optional?: Token;
+    };
+    typeExpression?: TypeExpression;
+    initialValue?: Expression;
     readonly kind = AstNodeKind.FieldStatement;
     /**
      * Derive a ValueKind from the type token, or the initial value.
@@ -576,56 +708,66 @@ export declare class FieldStatement extends Statement implements TypedefProvider
 }
 export declare type MemberStatement = FieldStatement | MethodStatement;
 export declare class TryCatchStatement extends Statement {
-    tokens: {
-        try: Token;
+    constructor(options?: {
+        try?: Token;
         endTry?: Token;
-    };
-    tryBranch?: Block;
-    catchStatement?: CatchStatement;
-    constructor(tokens: {
-        try: Token;
+        tryBranch?: Block;
+        catchStatement?: CatchStatement;
+    });
+    readonly tokens: {
+        try?: Token;
         endTry?: Token;
-    }, tryBranch?: Block, catchStatement?: CatchStatement);
+    };
+    tryBranch: Block;
+    catchStatement: CatchStatement;
     readonly kind = AstNodeKind.TryCatchStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class CatchStatement extends Statement {
-    tokens: {
-        catch: Token;
+    constructor(options?: {
+        catch?: Token;
+        exceptionVariable?: Identifier;
+        catchBranch?: Block;
+    });
+    readonly tokens: {
+        catch?: Token;
+        exceptionVariable?: Identifier;
     };
-    exceptionVariable?: Identifier;
     catchBranch?: Block;
-    constructor(tokens: {
-        catch: Token;
-    }, exceptionVariable?: Identifier, catchBranch?: Block);
     readonly kind = AstNodeKind.CatchStatement;
     range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ThrowStatement extends Statement {
-    throwToken: Token;
+    constructor(options?: {
+        throw?: Token;
+        expression?: Expression;
+    });
+    readonly tokens: {
+        throw?: Token;
+    };
     expression?: Expression;
-    constructor(throwToken: Token, expression?: Expression);
     readonly kind = AstNodeKind.ThrowStatement;
     range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class EnumStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        enum?: Token;
+        name: Identifier;
+        endEnum?: Token;
+        body: Array<EnumMemberStatement | CommentStatement>;
+    });
     tokens: {
-        enum: Token;
+        enum?: Token;
         name: Identifier;
-        endEnum: Token;
+        endEnum?: Token;
     };
     body: Array<EnumMemberStatement | CommentStatement>;
-    constructor(tokens: {
-        enum: Token;
-        name: Identifier;
-        endEnum: Token;
-    }, body: Array<EnumMemberStatement | CommentStatement>);
     readonly kind = AstNodeKind.EnumStatement;
     symbolTable: SymbolTable;
     get range(): Range;
@@ -651,15 +793,16 @@ export declare class EnumStatement extends Statement implements TypedefProvider
     getType(options: GetTypeOptions): EnumType;
 }
 export declare class EnumMemberStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        name: Identifier;
+        equals?: Token;
+        value?: Expression;
+    });
     tokens: {
         name: Identifier;
-        equal?: Token;
+        equals?: Token;
     };
     value?: Expression;
-    constructor(tokens: {
-        name: Identifier;
-        equal?: Token;
-    }, value?: Expression);
     readonly kind = AstNodeKind.EnumMemberStatement;
     get range(): Range;
     /**
@@ -673,17 +816,18 @@ export declare class EnumMemberStatement extends Statement implements TypedefPro
     getType(options: GetTypeOptions): EnumMemberType;
 }
 export declare class ConstStatement extends Statement implements TypedefProvider {
+    constructor(options: {
+        const?: Token;
+        name: Identifier;
+        equals?: Token;
+        value: Expression;
+    });
     tokens: {
         const: Token;
         name: Identifier;
         equals: Token;
     };
     value: Expression;
-    constructor(tokens: {
-        const: Token;
-        name: Identifier;
-        equals: Token;
-    }, value: Expression);
     readonly kind = AstNodeKind.ConstStatement;
     range: Range;
     get name(): string;
@@ -698,14 +842,14 @@ export declare class ConstStatement extends Statement implements TypedefProvider
     getType(options: GetTypeOptions): BscType;
 }
 export declare class ContinueStatement extends Statement {
+    constructor(options: {
+        continue?: Token;
+        loopType: Token;
+    });
     tokens: {
-        continue: Token;
+        continue?: Token;
         loopType: Token;
     };
-    constructor(tokens: {
-        continue: Token;
-        loopType: Token;
-    });
     readonly kind = AstNodeKind.ContinueStatement;
     range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];