brighterscript 1.0.0-alpha.26 → 1.0.0-alpha.27

package/dist/parser/Statement.d.ts

@@ -6,7 +6,7 @@ import type { Range } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
 import { ParseMode } from './Parser';
 import type { WalkVisitor, WalkOptions } from '../astUtils/visitors';
-import { type GetTypeOptions, type TranspileResult, type TypedefProvider } from '../interfaces';
+import type { GetTypeOptions, TranspileResult, TypedefProvider } from '../interfaces';
 import type { SourceNode } from 'source-map';
 import type { TranspileState } from './TranspileState';
 import { SymbolTable } from '../SymbolTable';
@@ -26,7 +26,7 @@ export declare class EmptyStatement extends Statement {
     /**
      * Create a negative range to indicate this is an interpolated location
      */
-    range: Range;
+    readonly range: Range;
     readonly kind = AstNodeKind.EmptyStatement;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -38,9 +38,9 @@ export declare class Body extends Statement implements TypedefProvider {
     constructor(options?: {
         statements?: Statement[];
     });
-    statements: Statement[];
+    readonly statements: Statement[];
     readonly kind = AstNodeKind.Body;
-    symbolTable: SymbolTable;
+    readonly symbolTable: SymbolTable;
     get range(): Range;
     transpile(state: BrsTranspileState): TranspileResult;
     getTypedef(state: BrsTranspileState): any[];
@@ -54,13 +54,13 @@ export declare class AssignmentStatement extends Statement {
         as?: Token;
         typeExpression?: TypeExpression;
     });
-    tokens: {
-        equals?: Token;
-        name: Identifier;
-        as?: Token;
+    readonly tokens: {
+        readonly equals?: Token;
+        readonly name: Identifier;
+        readonly as?: Token;
     };
-    value: Expression;
-    typeExpression: TypeExpression;
+    readonly value: Expression;
+    readonly typeExpression: TypeExpression;
     readonly kind = AstNodeKind.AssignmentStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
@@ -93,11 +93,11 @@ export declare class CommentStatement extends Statement implements Expression, T
     constructor(options: {
         comments: Token[];
     });
-    tokens: {
-        comments: Token[];
+    readonly tokens: {
+        readonly comments: Token[];
     };
     readonly kind = AstNodeKind.CommentStatement;
-    range: Range;
+    readonly range: Range;
     get text(): string;
     transpile(state: BrsTranspileState): any[];
     getTypedef(state: TranspileState): any[];
@@ -108,7 +108,7 @@ export declare class ExitForStatement extends Statement {
         exitFor?: Token;
     });
     readonly tokens: {
-        exitFor?: Token;
+        readonly exitFor?: Token;
     };
     readonly kind = AstNodeKind.ExitForStatement;
     readonly range: Range;
@@ -120,7 +120,7 @@ export declare class ExitWhileStatement extends Statement {
         exitWhile?: Token;
     });
     readonly tokens: {
-        exitWhile?: Token;
+        readonly exitWhile?: Token;
     };
     readonly kind = AstNodeKind.ExitWhileStatement;
     readonly range: Range;
@@ -132,10 +132,10 @@ export declare class FunctionStatement extends Statement implements TypedefProvi
         name: Identifier;
         func: FunctionExpression;
     });
