brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/parser/Expression.d.ts

@@ -1,252 +1,398 @@
-import type { Token, Identifier } from '../lexer';
-import type { Block, CommentStatement, FunctionStatement, LabelStatement } from './Statement';
-import type { Range } from 'vscode-languageserver';
+import type { Token, Identifier } from '../lexer/Token';
+import type { PrintSeparatorToken } from '../lexer/TokenKind';
+import type { Block } from './Statement';
+import type { Location } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
 import { ParseMode } from './Parser';
 import type { WalkOptions, WalkVisitor } from '../astUtils/visitors';
-import { InternalWalkMode } from '../astUtils/visitors';
-import type { TranspileResult, 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 { SymbolTable } from '../SymbolTable';
+import { AstNodeKind, Expression } from './AstNode';
+import { SourceNode } from 'source-map';
+import type { TranspileState } from './TranspileState';
+import { StringType } from '../types/StringType';
+import { TypedFunctionType } from '../types/TypedFunctionType';
+import { InvalidType } from '../types/InvalidType';
 import { FunctionType } from '../types/FunctionType';
 export declare type ExpressionVisitor = (expression: Expression, parent: Expression) => void;
-/** A BrightScript expression */
-export declare abstract class Expression {
-    /**
-     * The starting and ending location of the expression.
-     */
-    abstract range: Range;
-    abstract transpile(state: BrsTranspileState): TranspileResult;
-    /**
-     * When being considered by the walk visitor, this describes what type of element the current class is.
-     */
-    visitMode: InternalWalkMode;
-    abstract walk(visitor: WalkVisitor, options: WalkOptions): any;
-}
 export declare class BinaryExpression extends Expression {
-    left: Expression;
-    operator: Token;
-    right: Expression;
-    constructor(left: Expression, operator: Token, right: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    constructor(options: {
+        left: Expression;
+        operator: Token;
+        right: Expression;
+    });
+    readonly tokens: {
+        readonly operator: Token;
+    };
+    readonly left: Expression;
+    readonly right: Expression;
+    readonly kind = AstNodeKind.BinaryExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): BinaryExpression;
 }
 export declare class CallExpression extends Expression {
-    readonly callee: Expression;
-    readonly openingParen: Token;
-    readonly closingParen: Token;
-    readonly 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.
+     * 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
      */
-    readonly namespaceName: NamespacedVariableNameExpression;
     static MaximumArguments: number;
-    constructor(callee: Expression, 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.
-     */
-    namespaceName: NamespacedVariableNameExpression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState, nameOverride?: string): any[];
+    constructor(options: {
+        callee: Expression;
+        openingParen?: Token;
+        args?: Expression[];
+        closingParen?: Token;
+    });
+    readonly callee: Expression;
+    readonly args: Expression[];
+    readonly tokens: {
+        /**
+         * Can either be `(`, or `?(` for optional chaining - defaults to '('
+         */
+        readonly openingParen?: Token;
+        readonly closingParen?: Token;
+    };
+    readonly kind = AstNodeKind.CallExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState, nameOverride?: string): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): CallExpression;
 }
 export declare class FunctionExpression extends Expression implements TypedefProvider {
+    constructor(options: {
+        functionType?: Token;
+        leftParen?: Token;
+        parameters?: FunctionParameterExpression[];
+        rightParen?: Token;
+        as?: Token;
+        returnTypeExpression?: TypeExpression;
+        body: Block;
+        endFunctionType?: Token;
+    });
+    readonly kind = AstNodeKind.FunctionExpression;
     readonly parameters: FunctionParameterExpression[];
-    body: Block;
-    readonly functionType: Token | null;
-    end: Token;
-    readonly leftParen: Token;
-    readonly rightParen: Token;
-    readonly asToken?: Token;
-    readonly returnTypeToken?: Token;
-    /**
-     * 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, 
-    /**
-     * If this function is enclosed within another function, this will reference that parent function
-     */
-    parentFunction?: FunctionExpression, namespaceName?: NamespacedVariableNameExpression, parentSymbolTable?: SymbolTable);
-    readonly symbolTable: SymbolTable;
-    labelStatements: LabelStatement[];
-    /**
-     * The type this function returns
-     */
-    returnType: BscType;
-    /**
-     * 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
-     */
-    functionStatement?: FunctionStatement;
-    /**
-     * A list of all child functions declared directly within this function
-     */
-    childFunctionExpressions: FunctionExpression[];
+    readonly body: Block;
+    readonly returnTypeExpression?: TypeExpression;
+    readonly tokens: {
+        readonly functionType?: Token;
+        readonly endFunctionType?: Token;
+        readonly leftParen?: Token;
+        readonly rightParen?: Token;
+        readonly as?: Token;
+    };
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
     /**
      * 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[];
-    getTypedef(state: BrsTranspileState, name?: Identifier): any[];
+    get location(): Location;
+    transpile(state: BrsTranspileState, name?: Identifier, includeBody?: boolean): TranspileResult;
+    getTypedef(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getFunctionType(): FunctionType;
+    getType(options: GetTypeOptions): TypedFunctionType;
+    private get requiresReturnType();
+    clone(): FunctionExpression;
 }
 export declare class FunctionParameterExpression extends Expression {
-    name: Identifier;
-    type: BscType;
-    equalsToken?: Token;
-    defaultValue?: Expression;
-    asToken?: Token;
-    typeToken?: Token;
-    readonly namespaceName?: NamespacedVariableNameExpression;
-    constructor(name: Identifier, type: BscType, equalsToken?: Token, defaultValue?: Expression, asToken?: Token, typeToken?: Token, namespaceName?: NamespacedVariableNameExpression);
-    get range(): Range;
-    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;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
-    getNameParts(): string[];
-    getName(parseMode: ParseMode): string;
+    constructor(options: {
+        name: Identifier;
+        equals?: Token;
+        defaultValue?: Expression;
+        as?: Token;
+        typeExpression?: TypeExpression;
+    });
+    readonly kind = AstNodeKind.FunctionParameterExpression;
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly equals?: Token;
+        readonly as?: Token;
+    };
+    readonly defaultValue?: Expression;
+    readonly typeExpression?: TypeExpression;
+    getType(options: GetTypeOptions): BscType;
+    get location(): Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): FunctionParameterExpression;
 }
 export declare class DottedGetExpression extends Expression {
+    constructor(options: {
+        obj: Expression;
+        name: Identifier;
+        /**
+         * Can either be `.`, or `?.` for optional chaining - defaults in transpile to '.'
+         */
+        dot?: Token;
+    });
+    readonly tokens: {
+        readonly name: Identifier;
+        readonly dot?: Token;
+    };
     readonly obj: Expression;
