brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/parser/Expression.d.ts

@@ -1,4 +1,4 @@
-import type { Token, Identifier } from '../lexer';
+import type { Token, Identifier } from '../lexer/Token';
 import type { Block, CommentStatement, FunctionStatement, LabelStatement } from './Statement';
 import type { Range } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
@@ -6,9 +6,12 @@ import { ParseMode } from './Parser';
 import type { WalkOptions, WalkVisitor } from '../astUtils/visitors';
 import { InternalWalkMode } from '../astUtils/visitors';
 import type { TranspileResult, TypedefProvider } from '../interfaces';
-import type { BscType } from '../types/BscType';
+import { VoidType } from '../types/VoidType';
+import { DynamicType } from '../types/DynamicType';
+import type { BscType, SymbolContainer } from '../types/BscType';
 import { SymbolTable } from '../SymbolTable';
-import { FunctionType } from '../types/FunctionType';
+import { TypedFunctionType } from '../types/TypedFunctionType';
+import { ArrayType } from '../types/ArrayType';
 export declare type ExpressionVisitor = (expression: Expression, parent: Expression) => void;
 /** A BrightScript expression */
 export declare abstract class Expression {
@@ -34,6 +37,9 @@ export declare class BinaryExpression extends Expression {
 }
 export declare class CallExpression extends Expression {
     readonly callee: Expression;
+    /**
+     * Can either be `(`, or `?(` for optional chaining
+     */
     readonly openingParen: Token;
     readonly closingParen: Token;
     readonly args: Expression[];
@@ -42,7 +48,11 @@ export declare class CallExpression extends Expression {
      */
     readonly namespaceName: NamespacedVariableNameExpression;
     static MaximumArguments: number;
-    constructor(callee: Expression, openingParen: Token, closingParen: Token, args: Expression[], 
+    constructor(callee: Expression, 
+    /**
+     * Can either be `(`, or `?(` for optional chaining
+     */
+    openingParen: Token, closingParen: Token, args: Expression[], 
     /**
      * The namespace that currently wraps this call expression. This is NOT the namespace of the callee...that will be represented in the callee expression itself.
      */
@@ -59,24 +69,31 @@ export declare class FunctionExpression extends Expression implements TypedefPro
     readonly leftParen: Token;
     readonly rightParen: Token;
     readonly asToken?: Token;
-    readonly returnTypeToken?: Token;
+    readonly returnType?: TypeExpression;
     /**
      * If this function is enclosed within another function, this will reference that parent function
      */
     readonly parentFunction?: FunctionExpression;
     readonly namespaceName?: NamespacedVariableNameExpression;
     readonly parentSymbolTable?: SymbolTable;
-    constructor(parameters: FunctionParameterExpression[], body: Block, functionType: Token | null, end: Token, leftParen: Token, rightParen: Token, asToken?: Token, returnTypeToken?: Token, 
+    constructor(parameters: FunctionParameterExpression[], body: Block, functionType: Token | null, end: Token, leftParen: Token, rightParen: Token, asToken?: Token, returnType?: TypeExpression, 
     /**
      * If this function is enclosed within another function, this will reference that parent function
      */
     parentFunction?: FunctionExpression, namespaceName?: NamespacedVariableNameExpression, parentSymbolTable?: SymbolTable);
+    get range(): Range;
+    /**
+     * The range of the function
+     */
+    cacheRange(): Range;
+    private _range;
     readonly symbolTable: SymbolTable;
     labelStatements: LabelStatement[];
+    private _returnType;
     /**
      * The type this function returns
      */
-    returnType: BscType;
+    getReturnType(): BscType;
     /**
      * The list of function calls that are declared within this function scope. This excludes CallExpressions
      * declared in child functions
@@ -91,42 +108,51 @@ export declare class FunctionExpression extends Expression implements TypedefPro
      */
     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;
+    * The range of the function declaration, starting at the 'f' in function or 's' in sub (or the open paren if the keyword is missing),
+    * and ending with the last character in the returnTypeToken, or the 's' in 'as', or the rightParen
+    */
+    get functionDeclarationRange(): Range;
     transpile(state: BrsTranspileState, name?: Identifier, includeBody?: boolean): any[];
     getTypedef(state: BrsTranspileState, name?: Identifier): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getFunctionType(): FunctionType;
+    getFunctionType(): TypedFunctionType;
 }
 export declare class FunctionParameterExpression extends Expression {
     name: Identifier;
-    type: BscType;
+    private typeInContext;
     equalsToken?: Token;
     defaultValue?: Expression;
     asToken?: Token;
-    typeToken?: Token;
+    type?: TypeExpression;
     readonly namespaceName?: NamespacedVariableNameExpression;
-    constructor(name: Identifier, type: BscType, equalsToken?: Token, defaultValue?: Expression, asToken?: Token, typeToken?: Token, namespaceName?: NamespacedVariableNameExpression);
-    get range(): Range;
+    constructor(name: Identifier, typeInContext: BscType, equalsToken?: Token, defaultValue?: Expression, asToken?: Token, type?: TypeExpression, namespaceName?: NamespacedVariableNameExpression);
+    readonly range: Range;
+    getType(): BscType;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get isOptional(): boolean;
 }
 export declare class NamespacedVariableNameExpression extends Expression {
     readonly expression: DottedGetExpression | VariableExpression;
     constructor(expression: DottedGetExpression | VariableExpression);
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): import("source-map").SourceNode[];
     getNameParts(): string[];
-    getName(parseMode: ParseMode): string;
+    getName(parseMode?: ParseMode): string;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class DottedGetExpression extends Expression {
     readonly obj: Expression;
     readonly name: Identifier;
+    /**
+     * Can either be `.`, or `?.` for optional chaining
+     */
     readonly dot: Token;
-    constructor(obj: Expression, name: Identifier, dot: Token);
+    constructor(obj: Expression, name: Identifier, 
+    /**
+     * Can either be `.`, or `?.` for optional chaining
+     */
+    dot: Token);
     readonly range: Range;
     transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -134,18 +160,33 @@ export declare class DottedGetExpression extends Expression {
 export declare class XmlAttributeGetExpression extends Expression {
     readonly obj: Expression;
     readonly name: Identifier;
+    /**
+     * Can either be `@`, or `?@` for optional chaining
+     */
     readonly at: Token;
-    constructor(obj: Expression, name: Identifier, at: Token);
+    constructor(obj: Expression, name: Identifier, 
+    /**
+     * Can either be `@`, or `?@` for optional chaining
+     */
+    at: Token);
     readonly range: Range;
     transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class IndexedGetExpression extends Expression {
-    readonly obj: Expression;
-    readonly index: Expression;
-    readonly openingSquare: Token;
-    readonly closingSquare: Token;
-    constructor(obj: Expression, index: Expression, openingSquare: Token, closingSquare: Token);
+    obj: Expression;
+    index: Expression;
+    /**
+     * Can either be `[` or `?[`. If `?.[` is used, this will be `[` and `optionalChainingToken` will be `?.`
+     */
+    openingSquare: Token;
+    closingSquare: Token;
+    questionDotToken?: Token;
+    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 range: Range;
     transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -167,7 +208,7 @@ export declare class GroupingExpression extends Expression {
 export declare class LiteralExpression extends Expression {
     token: Token;
     constructor(token: Token);
-    get range(): Range;
+    readonly range: Range;
     /**
      * The (data) type of this expression
      */
@@ -205,19 +246,25 @@ export declare class AAMemberExpression extends Expression {
     colonToken: Token;
     /** The expression evaluated to determine the member's initial value. */
     value: Expression;
+    type: BscType;
     constructor(keyToken: Token, colonToken: Token, 
     /** The expression evaluated to determine the member's initial value. */
-    value: Expression);
-    range: Range;
+    value: Expression, type: BscType);
+    readonly range: Range;
+    commaToken?: Token;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
-export declare class AALiteralExpression extends Expression {
+export declare class AALiteralExpression extends Expression implements SymbolContainer {
     readonly elements: Array<AAMemberExpression | CommentStatement>;
     readonly open: Token;
     readonly close: Token;
-    constructor(elements: Array<AAMemberExpression | CommentStatement>, open: Token, close: Token);
+    readonly functionExpression: FunctionExpression;
+    constructor(elements: Array<AAMemberExpression | CommentStatement>, open: Token, close: Token, functionExpression: FunctionExpression);
     readonly range: Range;
+    readonly symbolTable: SymbolTable;
+    readonly memberTable: SymbolTable;
+    buildSymbolTable(): void;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -234,7 +281,6 @@ export declare class VariableExpression extends Expression {
     namespaceName: NamespacedVariableNameExpression;
     constructor(name: Identifier, namespaceName: NamespacedVariableNameExpression);
     readonly range: Range;
-    isCalled: boolean;
     getName(parseMode: ParseMode): string;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
@@ -256,12 +302,12 @@ export declare class NewExpression extends Expression {
     readonly newKeyword: Token;
     readonly call: CallExpression;
     constructor(newKeyword: Token, call: CallExpression);
+    readonly range: Range;
     /**
      * The name of the class to initialize (with optional namespace prefixed)
      */
     get className(): NamespacedVariableNameExpression;
     get namespaceName(): NamespacedVariableNameExpression;
-    readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -313,8 +359,10 @@ export declare class AnnotationExpression extends Expression {
     readonly atToken: Token;
     readonly nameToken: Token;
     constructor(atToken: Token, nameToken: Token);
+    get range(): Range;
+    cacheRange(): Range;
+    private _range;
     name: string;
-    range: Range;
     call: CallExpression;
     /**
      * Convert annotation arguments to JavaScript types
@@ -332,7 +380,7 @@ export declare class TernaryExpression extends Expression {
     readonly colonToken?: Token;
     readonly alternate?: Expression;
     constructor(test: Expression, questionMarkToken: Token, consequent?: Expression, colonToken?: Token, alternate?: Expression);
-    range: Range;
+    readonly range: Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -345,6 +393,74 @@ export declare class NullCoalescingExpression extends Expression {
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
+export declare class RegexLiteralExpression extends Expression {
+    tokens: {
+        regexLiteral: Token;
+    };
+    constructor(tokens: {
+        regexLiteral: Token;
+    });
+    readonly range: Range;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+}
+export declare class TypeExpression extends Expression {
+    private tokens;
+    namespaceName?: NamespacedVariableNameExpression;
+    constructor(tokens: {
+        type?: Token;
+    }, namespaceName?: NamespacedVariableNameExpression);
+    readonly range: Range;
+    private _type;
+    /**
+     * The this TypeExpression refers to
+     */
+    get type(): BscType;
+    /**
+     * Derive a BscType from the type token
+     * Can deal with multiple brackets to make multidimensional arrays, eg. float[][]
+     * Defaults to `DynamicType`
+     */
+    getType(parseMode?: ParseMode): DynamicType | BscType | import("../types/FloatType").FloatType | import("../types/IntegerType").IntegerType | import("../types/DoubleType").DoubleType | import("../types/LongIntegerType").LongIntegerType | import("../types/StringType").StringType | import("../types/BooleanType").BooleanType | import("../types/FunctionType").FunctionType | import("../types/InvalidType").InvalidType | VoidType;
+    /**
+     * Is this a valid, (eg. known) type?
+     */
+    isValidType(parseMode?: ParseMode): boolean;
+    /**
+     * Gives a human readable string that says the type
+     * @returns text to display to show the type
+     */
+    getText(): string;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+}
+export declare class ArrayTypeExpression extends TypeExpression {
+    innerTypes: TypeExpression[];
+    private bracketTokens;
+    namespaceName?: NamespacedVariableNameExpression;
+    constructor(innerTypes: TypeExpression[], // this is an array so that in the future when we support union types
+    bracketTokens: {
+        leftBracket?: Token;
+        rightBracket?: Token;
+    }, namespaceName?: NamespacedVariableNameExpression);
+    readonly range: Range;
+    private get defaultTypeExpression();
+    /**
+     * Derive a BscType from the type token
+     * Returns an array type with the inner types based on the inner type expressions
+     */
+    getType(parseMode?: ParseMode): ArrayType;
+    /**
+     * Is this a valid, (eg. known) type?
+     */
+    isValidType(parseMode?: ParseMode): boolean;
+    /**
+     * Gives a human readable string that says the type
+     * @returns text to display to show the type
+     */
+    getText(): string;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+}
 declare type ExpressionValue = string | number | boolean | Expression | ExpressionValue[] | {
     [key: string]: ExpressionValue;
 };