brighterscript 1.0.0-alpha.26 → 1.0.0-alpha.28

package/dist/parser/Expression.d.ts

@@ -1,19 +1,19 @@
 import type { Token, Identifier } from '../lexer/Token';
-import type { Block, CommentStatement, FunctionStatement } from './Statement';
+import type { Block, FunctionStatement } from './Statement';
 import type { Range } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
 import { ParseMode } from './Parser';
 import type { WalkOptions, WalkVisitor } from '../astUtils/visitors';
-import type { GetTypeOptions } from '../interfaces';
-import { type TranspileResult, type TypedefProvider } from '../interfaces';
+import type { GetTypeOptions, TranspileResult, TypedefProvider } from '../interfaces';
 import { VoidType } from '../types/VoidType';
 import { DynamicType } from '../types/DynamicType';
 import type { BscType } from '../types/BscType';
-import { TypedFunctionType } from '../types/TypedFunctionType';
 import { AstNodeKind, Expression } from './AstNode';
 import { SourceNode } from 'source-map';
 import type { TranspileState } from './TranspileState';
 import { StringType } from '../types/StringType';
+import { TypedFunctionType } from '../types';
+import { FunctionType } from '../types/FunctionType';
 export declare type ExpressionVisitor = (expression: Expression, parent: Expression) => void;
 export declare class BinaryExpression extends Expression {
     constructor(options: {
@@ -21,16 +21,17 @@ export declare class BinaryExpression extends Expression {
         operator: Token;
         right: Expression;
     });
-    tokens: {
-        operator: Token;
+    readonly tokens: {
+        readonly operator: Token;
     };
-    left: Expression;
-    right: Expression;
+    readonly left: Expression;
+    readonly right: Expression;
     readonly kind = AstNodeKind.BinaryExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class CallExpression extends Expression {
     static MaximumArguments: number;
@@ -42,7 +43,7 @@ export declare class CallExpression extends Expression {
     });
     readonly callee: Expression;
     readonly args: Expression[];
-    tokens: {
+    readonly tokens: {
         /**
          * Can either be `(`, or `?(` for optional chaining - defaults to '('
          */
@@ -50,10 +51,11 @@ export declare class CallExpression extends Expression {
         readonly closingParen?: Token;
     };
     readonly kind = AstNodeKind.CallExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState, nameOverride?: string): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState, nameOverride?: string): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): any;
+    getLeadingTrivia(): Token[];
 }
 export declare class FunctionExpression extends Expression implements TypedefProvider {
     constructor(options: {
@@ -68,20 +70,15 @@ export declare class FunctionExpression extends Expression implements TypedefPro
     });
     readonly kind = AstNodeKind.FunctionExpression;
     readonly parameters: FunctionParameterExpression[];
-    body: Block;
-    returnTypeExpression?: TypeExpression;
+    readonly body: Block;
+    readonly returnTypeExpression?: TypeExpression;
     readonly tokens: {
-        functionType?: Token;
-        endFunctionType?: Token;
-        leftParen?: Token;
-        rightParen?: Token;
-        as?: Token;
+        readonly functionType?: Token;
+        readonly endFunctionType?: Token;
+        readonly leftParen?: Token;
+        readonly rightParen?: Token;
+        readonly as?: Token;
     };
-    /**
-     * The list of function calls that are declared within this function scope. This excludes CallExpressions
-     * declared in child functions
-     */
-    callExpressions: CallExpression[];
     /**
      * If this function is part of a FunctionStatement, this will be set. Otherwise this will be undefined
      */
@@ -92,7 +89,7 @@ export declare class FunctionExpression extends Expression implements TypedefPro
      * and ending with the last n' in 'end function' or 'b' in 'end sub'
      */
     get range(): Range;
-    transpile(state: BrsTranspileState, name?: Identifier, includeBody?: boolean): any[];
+    transpile(state: BrsTranspileState, name?: Identifier, includeBody?: boolean): TranspileResult;
     getTypedef(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): TypedFunctionType;
@@ -106,18 +103,19 @@ export declare class FunctionParameterExpression extends Expression {
         typeExpression?: TypeExpression;
     });
     readonly kind = AstNodeKind.FunctionParameterExpression;
-    tokens: {
-        name: Identifier;
-        equals?: Token;
-        as?: Token;
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly equals?: Token;
+        readonly as?: Token;
     };
-    defaultValue?: Expression;
-    typeExpression?: TypeExpression;
+    readonly defaultValue?: Expression;
+    readonly typeExpression?: TypeExpression;
     getType(options: GetTypeOptions): BscType;
-    get range(): Range;
-    transpile(state: BrsTranspileState): any[];
+    get range(): Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 export declare class DottedGetExpression extends Expression {
     constructor(options: {
@@ -129,16 +127,17 @@ export declare class DottedGetExpression extends Expression {
         dot?: Token;
     });
     readonly tokens: {
-        name: Identifier;
-        dot?: Token;
+        readonly name: Identifier;
+        readonly dot?: Token;
     };
     readonly obj: Expression;
     readonly kind = AstNodeKind.DottedGetExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
     getName(parseMode: ParseMode): string;
+    getLeadingTrivia(): Token[];
 }
 export declare class XmlAttributeGetExpression extends Expression {
     constructor(options: {
@@ -150,14 +149,15 @@ export declare class XmlAttributeGetExpression extends Expression {
         name: Identifier;
     });
     readonly kind = AstNodeKind.XmlAttributeGetExpression;
-    tokens: {
+    readonly tokens: {
         name: Identifier;
         at?: Token;
     };
     readonly obj: Expression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 export declare class IndexedGetExpression extends Expression {
     constructor(options: {
@@ -171,20 +171,21 @@ export declare class IndexedGetExpression extends Expression {
         questionDot?: Token;
     });
     readonly kind = AstNodeKind.IndexedGetExpression;
-    obj: Expression;
-    indexes: Expression[];
-    tokens: {
+    readonly obj: Expression;
+    readonly indexes: Expression[];
+    readonly tokens: {
         /**
          * Can either be `[` or `?[`. If `?.[` is used, this will be `[` and `optionalChainingToken` will be `?.` - defaults to '[' in transpile
          */
-        openingSquare?: Token;
-        closingSquare?: Token;
-        questionDot?: Token;
+        readonly openingSquare?: Token;
+        readonly closingSquare?: Token;
+        readonly questionDot?: Token;
     };
-    readonly range: Range;
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class GroupingExpression extends Expression {
     constructor(options: {
@@ -193,28 +194,30 @@ export declare class GroupingExpression extends Expression {
         expression: Expression;
     });
     readonly tokens: {
-        leftParen?: Token;
-        rightParen?: Token;
+        readonly leftParen?: Token;
+        readonly rightParen?: Token;
     };
-    expression: Expression;
+    readonly expression: Expression;
     readonly kind = AstNodeKind.GroupingExpression;
-    readonly range: Range;
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class LiteralExpression extends Expression {
     constructor(options: {
         value: Token;
     });
-    tokens: {
-        value: Token;
+    readonly tokens: {
+        readonly value: Token;
     };
     readonly kind = AstNodeKind.LiteralExpression;
     get range(): Range;
-    getType(options?: GetTypeOptions): DynamicType | import("../types").ObjectType | StringType | import("../types").IntegerType | import("../types").BooleanType | import("../types").FloatType | import("../types").DoubleType | import("../types").LongIntegerType | VoidType | import("../types/FunctionType").FunctionType;
-    transpile(state: BrsTranspileState): SourceNode[];
+    getType(options?: GetTypeOptions): DynamicType | import("../types").ObjectType | StringType | import("../types").IntegerType | import("../types").BooleanType | import("../types").FloatType | import("../types").DoubleType | import("../types").LongIntegerType | VoidType | FunctionType;
+    transpile(state: BrsTranspileState): TranspileResult[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 /**
  * This is a special expression only used within template strings. It exists so we can prevent producing lots of empty strings
@@ -227,8 +230,8 @@ export declare class EscapedCharCodeLiteralExpression extends Expression {
         };
     });
     readonly kind = AstNodeKind.EscapedCharCodeLiteralExpression;
-    tokens: {
-        value: Token & {
+    readonly tokens: {
+        readonly value: Token & {
             charCode: number;
         };
     };
@@ -238,20 +241,21 @@ export declare class EscapedCharCodeLiteralExpression extends Expression {
 }
 export declare class ArrayLiteralExpression extends Expression {
     constructor(options: {
-        elements: Array<Expression | CommentStatement>;
+        elements: Array<Expression>;
         open?: Token;
         close?: Token;
     });
-    readonly elements: Array<Expression | CommentStatement>;
+    readonly elements: Array<Expression>;
     readonly tokens: {
-        open?: Token;
-        close?: Token;
+        readonly open?: Token;
+        readonly close?: Token;
     };
     readonly kind = AstNodeKind.ArrayLiteralExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class AAMemberExpression extends Expression {
     constructor(options: {
@@ -262,34 +266,36 @@ export declare class AAMemberExpression extends Expression {
         comma?: Token;
     });
     readonly kind = AstNodeKind.AAMemberExpression;
-    range: Range;
-    tokens: {
-        key: Token;
-        colon?: Token;
-        comma?: Token;
+    readonly range: Range | undefined;
+    readonly tokens: {
+        readonly key: Token;
+        readonly colon?: Token;
+        readonly comma?: Token;
     };
     /** The expression evaluated to determine the member's initial value. */
-    value: Expression;
+    readonly value: Expression;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class AALiteralExpression extends Expression {
     constructor(options: {
-        elements: Array<AAMemberExpression | CommentStatement>;
+        elements: Array<AAMemberExpression>;
         open?: Token;
         close?: Token;
     });
-    readonly elements: Array<AAMemberExpression | CommentStatement>;
+    readonly elements: Array<AAMemberExpression>;
     readonly tokens: {
-        open?: Token;
-        close?: Token;
+        readonly open?: Token;
+        readonly close?: Token;
     };
     readonly kind = AstNodeKind.AALiteralExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class UnaryExpression extends Expression {
     constructor(options: {
@@ -297,28 +303,30 @@ export declare class UnaryExpression extends Expression {
         right: Expression;
     });
     readonly kind = AstNodeKind.UnaryExpression;
-    readonly range: Range;
-    tokens: {
-        operator: Token;
+    readonly range: Range | undefined;
+    readonly tokens: {
+        readonly operator: Token;
     };
-    right: Expression;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly right: Expression;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class VariableExpression extends Expression {
     constructor(options: {
         name: Identifier;
     });
     readonly tokens: {
-        name: Identifier;
+        readonly name: Identifier;
     };
     readonly kind = AstNodeKind.VariableExpression;
     readonly range: Range;
     getName(parseMode?: ParseMode): string;
-    transpile(state: BrsTranspileState): any[];
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 export declare class SourceLiteralExpression extends Expression {
     constructor(options: {
@@ -327,15 +335,20 @@ export declare class SourceLiteralExpression extends Expression {
     readonly range: Range;
     readonly kind = AstNodeKind.SourceLiteralExpression;
     readonly tokens: {
-        value: Token;
+        readonly value: Token;
     };
     /**
      * Find the index of the function in its parent
      */
     private findFunctionIndex;
     private getFunctionName;
+    /**
+     * Get the line number from our token or from the closest ancestor that has a range
+     */
+    private getClosestLineNumber;
     transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 /**
  * This expression transpiles and acts exactly like a CallExpression,
@@ -348,18 +361,19 @@ export declare class NewExpression extends Expression {
         call: CallExpression;
     });
     readonly kind = AstNodeKind.NewExpression;
-    readonly range: Range;
+    readonly range: Range | undefined;
     readonly tokens: {
-        new?: Token;
+        readonly new?: Token;
     };
     readonly call: CallExpression;
     /**
      * The name of the class to initialize (with optional namespace prefixed)
      */
     get className(): DottedGetExpression | VariableExpression;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): any;
+    getLeadingTrivia(): Token[];
 }
 export declare class CallfuncExpression extends Expression {
     constructor(options: {
@@ -373,16 +387,17 @@ export declare class CallfuncExpression extends Expression {
     readonly callee: Expression;
     readonly args: Expression[];
     readonly tokens: {
-        operator: Token;
-        methodName: Identifier;
-        openingParen?: Token;
-        closingParen?: Token;
+        readonly operator: Token;
+        readonly methodName: Identifier;
+        readonly openingParen?: Token;
+        readonly closingParen?: Token;
     };
     readonly kind = AstNodeKind.CallfuncExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
+    getLeadingTrivia(): Token[];
 }
 /**
  * Since template strings can contain newlines, we need to concatenate multiple strings together with chr() calls.
@@ -394,8 +409,8 @@ export declare class TemplateStringQuasiExpression extends Expression {
     });
     readonly expressions: Array<LiteralExpression | EscapedCharCodeLiteralExpression>;
     readonly kind = AstNodeKind.TemplateStringQuasiExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState, skipEmptyStrings?: boolean): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState, skipEmptyStrings?: boolean): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class TemplateStringExpression extends Expression {
@@ -407,14 +422,14 @@ export declare class TemplateStringExpression extends Expression {
     });
     readonly kind = AstNodeKind.TemplateStringExpression;
     readonly tokens: {
-        openingBacktick?: Token;
-        closingBacktick?: Token;
+        readonly openingBacktick?: Token;
+        readonly closingBacktick?: Token;
     };
     readonly quasis: TemplateStringQuasiExpression[];
     readonly expressions: Expression[];
-    readonly range: Range;
+    readonly range: Range | undefined;
     getType(options: GetTypeOptions): StringType;
-    transpile(state: BrsTranspileState): any[];
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class TaggedTemplateStringExpression extends Expression {
@@ -426,15 +441,15 @@ export declare class TaggedTemplateStringExpression extends Expression {
         closingBacktick?: Token;
     });
     readonly kind = AstNodeKind.TaggedTemplateStringExpression;
-    tokens: {
-        tagName: Identifier;
-        openingBacktick?: Token;
-        closingBacktick?: Token;
+    readonly tokens: {
+        readonly tagName: Identifier;
+        readonly openingBacktick?: Token;
+        readonly closingBacktick?: Token;
     };
     readonly quasis: TemplateStringQuasiExpression[];
     readonly expressions: Expression[];
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class AnnotationExpression extends Expression {
@@ -445,11 +460,11 @@ export declare class AnnotationExpression extends Expression {
     });
     readonly kind = AstNodeKind.AnnotationExpression;
     readonly tokens: {
-        at: Token;
-        name: Token;
+        readonly at: Token;
+        readonly name: Token;
     };
-    get range(): Range;
-    name: string;
+    get range(): Range | undefined;
+    readonly name: string;
     call: CallExpression;
     /**
      * Convert annotation arguments to JavaScript types
@@ -459,7 +474,7 @@ export declare class AnnotationExpression extends Expression {
     getLeadingTrivia(): Token[];
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getTypedef(state: BrsTranspileState): (string | SourceNode)[];
+    getTypedef(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
 }
 export declare class TernaryExpression extends Expression {
     constructor(options: {
@@ -470,16 +485,17 @@ export declare class TernaryExpression extends Expression {
         alternate?: Expression;
     });
     readonly kind = AstNodeKind.TernaryExpression;
-    range: Range;
+    readonly range: Range | undefined;
     readonly tokens: {
-        questionMark?: Token;
-        colon?: Token;
+        readonly questionMark?: Token;
+        readonly colon?: Token;
     };
     readonly test: Expression;
     readonly consequent?: Expression;
     readonly alternate?: Expression;
-    transpile(state: BrsTranspileState): any[];
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 export declare class NullCoalescingExpression extends Expression {
     constructor(options: {
@@ -488,30 +504,32 @@ export declare class NullCoalescingExpression extends Expression {
         alternate: Expression;
     });
     readonly kind = AstNodeKind.NullCoalescingExpression;
-    readonly range: Range;
-    tokens: {
-        questionQuestion?: Token;
+    readonly range: Range | undefined;
+    readonly tokens: {
+        readonly questionQuestion?: Token;
     };
-    consequent: Expression;
-    alternate: Expression;
-    transpile(state: BrsTranspileState): any[];
+    readonly consequent: Expression;
+    readonly alternate: Expression;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 export declare class RegexLiteralExpression extends Expression {
     constructor(options: {
         regexLiteral: Token;
     });
     readonly kind = AstNodeKind.RegexLiteralExpression;
-    tokens: {
-        regexLiteral: Token;
+    readonly tokens: {
+        readonly regexLiteral: Token;
     };
     get range(): Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getLeadingTrivia(): Token[];
 }
 declare type ExpressionValue = string | number | boolean | Expression | ExpressionValue[] | {
     [key: string]: ExpressionValue;
-};
+} | null;
 export declare class TypeExpression extends Expression implements TypedefProvider {
     constructor(options: {
         /**
@@ -523,12 +541,12 @@ export declare class TypeExpression extends Expression implements TypedefProvide
     /**
      * The standard AST expression that represents the type for this TypeExpression.
      */
-    expression: Expression;
-    range: Range;
+    readonly expression: Expression;
+    readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
-    getTypedef(state: TranspileState): (string | SourceNode)[];
+    getTypedef(state: TranspileState): TranspileResult;
     getName(parseMode?: ParseMode): string;
     getNameParts(): string[];
 }
@@ -539,12 +557,12 @@ export declare class TypeCastExpression extends Expression {
         typeExpression?: TypeExpression;
     });
     readonly kind = AstNodeKind.TypeCastExpression;
-    obj: Expression;
-    tokens: {
-        as?: Token;
+    readonly obj: Expression;
+    readonly tokens: {
+        readonly as?: Token;
     };
     typeExpression?: TypeExpression;
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;
@@ -555,13 +573,13 @@ export declare class TypedArrayExpression extends Expression {
         leftBracket?: Token;
         rightBracket?: Token;
     });
-    tokens: {
-        leftBracket?: Token;
-        rightBracket?: Token;
+    readonly tokens: {
+        readonly leftBracket?: Token;
+        readonly rightBracket?: Token;
     };
-    innerType: Expression;
+    readonly innerType: Expression;
     readonly kind = AstNodeKind.TypedArrayExpression;
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getType(options: GetTypeOptions): BscType;