-    readonly name: Identifier;
-    readonly dot: Token;
-    constructor(obj: Expression, name: Identifier, dot: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    readonly kind = AstNodeKind.DottedGetExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
+    getTypedef(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    getName(parseMode: ParseMode): string;
+    get leadingTrivia(): Token[];
+    clone(): DottedGetExpression;
 }
 export declare class XmlAttributeGetExpression extends Expression {
+    constructor(options: {
+        obj: Expression;
+        /**
+         * Can either be `@`, or `?@` for optional chaining - defaults to '@'
+         */
+        at?: Token;
+        name: Identifier;
+    });
+    readonly kind = AstNodeKind.XmlAttributeGetExpression;
+    readonly tokens: {
+        name: Identifier;
+        at?: Token;
+    };
     readonly obj: Expression;
-    readonly name: Identifier;
-    readonly at: Token;
-    constructor(obj: Expression, name: Identifier, at: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): XmlAttributeGetExpression;
 }
 export declare class IndexedGetExpression extends Expression {
+    constructor(options: {
+        obj: Expression;
+        indexes: Expression[];
+        /**
+         * 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 kind = AstNodeKind.IndexedGetExpression;
     readonly obj: Expression;
-    readonly index: Expression;
-    readonly openingSquare: Token;
-    readonly closingSquare: Token;
-    constructor(obj: Expression, index: Expression, openingSquare: Token, closingSquare: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    readonly indexes: Expression[];
+    readonly tokens: {
+        /**
+         * Can either be `[` or `?[`. If `?.[` is used, this will be `[` and `optionalChainingToken` will be `?.` - defaults to '[' in transpile
+         */
+        readonly openingSquare?: Token;
+        readonly closingSquare?: Token;
+        readonly questionDot?: Token;
+    };
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): IndexedGetExpression;
 }
 export declare class GroupingExpression extends Expression {
+    constructor(options: {
+        leftParen?: Token;
+        rightParen?: Token;
+        expression: Expression;
+    });
     readonly tokens: {
-        left: Token;
-        right: Token;
+        readonly leftParen?: Token;
+        readonly rightParen?: Token;
     };
-    expression: Expression;
-    constructor(tokens: {
-        left: Token;
-        right: Token;
-    }, expression: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    readonly expression: Expression;
+    readonly kind = AstNodeKind.GroupingExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): GroupingExpression;
 }
 export declare class LiteralExpression extends Expression {
-    token: Token;
-    constructor(token: Token);
-    get range(): Range;
-    /**
-     * The (data) type of this expression
-     */
-    type: BscType;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    constructor(options: {
+        value: Token;
+    });
+    readonly tokens: {
+        readonly value: Token;
+    };
+    readonly kind = AstNodeKind.LiteralExpression;
+    get location(): Location;
+    getType(options?: GetTypeOptions): DynamicType | import("..").ObjectType | VoidType | InvalidType | import("..").BooleanType | import("..").DoubleType | import("..").FloatType | FunctionType | import("..").IntegerType | import("..").LongIntegerType | StringType;
+    transpile(state: BrsTranspileState): TranspileResult[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): LiteralExpression;
+}
+/**
+ * The print statement can have a mix of expressions and separators. These separators represent actual output to the screen,
+ * so this AstNode represents those separators (comma, semicolon, and whitespace)
+ */
+export declare class PrintSeparatorExpression extends Expression {
+    constructor(options: {
+        separator: PrintSeparatorToken;
+    });
+    readonly tokens: {
+        readonly separator: PrintSeparatorToken;
+    };
+    readonly kind = AstNodeKind.PrintSeparatorExpression;
+    location: Location;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): PrintSeparatorExpression;
 }
 /**
  * This is a special expression only used within template strings. It exists so we can prevent producing lots of empty strings
  * during template string transpile by identifying these expressions explicitly and skipping the bslib_toString around them
  */
 export declare class EscapedCharCodeLiteralExpression extends Expression {
-    readonly token: Token & {
-        charCode: number;
-    };
-    constructor(token: Token & {
-        charCode: number;
+    constructor(options: {
+        value: Token & {
+            charCode: number;
+        };
     });
-    readonly range: Range;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    readonly kind = AstNodeKind.EscapedCharCodeLiteralExpression;
+    readonly tokens: {
+        readonly value: Token & {
+            charCode: number;
+        };
+    };
+    readonly location: Location;
+    transpile(state: BrsTranspileState): SourceNode[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): EscapedCharCodeLiteralExpression;
 }
 export declare class ArrayLiteralExpression extends Expression {
-    readonly elements: Array<Expression | CommentStatement>;
-    readonly open: Token;
-    readonly close: Token;
-    readonly hasSpread: boolean;
-    constructor(elements: Array<Expression | CommentStatement>, open: Token, close: Token, hasSpread?: boolean);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    constructor(options: {
+        elements: Array<Expression>;
+        open?: Token;
+        close?: Token;
+    });
+    readonly elements: Array<Expression>;
+    readonly tokens: {
+        readonly open?: Token;
+        readonly close?: Token;
+    };
+    readonly kind = AstNodeKind.ArrayLiteralExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): ArrayLiteralExpression;
 }
 export declare class AAMemberExpression extends Expression {
-    keyToken: Token;
-    colonToken: Token;
-    /** The expression evaluated to determine the member's initial value. */
-    value: Expression;
-    constructor(keyToken: Token, colonToken: Token, 
+    constructor(options: {
+        key: Token;
+        colon?: Token;
+        /** The expression evaluated to determine the member's initial value. */
+        value: Expression;
+        comma?: Token;
+    });
+    readonly kind = AstNodeKind.AAMemberExpression;
+    readonly location: Location | undefined;
+    readonly tokens: {
+        readonly key: Token;
+        readonly colon?: Token;
+        readonly comma?: Token;
+    };
     /** The expression evaluated to determine the member's initial value. */
-    value: Expression);
-    range: Range;
+    readonly value: Expression;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): AAMemberExpression;
 }
 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 range: Range;