-    tokens: {
-        name: Identifier;
+    readonly tokens: {
+        readonly name: Identifier;
     };
-    func: FunctionExpression;
+    readonly func: FunctionExpression;
     readonly kind: AstNodeKind;
     readonly range: Range;
     /**
@@ -160,10 +160,10 @@ export declare class IfStatement extends Statement {
         isInline?: boolean;
     });
     readonly tokens: {
-        if?: Token;
-        then?: Token;
-        else?: Token;
-        endIf?: Token;
+        readonly if?: Token;
+        readonly then?: Token;
+        readonly else?: Token;
+        readonly endIf?: Token;
     };
     readonly condition: Expression;
     readonly thenBranch: Block;
@@ -181,7 +181,7 @@ export declare class IncrementStatement extends Statement {
     });
     readonly value: Expression;
     readonly tokens: {
-        operator: Token;
+        readonly operator: Token;
     };
     readonly kind = AstNodeKind.IncrementStatement;
     readonly range: Range;
@@ -211,7 +211,7 @@ export declare class PrintStatement extends Statement {
         expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>;
     });
     readonly tokens: {
-        print: Token;
+        readonly print: Token;
     };
     readonly expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>;
     readonly kind = AstNodeKind.PrintStatement;
@@ -228,14 +228,14 @@ export declare class DimStatement extends Statement {
         closingSquare?: Token;
     });
     readonly tokens: {
-        dim?: Token;
-        name: Identifier;
-        openingSquare?: Token;
-        closingSquare?: Token;
+        readonly dim?: Token;
+        readonly name: Identifier;
+        readonly openingSquare?: Token;
+        readonly closingSquare?: Token;
     };
-    dimensions: Expression[];
+    readonly dimensions: Expression[];
     readonly kind = AstNodeKind.DimStatement;
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
@@ -246,8 +246,8 @@ export declare class GotoStatement extends Statement {
         label: Token;
     });
     readonly tokens: {
-        goto?: Token;
-        label: Token;
+        readonly goto?: Token;
+        readonly label: Token;
     };
     readonly kind = AstNodeKind.GotoStatement;
     readonly range: Range;
@@ -260,8 +260,8 @@ export declare class LabelStatement extends Statement {
         colon?: Token;
     });
     readonly tokens: {
-        name: Token;
-        colon: Token;
+        readonly name: Token;
+        readonly colon: Token;
     };
     readonly kind = AstNodeKind.LabelStatement;
     readonly range: Range;
@@ -275,7 +275,7 @@ export declare class ReturnStatement extends Statement {
         value?: Expression;
     });
     readonly tokens: {
-        return: Token;
+        readonly return?: Token;
     };
     readonly value?: Expression;
     readonly kind = AstNodeKind.ReturnStatement;
@@ -288,7 +288,7 @@ export declare class EndStatement extends Statement {
         end?: Token;
     });
     readonly tokens: {
-        end?: Token;
+        readonly end?: Token;
     };
     readonly kind = AstNodeKind.EndStatement;
     readonly range: Range;
@@ -300,7 +300,7 @@ export declare class StopStatement extends Statement {
         stop?: Token;
     });
     readonly tokens: {
-        stop?: Token;
+        readonly stop?: Token;
     };
     readonly kind = AstNodeKind.StopStatement;
     readonly range: Range;
@@ -319,15 +319,15 @@ export declare class ForStatement extends Statement {
         increment?: Expression;
     });
     readonly tokens: {
-        for?: Token;
-        to?: Token;
-        endFor?: Token;
-        step?: Token;
+        readonly for?: Token;
+        readonly to?: Token;
+        readonly endFor?: Token;
+        readonly step?: Token;
     };
-    counterDeclaration: AssignmentStatement;
-    finalValue: Expression;
-    body: Block;
-    increment?: Expression;
+    readonly counterDeclaration: AssignmentStatement;
+    readonly finalValue: Expression;
+    readonly body: Block;
+    readonly increment?: Expression;
     readonly kind = AstNodeKind.ForStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
@@ -343,10 +343,10 @@ export declare class ForEachStatement extends Statement {
         endFor?: Token;
     });
     readonly tokens: {
-        forEach?: Token;
-        item: Token;
-        in?: Token;
-        endFor?: Token;
+        readonly forEach?: Token;
+        readonly item: Token;
+        readonly in?: Token;
+        readonly endFor?: Token;
     };
     readonly body: Block;
     readonly target: Expression;
@@ -363,8 +363,8 @@ export declare class WhileStatement extends Statement {
         body: Block;
     });
     readonly tokens: {
-        while?: Token;
-        endWhile?: Token;
+        readonly while?: Token;
+        readonly endWhile?: Token;
     };
     readonly condition: Expression;
     readonly body: Block;
@@ -381,8 +381,8 @@ export declare class DottedSetStatement extends Statement {
         dot?: Token;
     });
     readonly tokens: {
-        name: Identifier;
-        dot?: Token;
+        readonly name: Identifier;
+        readonly dot?: Token;
     };
     readonly obj: Expression;
     readonly value: Expression;
@@ -401,8 +401,8 @@ export declare class IndexedSetStatement extends Statement {
         closingSquare?: Token;
     });
     readonly tokens: {
-        openingSquare?: Token;
-        closingSquare?: Token;
+        readonly openingSquare?: Token;
+        readonly closingSquare?: Token;
     };
     readonly obj: Expression;
     readonly indexes: Expression[];
@@ -418,8 +418,8 @@ export declare class LibraryStatement extends Statement implements TypedefProvid
         filePath?: Token;
     });
     readonly tokens: {
-        library: Token;
-        filePath?: Token;
+        readonly library: Token;
+        readonly filePath?: Token;
     };
     readonly kind = AstNodeKind.LibraryStatement;
     readonly range: Range;
@@ -435,11 +435,11 @@ export declare class NamespaceStatement extends Statement implements TypedefProv
         endNamespace?: Token;
     });
     readonly tokens: {
-        namespace?: Token;
-        endNamespace?: Token;
+        readonly namespace?: Token;
+        readonly endNamespace?: Token;
     };
     readonly nameExpression: VariableExpression | DottedGetExpression;
-    body: Body;
+    readonly body: Body;
     readonly kind = AstNodeKind.NamespaceStatement;
     /**
      * The string name for this namespace
@@ -459,15 +459,15 @@ export declare class NamespaceStatement extends Statement implements TypedefProv
 export declare class ImportStatement extends Statement implements TypedefProvider {
     constructor(options: {
         import?: Token;
-        filePath: Token;
+        path: Token;
     });
     readonly tokens: {
-        import?: Token;
-        filePath: Token;
+        readonly import?: Token;
+        readonly path: Token;
     };
     readonly kind = AstNodeKind.ImportStatement;
-    range: Range;
-    filePath: string;
+    readonly range: Range;
+    readonly filePath: string;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     /**
      * Get the typedef for this statement
@@ -484,16 +484,16 @@ export declare class InterfaceStatement extends Statement implements TypedefProv
         body: Statement[];
         endInterface?: Token;
     });
-    parentInterfaceName?: TypeExpression;
-    body: Statement[];
+    readonly parentInterfaceName?: TypeExpression;
+    readonly body: Statement[];
     readonly kind = AstNodeKind.InterfaceStatement;
-    tokens: {
-        interface?: Token;
-        name: Identifier;
-        extends?: Token;
-        endInterface?: Token;
+    readonly tokens: {
+        readonly interface?: Token;
+        readonly name: Identifier;
+        readonly extends?: Token;
+        readonly endInterface?: Token;
     };
-    range: Range;
+    readonly range: Range;
     get fields(): InterfaceFieldStatement[];
     get methods(): InterfaceMethodStatement[];
     hasParentInterface(): boolean;
@@ -524,12 +524,12 @@ export declare class InterfaceFieldStatement extends Statement implements Typede
         optional?: Token;
     });
     readonly kind = AstNodeKind.InterfaceFieldStatement;
-    typeExpression?: TypeExpression;
-    range: Range;
-    tokens: {
-        name: Identifier;
-        as: Token;
-        optional?: Token;
+    readonly typeExpression?: TypeExpression;
+    readonly range: Range;
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly as: Token;
+        readonly optional?: Token;
     };
     getLeadingTrivia(): Token[];
     get name(): string;
@@ -556,16 +556,16 @@ export declare class InterfaceMethodStatement extends Statement implements Typed
      * Get the name of this method.
      */
     getName(parseMode: ParseMode): string;
-    tokens: {
-        optional?: Token;
-        functionType: Token;
-        name: Identifier;
-        leftParen?: Token;
-        rightParen?: Token;
-        as?: Token;
-    };
-    params: FunctionParameterExpression[];
-    returnTypeExpression?: TypeExpression;
+    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;
     getLeadingTrivia(): Token[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -585,22 +585,22 @@ export declare class ClassStatement extends Statement implements TypedefProvider
         parentClassName?: TypeExpression;
     });
     readonly kind = AstNodeKind.ClassStatement;
