brighterscript 0.66.0-alpha.8 → 0.67.0

package/dist/parser/Expression.d.ts

@@ -4,26 +4,20 @@ 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, TranspileResult, TypedefProvider } from '../interfaces';
+import type { TranspileResult, TypedefProvider } from '../interfaces';
 import type { BscType } from '../types/BscType';
-import { TypedFunctionType } from '../types/TypedFunctionType';
-import { AstNodeKind, Expression } from './AstNode';
+import { FunctionType } from '../types/FunctionType';
+import { Expression } from './AstNode';
 import { SourceNode } from 'source-map';
-import type { TranspileState } from './TranspileState';
-import { StringType } from '../types/StringType';
-import { DynamicType } from '../types/DynamicType';
-import { VoidType } from '../types/VoidType';
 export declare type ExpressionVisitor = (expression: Expression, parent: Expression) => void;
 export declare class BinaryExpression extends Expression {
     left: Expression;
     operator: Token;
     right: Expression;
     constructor(left: Expression, operator: Token, right: Expression);
-    readonly kind = AstNodeKind.BinaryExpression;
-    readonly range: Range;
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
 export declare class CallExpression extends Expression {
     readonly callee: Expression;
@@ -33,17 +27,26 @@ export declare class CallExpression extends Expression {
     readonly openingParen: Token;
     readonly closingParen: Token;
     readonly args: Expression[];
+    /**
+     * Number of parameters that can be defined on a function
+     *
+     * Prior to Roku OS 11.5, this was 32
+     * As of Roku OS 11.5, this is 63
+     */
     static MaximumArguments: number;
     constructor(callee: Expression, 
     /**
      * Can either be `(`, or `?(` for optional chaining
      */
     openingParen: Token, closingParen: Token, args: Expression[], unused?: any);
-    readonly kind = AstNodeKind.CallExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState, nameOverride?: string): any[];
+    readonly range: Range | undefined;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
+    transpile(state: BrsTranspileState, nameOverride?: string): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): any;
 }
 export declare class FunctionExpression extends Expression implements TypedefProvider {
     readonly parameters: FunctionParameterExpression[];
@@ -53,9 +56,22 @@ export declare class FunctionExpression extends Expression implements TypedefPro
     readonly leftParen: Token;
     readonly rightParen: Token;
     readonly asToken?: Token;
-    returnTypeExpression?: TypeExpression;
-    constructor(parameters: FunctionParameterExpression[], body: Block, functionType: Token | null, end: Token, leftParen: Token, rightParen: Token, asToken?: Token, returnTypeExpression?: TypeExpression);
-    readonly kind = AstNodeKind.FunctionExpression;
+    readonly returnTypeToken?: Token;
+    constructor(parameters: FunctionParameterExpression[], body: Block, functionType: Token | null, end: Token, leftParen: Token, rightParen: Token, asToken?: Token, returnTypeToken?: Token);
+    /**
+     * The type this function returns
+     */
+    returnType: BscType;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isFunctionExpression)` instead.
+     */
+    get parentFunction(): FunctionExpression;
     /**
      * The list of function calls that are declared within this function scope. This excludes CallExpressions
      * declared in child functions
@@ -65,31 +81,42 @@ export declare class FunctionExpression extends Expression implements TypedefPro
      * If this function is part of a FunctionStatement, this will be set. Otherwise this will be undefined
      */
     functionStatement?: FunctionStatement;
-    getLeadingTrivia(): Token[];
+    /**
+     * A list of all child functions declared directly within this function
+     * @deprecated use `.walk(createVisitor({ FunctionExpression: ()=>{}), { walkMode: WalkMode.visitAllRecursive })` instead
+     */
+    get childFunctionExpressions(): FunctionExpression[];
     /**
      * The range of the function, starting at the 'f' in function or 's' in sub (or the open paren if the keyword is missing),
      * 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;
+    getFunctionType(): FunctionType;
 }
 export declare class FunctionParameterExpression extends Expression {
     name: Identifier;
-    equalToken?: Token;
+    typeToken?: Token;
     defaultValue?: Expression;
     asToken?: Token;
-    typeExpression?: TypeExpression;
-    constructor(name: Identifier, equalToken?: Token, defaultValue?: Expression, asToken?: Token, typeExpression?: TypeExpression);
-    readonly kind = AstNodeKind.FunctionParameterExpression;
-    getType(options: GetTypeOptions): BscType;
-    get range(): Range;
+    constructor(name: Identifier, typeToken?: Token, defaultValue?: Expression, asToken?: Token);
+    type: BscType;
+    get range(): Range | undefined;
     transpile(state: BrsTranspileState): any[];
     getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
+export declare class NamespacedVariableNameExpression extends Expression {
+    readonly expression: DottedGetExpression | VariableExpression;
+    constructor(expression: DottedGetExpression | VariableExpression);
+    range: Range | undefined;
+    transpile(state: BrsTranspileState): SourceNode[];
+    getNameParts(): string[];
+    getName(parseMode: ParseMode): string;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+}
 export declare class DottedGetExpression extends Expression {
     readonly obj: Expression;
     readonly name: Identifier;
@@ -102,12 +129,9 @@ export declare class DottedGetExpression extends Expression {
      * Can either be `.`, or `?.` for optional chaining
      */
     dot: Token);
-    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;
 }
 export declare class XmlAttributeGetExpression extends Expression {
     readonly obj: Expression;
@@ -121,9 +145,8 @@ export declare class XmlAttributeGetExpression extends Expression {
      * Can either be `@`, or `?@` for optional chaining
      */
     at: Token);
-    readonly kind = AstNodeKind.XmlAttributeGetExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class IndexedGetExpression extends Expression {
@@ -135,16 +158,22 @@ export declare class IndexedGetExpression extends Expression {
     openingSquare: Token;
     closingSquare: Token;
     questionDotToken?: Token;
+    /**
+     * More indexes, separated by commas
+     */
+    additionalIndexes?: Expression[];
     constructor(obj: Expression, index: Expression, 
     /**
      * Can either be `[` or `?[`. If `?.[` is used, this will be `[` and `optionalChainingToken` will be `?.`
      */
-    openingSquare: Token, closingSquare: Token, questionDotToken?: Token);
-    readonly kind = AstNodeKind.IndexedGetExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    openingSquare: Token, closingSquare: Token, questionDotToken?: Token, //  ? or ?.
+    /**
+     * More indexes, separated by commas
+     */
+    additionalIndexes?: Expression[]);
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
 export declare class GroupingExpression extends Expression {
     readonly tokens: {
@@ -156,18 +185,18 @@ export declare class GroupingExpression extends Expression {
         left: Token;
         right: Token;
     }, expression: Expression);
-    readonly kind = AstNodeKind.GroupingExpression;
-    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;
 }
 export declare class LiteralExpression extends Expression {
     token: Token;
     constructor(token: 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;
+    /**
+     * The (data) type of this expression
+     */
+    type: BscType;
     transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -182,7 +211,6 @@ export declare class EscapedCharCodeLiteralExpression extends Expression {
     constructor(token: Token & {
         charCode: number;
     });
-    readonly kind = AstNodeKind.EscapedCharCodeLiteralExpression;
     readonly range: Range;
     transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -193,11 +221,9 @@ export declare class ArrayLiteralExpression extends Expression {
     readonly close: Token;
     readonly hasSpread: boolean;
     constructor(elements: Array<Expression | CommentStatement>, open: Token, close: Token, hasSpread?: boolean);
-    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;
 }
 export declare class AAMemberExpression extends Expression {
     keyToken: Token;
@@ -207,54 +233,45 @@ export declare class AAMemberExpression extends Expression {
     constructor(keyToken: Token, colonToken: Token, 
     /** The expression evaluated to determine the member's initial value. */
     value: Expression);
-    readonly kind = AstNodeKind.AAMemberExpression;
-    range: Range;
+    range: Range | undefined;
     commaToken?: Token;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
 export declare class AALiteralExpression extends Expression {
     readonly elements: Array<AAMemberExpression | CommentStatement>;
     readonly open: Token;
     readonly close: Token;
     constructor(elements: Array<AAMemberExpression | CommentStatement>, open: Token, 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;
 }
 export declare class UnaryExpression extends Expression {
     operator: Token;
     right: Expression;
     constructor(operator: Token, right: Expression);
-    readonly kind = AstNodeKind.UnaryExpression;
-    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;
 }
 export declare class VariableExpression extends Expression {
     readonly name: Identifier;
     constructor(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;
 }
 export declare class SourceLiteralExpression extends Expression {
     readonly token: Token;
     constructor(token: Token);
     readonly range: Range;
-    readonly kind = AstNodeKind.SourceLiteralExpression;
+    private getFunctionName;
     /**
-     * Find the index of the function in its parent
+     * Get the line number from our token or from the closest ancestor that has a range
      */
-    private findFunctionIndex;
-    private getFunctionName;
+    private getClosestLineNumber;
     transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -267,15 +284,13 @@ export declare class NewExpression extends Expression {
     readonly newKeyword: Token;
     readonly call: CallExpression;
     constructor(newKeyword: Token, call: CallExpression);
-    readonly kind = AstNodeKind.NewExpression;
-    readonly range: Range;
     /**
      * The name of the class to initialize (with optional namespace prefixed)
      */
-    get className(): DottedGetExpression | VariableExpression;
-    transpile(state: BrsTranspileState): any[];
+    get className(): NamespacedVariableNameExpression;
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): any;
 }
 export declare class CallfuncExpression extends Expression {
     readonly callee: Expression;
@@ -285,11 +300,14 @@ export declare class CallfuncExpression extends Expression {
     readonly args: Expression[];
     readonly closingParen: Token;
     constructor(callee: Expression, operator: Token, methodName: Identifier, openingParen: Token, args: Expression[], closingParen: Token);
-    readonly kind = AstNodeKind.CallfuncExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
 /**
  * Since template strings can contain newlines, we need to concatenate multiple strings together with chr() calls.
@@ -298,9 +316,8 @@ export declare class CallfuncExpression extends Expression {
 export declare class TemplateStringQuasiExpression extends Expression {
     readonly expressions: Array<LiteralExpression | EscapedCharCodeLiteralExpression>;
     constructor(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 {
@@ -309,10 +326,8 @@ export declare class TemplateStringExpression extends Expression {
     readonly expressions: Expression[];
     readonly closingBacktick: Token;
     constructor(openingBacktick: Token, quasis: TemplateStringQuasiExpression[], expressions: Expression[], closingBacktick: Token);
-    readonly kind = AstNodeKind.TemplateStringExpression;
-    readonly range: Range;
-    getType(options: GetTypeOptions): StringType;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class TaggedTemplateStringExpression extends Expression {
@@ -322,28 +337,25 @@ export declare class TaggedTemplateStringExpression extends Expression {
     readonly expressions: Expression[];
     readonly closingBacktick: Token;
     constructor(tagName: Identifier, openingBacktick: Token, quasis: TemplateStringQuasiExpression[], expressions: Expression[], closingBacktick: Token);
-    readonly kind = AstNodeKind.TaggedTemplateStringExpression;
-    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 {
     readonly atToken: Token;
     readonly nameToken: Token;
     constructor(atToken: Token, nameToken: Token);
-    readonly kind = AstNodeKind.AnnotationExpression;
-    range: Range;
+    get range(): Range;
     name: string;
-    call: CallExpression;
+    call: CallExpression | undefined;
     /**
      * Convert annotation arguments to JavaScript types
      * @param strict If false, keep Expression objects not corresponding to JS types
      */
     getArguments(strict?: boolean): ExpressionValue[];
-    getLeadingTrivia(): Token[];
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getTypedef(state: BrsTranspileState): any[];
+    getTypedef(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
 }
 export declare class TernaryExpression extends Expression {
     readonly test: Expression;
@@ -352,9 +364,8 @@ export declare class TernaryExpression extends Expression {
     readonly colonToken?: Token;
     readonly alternate?: Expression;
     constructor(test: Expression, questionMarkToken: Token, consequent?: Expression, colonToken?: Token, alternate?: Expression);
-    readonly kind = AstNodeKind.TernaryExpression;
-    range: Range;
-    transpile(state: BrsTranspileState): any[];
+    range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class NullCoalescingExpression extends Expression {
@@ -362,9 +373,8 @@ export declare class NullCoalescingExpression extends Expression {
     questionQuestionToken: Token;
     alternate: Expression;
     constructor(consequent: Expression, questionQuestionToken: Token, alternate: Expression);
-    readonly kind = AstNodeKind.NullCoalescingExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class RegexLiteralExpression extends Expression {
@@ -374,53 +384,20 @@ export declare class RegexLiteralExpression extends Expression {
     constructor(tokens: {
         regexLiteral: Token;
     });
-    readonly kind = AstNodeKind.RegexLiteralExpression;
     get range(): Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
-declare type ExpressionValue = string | number | boolean | Expression | ExpressionValue[] | {
-    [key: string]: ExpressionValue;
-};
-export declare class TypeExpression extends Expression implements TypedefProvider {
-    /**
-     * The standard AST expression that represents the type for this TypeExpression.
-     */
-    expression: Expression;
-    constructor(
-    /**
-     * The standard AST expression that represents the type for this TypeExpression.
-     */
-    expression: Expression);
-    readonly kind = AstNodeKind.TypeExpression;
-    range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
-    walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
-    getTypedef(state: TranspileState): (string | SourceNode)[];
-    getName(parseMode?: ParseMode): string;
-    getNameParts(): string[];
-}
 export declare class TypeCastExpression extends Expression {
     obj: Expression;
-    asToken?: Token;
-    typeExpression?: TypeExpression;
-    constructor(obj: Expression, asToken?: Token, typeExpression?: TypeExpression);
-    readonly kind = AstNodeKind.TypeCastExpression;
+    asToken: Token;
+    typeToken: Token;
+    constructor(obj: Expression, asToken: Token, typeToken: Token);
     range: Range;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
-}
-export declare class TypedArrayExpression extends Expression {
-    innerType: Expression;
-    leftBracket: Token;
-    rightBracket: Token;
-    constructor(innerType: Expression, leftBracket: Token, rightBracket: Token);
-    readonly kind = AstNodeKind.TypedArrayExpression;
-    range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
-    walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
+declare type ExpressionValue = string | number | boolean | Expression | ExpressionValue[] | {
+    [key: string]: ExpressionValue;
+} | null;
 export {};