-    transpile(state: BrsTranspileState): any[];
+    constructor(options: {
+        elements: Array<AAMemberExpression>;
+        open?: Token;
+        close?: Token;
+    });
+    readonly elements: Array<AAMemberExpression>;
+    readonly tokens: {
+        readonly open?: Token;
+        readonly close?: Token;
+    };
+    readonly kind = AstNodeKind.AALiteralExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    get endTrivia(): Token[];
+    clone(): AALiteralExpression;
 }
 export declare class UnaryExpression extends Expression {
-    operator: Token;
-    right: Expression;
-    constructor(operator: Token, right: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
+    constructor(options: {
+        operator: Token;
+        right: Expression;
+    });
+    readonly kind = AstNodeKind.UnaryExpression;
+    readonly location: Location | undefined;
+    readonly tokens: {
+        readonly operator: Token;
+    };
+    readonly right: Expression;
+    transpile(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): UnaryExpression;
 }
 export declare class VariableExpression extends Expression {
-    name: Identifier;
-    namespaceName: NamespacedVariableNameExpression;
-    constructor(name: Identifier, namespaceName: NamespacedVariableNameExpression);
-    readonly range: Range;
-    isCalled: boolean;
-    getName(parseMode: ParseMode): string;
-    transpile(state: BrsTranspileState): any[];
+    constructor(options: {
+        name: Identifier;
+    });
+    readonly tokens: {
+        readonly name: Identifier;
+    };
+    readonly kind = AstNodeKind.VariableExpression;
+    readonly location: Location;
+    getName(parseMode?: ParseMode): string;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): VariableExpression;
 }
 export declare class SourceLiteralExpression extends Expression {
-    readonly token: Token;
-    constructor(token: Token);
-    readonly range: Range;
+    constructor(options: {
+        value: Token;
+    });
+    readonly location: Location;
+    readonly kind = AstNodeKind.SourceLiteralExpression;
+    readonly tokens: {
+        readonly value: Token;
+    };
+    /**
+     * Find the index of the function in its parent
+     */
+    private findFunctionIndex;
     private getFunctionName;
-    transpile(state: BrsTranspileState): import("source-map").SourceNode[];
+    /**
+     * 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;
+    get leadingTrivia(): Token[];
+    clone(): SourceLiteralExpression;
 }
 /**
  * This expression transpiles and acts exactly like a CallExpression,
@@ -254,99 +400,285 @@ export declare class SourceLiteralExpression extends Expression {
  * do more type checking.
  */
 export declare class NewExpression extends Expression {
-    readonly newKeyword: Token;
+    constructor(options: {
+        new?: Token;
+        call: CallExpression;
+    });
+    readonly kind = AstNodeKind.NewExpression;
+    readonly location: Location | undefined;
+    readonly tokens: {
+        readonly new?: Token;
+    };
     readonly call: CallExpression;
-    constructor(newKeyword: Token, call: CallExpression);
     /**
      * The name of the class to initialize (with optional namespace prefixed)
      */
-    get className(): NamespacedVariableNameExpression;
-    get namespaceName(): NamespacedVariableNameExpression;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    get className(): DottedGetExpression | VariableExpression;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): NewExpression;
 }
 export declare class CallfuncExpression extends Expression {
+    constructor(options: {
+        callee: Expression;
+        operator?: Token;
+        methodName: Identifier;
+        openingParen?: Token;
+        args?: Expression[];
+        closingParen?: Token;
+    });
     readonly callee: Expression;
-    readonly operator: Token;
-    readonly methodName: Identifier;
-    readonly openingParen: Token;
     readonly args: Expression[];
-    readonly closingParen: Token;
-    constructor(callee: Expression, operator: Token, methodName: Identifier, openingParen: Token, args: Expression[], closingParen: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly tokens: {
+        readonly operator: Token;
+        readonly methodName: Identifier;
+        readonly openingParen?: Token;
+        readonly closingParen?: Token;
+    };
+    readonly kind = AstNodeKind.CallfuncExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get leadingTrivia(): Token[];
+    clone(): CallfuncExpression;
 }
 /**
  * Since template strings can contain newlines, we need to concatenate multiple strings together with chr() calls.
  * This is a single expression that represents the string contatenation of all parts of a single quasi.
  */
 export declare class TemplateStringQuasiExpression extends Expression {
+    constructor(options: {
+        expressions: Array<LiteralExpression | EscapedCharCodeLiteralExpression>;
+    });
     readonly expressions: Array<LiteralExpression | EscapedCharCodeLiteralExpression>;
-    constructor(expressions: Array<LiteralExpression | EscapedCharCodeLiteralExpression>);
-    readonly range: Range;
-    transpile(state: BrsTranspileState, skipEmptyStrings?: boolean): any[];
+    readonly kind = AstNodeKind.TemplateStringQuasiExpression;
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState, skipEmptyStrings?: boolean): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): TemplateStringQuasiExpression;
 }
 export declare class TemplateStringExpression extends Expression {
-    readonly openingBacktick: Token;
+    constructor(options: {
+        openingBacktick?: Token;
+        quasis: TemplateStringQuasiExpression[];
+        expressions: Expression[];
+        closingBacktick?: Token;
+    });
+    readonly kind = AstNodeKind.TemplateStringExpression;
+    readonly tokens: {
+        readonly openingBacktick?: Token;
+        readonly closingBacktick?: Token;
+    };
     readonly quasis: TemplateStringQuasiExpression[];
     readonly expressions: Expression[];
-    readonly closingBacktick: Token;
-    constructor(openingBacktick: Token, quasis: TemplateStringQuasiExpression[], expressions: Expression[], closingBacktick: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly location: Location | undefined;
+    getType(options: GetTypeOptions): StringType;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): TemplateStringExpression;
 }
 export declare class TaggedTemplateStringExpression extends Expression {
-    readonly tagName: Identifier;
-    readonly openingBacktick: Token;
+    constructor(options: {
+        tagName: Identifier;
+        openingBacktick?: Token;
+        quasis: TemplateStringQuasiExpression[];
+        expressions: Expression[];
+        closingBacktick?: Token;
+    });
+    readonly kind = AstNodeKind.TaggedTemplateStringExpression;
+    readonly tokens: {
+        readonly tagName: Identifier;
+        readonly openingBacktick?: Token;
+        readonly closingBacktick?: Token;
+    };
     readonly quasis: TemplateStringQuasiExpression[];
     readonly expressions: Expression[];
-    readonly closingBacktick: Token;
-    constructor(tagName: Identifier, openingBacktick: Token, quasis: TemplateStringQuasiExpression[], expressions: Expression[], closingBacktick: Token);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly location: Location | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): TaggedTemplateStringExpression;
 }
 export declare class AnnotationExpression extends Expression {
-    readonly atToken: Token;
-    readonly nameToken: Token;
-    constructor(atToken: Token, nameToken: Token);
-    name: string;
-    range: Range;
+    constructor(options: {
+        at?: Token;
+        name: Token;
+        call?: CallExpression;
+    });
+    readonly kind = AstNodeKind.AnnotationExpression;
+    readonly tokens: {
+        readonly at: Token;
+        readonly name: Token;
+    };
+    get location(): Location | undefined;
+    readonly name: string;
     call: CallExpression;
     /**
      * Convert annotation arguments to JavaScript types
      * @param strict If false, keep Expression objects not corresponding to JS types
      */
     getArguments(strict?: boolean): ExpressionValue[];
-    transpile(state: BrsTranspileState): any[];
+    get leadingTrivia(): Token[];
+    transpile(state: BrsTranspileState): (string | SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getTypedef(state: BrsTranspileState): any[];
+    getTypedef(state: BrsTranspileState): (string | SourceNode | TranspileResult)[];
+    clone(): AnnotationExpression;
 }
 export declare class TernaryExpression extends Expression {
+    constructor(options: {
+        test: Expression;
+        questionMark?: Token;
+        consequent?: Expression;
+        colon?: Token;
+        alternate?: Expression;
+    });
+    readonly kind = AstNodeKind.TernaryExpression;
+    readonly location: Location | undefined;
+    readonly tokens: {
+        readonly questionMark?: Token;
+        readonly colon?: Token;
+    };
     readonly test: Expression;
-    readonly questionMarkToken: Token;
     readonly consequent?: Expression;
-    readonly colonToken?: Token;
     readonly alternate?: Expression;
-    constructor(test: Expression, questionMarkToken: Token, consequent?: Expression, colonToken?: Token, alternate?: Expression);
-    range: Range;
-    transpile(state: BrsTranspileState): any[];
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): TernaryExpression;
 }
 export declare class NullCoalescingExpression extends Expression {
-    consequent: Expression;
-    questionQuestionToken: Token;
-    alternate: Expression;
-    constructor(consequent: Expression, questionQuestionToken: Token, alternate: Expression);
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    constructor(options: {
+        consequent: Expression;
+        questionQuestion?: Token;
+        alternate: Expression;
+    });
+    readonly kind = AstNodeKind.NullCoalescingExpression;
+    readonly location: Location | undefined;
+    readonly tokens: {
+        readonly questionQuestion?: Token;
+    };
+    readonly consequent: Expression;
+    readonly alternate: Expression;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get leadingTrivia(): Token[];
+    clone(): NullCoalescingExpression;
+}
+export declare class RegexLiteralExpression extends Expression {
+    constructor(options: {
+        regexLiteral: Token;
+    });
+    readonly kind = AstNodeKind.RegexLiteralExpression;
+    readonly tokens: {
+        readonly regexLiteral: Token;
+    };
+    get location(): Location;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    clone(): RegexLiteralExpression;
+    get leadingTrivia(): Token[];
 }
 declare type ExpressionValue = string | number | boolean | Expression | ExpressionValue[] | {
     [key: string]: ExpressionValue;
-};
+} | null;
+export declare class TypeExpression extends Expression implements TypedefProvider {
+    constructor(options: {
+        /**
+         * The standard AST expression that represents the type for this TypeExpression.
+         */
+        expression: Expression;
+    });
+    readonly kind = AstNodeKind.TypeExpression;
+    /**
+     * The standard AST expression that represents the type for this TypeExpression.
+     */
+    readonly expression: Expression;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    getTypedef(state: TranspileState): TranspileResult;
+    getName(parseMode?: ParseMode): string;
+    getNameParts(): string[];
+    clone(): TypeExpression;
+}
+export declare class TypecastExpression extends Expression {
+    constructor(options: {
+        obj: Expression;
+        as?: Token;
+        typeExpression?: TypeExpression;
+    });
+    readonly kind = AstNodeKind.TypecastExpression;
+    readonly obj: Expression;
+    readonly tokens: {
+        readonly as?: Token;
+    };
+    typeExpression?: TypeExpression;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    clone(): TypecastExpression;
+}
+export declare class TypedArrayExpression extends Expression {
+    constructor(options: {
+        innerType: Expression;
+        leftBracket?: Token;
+        rightBracket?: Token;
+    });
+    readonly tokens: {
+        readonly leftBracket?: Token;
+        readonly rightBracket?: Token;
+    };
+    readonly innerType: Expression;
+    readonly kind = AstNodeKind.TypedArrayExpression;
+    readonly location: Location;
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    clone(): TypedArrayExpression;
+}
+export declare class InlineInterfaceExpression extends Expression {
+    constructor(options: {
+        open?: Token;
+        members: InlineInterfaceMemberExpression[];
+        close?: Token;
+    });
+    readonly tokens: {
+        readonly open?: Token;
+        readonly close?: Token;
+    };
+    readonly members: InlineInterfaceMemberExpression[];
+    readonly kind = AstNodeKind.InlineInterfaceExpression;
+    readonly location: Location;
+    get leadingTrivia(): Token[];
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    clone(): InlineInterfaceExpression;
+}
+export declare class InlineInterfaceMemberExpression extends Expression {
+    constructor(options: {
+        optional?: Token;
+        name: Token;
+        as?: Token;
+        typeExpression?: TypeExpression;
+    });
+    readonly kind = AstNodeKind.InlineInterfaceMemberExpression;
+    readonly tokens: {
+        readonly optional?: Token;
+        readonly name: Token;
+        readonly as?: Token;
+    };
+    readonly typeExpression?: TypeExpression;
+    readonly location: Location;
+    get leadingTrivia(): Token[];
+    transpile(state: BrsTranspileState): TranspileResult;
+    walk(visitor: WalkVisitor, options: WalkOptions): void;
+    getType(options: GetTypeOptions): BscType;
+    get isOptional(): boolean;
+    clone(): InlineInterfaceMemberExpression;
+}
 export {};