-    tokens: {
-        class?: Token;
+    readonly tokens: {
+        readonly class?: Token;
         /**
          * The name of the class (without namespace prefix)
          */
-        name: Identifier;
-        endClass?: Token;
-        extends?: Token;
+        readonly name: Identifier;
+        readonly endClass?: Token;
+        readonly extends?: Token;
     };
     readonly body: Statement[];
     readonly parentClassName: TypeExpression;
     getName(parseMode: ParseMode): string;
     getLeadingTrivia(): Token[];
-    memberMap: Record<string, MemberStatement>;
-    methods: MethodStatement[];
-    fields: FieldStatement[];
+    readonly memberMap: Record<string, MemberStatement>;
+    readonly methods: MethodStatement[];
+    readonly fields: FieldStatement[];
     readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     getTypedef(state: BrsTranspileState): TranspileResult;
@@ -649,10 +649,10 @@ export declare class MethodStatement extends FunctionStatement {
         override?: Token;
     });
     readonly kind: AstNodeKind;
-    modifiers: Token[];
+    readonly modifiers: Token[];
     readonly tokens: {
-        name: Identifier;
-        override?: Token;
+        readonly name: Identifier;
+        readonly override?: Token;
     };
     get accessModifier(): Token;
     readonly range: Range;
@@ -685,14 +685,14 @@ export declare class FieldStatement extends Statement implements TypedefProvider
         optional?: Token;
     });
     readonly tokens: {
-        accessModifier?: Token;
-        name: Identifier;
-        as?: Token;
-        equals?: Token;
-        optional?: Token;
-    };
-    typeExpression?: TypeExpression;
-    initialValue?: Expression;
+        readonly accessModifier?: Token;
+        readonly name: Identifier;
+        readonly as?: Token;
+        readonly equals?: Token;
+        readonly optional?: Token;
+    };
+    readonly typeExpression?: TypeExpression;
+    readonly initialValue?: Expression;
     readonly kind = AstNodeKind.FieldStatement;
     /**
      * Derive a ValueKind from the type token, or the initial value.
@@ -715,11 +715,11 @@ export declare class TryCatchStatement extends Statement {
         catchStatement?: CatchStatement;
     });
     readonly tokens: {
-        try?: Token;
-        endTry?: Token;
+        readonly try?: Token;
+        readonly endTry?: Token;
     };
-    tryBranch: Block;
-    catchStatement: CatchStatement;
+    readonly tryBranch: Block;
+    readonly catchStatement: CatchStatement;
     readonly kind = AstNodeKind.TryCatchStatement;
     readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
@@ -732,12 +732,12 @@ export declare class CatchStatement extends Statement {
         catchBranch?: Block;
     });
     readonly tokens: {
-        catch?: Token;
-        exceptionVariable?: Identifier;
+        readonly catch?: Token;
+        readonly exceptionVariable?: Identifier;
     };
-    catchBranch?: Block;
+    readonly catchBranch?: Block;
     readonly kind = AstNodeKind.CatchStatement;
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -747,11 +747,11 @@ export declare class ThrowStatement extends Statement {
         expression?: Expression;
     });
     readonly tokens: {
-        throw?: Token;
+        readonly throw?: Token;
     };
-    expression?: Expression;
+    readonly expression?: Expression;
     readonly kind = AstNodeKind.ThrowStatement;
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -762,14 +762,13 @@ export declare class EnumStatement extends Statement implements TypedefProvider
         endEnum?: Token;
         body: Array<EnumMemberStatement | CommentStatement>;
     });
-    tokens: {
-        enum?: Token;
-        name: Identifier;
-        endEnum?: Token;
+    readonly tokens: {
+        readonly enum?: Token;
+        readonly name: Identifier;
+        readonly endEnum?: Token;
     };
-    body: Array<EnumMemberStatement | CommentStatement>;
+    readonly body: Array<EnumMemberStatement | CommentStatement>;
     readonly kind = AstNodeKind.EnumStatement;
-    symbolTable: SymbolTable;
     get range(): Range;
     getMembers(): EnumMemberStatement[];
     getLeadingTrivia(): Token[];
@@ -798,11 +797,11 @@ export declare class EnumMemberStatement extends Statement implements TypedefPro
         equals?: Token;
         value?: Expression;
     });
-    tokens: {
-        name: Identifier;
-        equals?: Token;
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly equals?: Token;
     };
-    value?: Expression;
+    readonly value?: Expression;
     readonly kind = AstNodeKind.EnumMemberStatement;
     get range(): Range;
     /**
@@ -822,14 +821,14 @@ export declare class ConstStatement extends Statement implements TypedefProvider
         equals?: Token;
         value: Expression;
     });
-    tokens: {
-        const: Token;
-        name: Identifier;
-        equals: Token;
+    readonly tokens: {
+        readonly const: Token;
+        readonly name: Identifier;
+        readonly equals: Token;
     };
-    value: Expression;
+    readonly value: Expression;
     readonly kind = AstNodeKind.ConstStatement;
-    range: Range;
+    readonly range: Range;
     get name(): string;
     getLeadingTrivia(): Token[];
     /**
@@ -846,12 +845,12 @@ export declare class ContinueStatement extends Statement {
         continue?: Token;
         loopType: Token;
     });
-    tokens: {
-        continue?: Token;
-        loopType: Token;
+    readonly tokens: {
+        readonly continue?: Token;
+        readonly loopType: Token;
     };
     readonly kind = AstNodeKind.ContinueStatement;
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }