brighterscript 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/parser/Expression.js

@@ -1,35 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayTypeExpression = exports.TypeExpression = exports.RegexLiteralExpression = exports.NullCoalescingExpression = exports.TernaryExpression = exports.AnnotationExpression = exports.TaggedTemplateStringExpression = exports.TemplateStringExpression = exports.TemplateStringQuasiExpression = exports.CallfuncExpression = exports.NewExpression = exports.SourceLiteralExpression = exports.VariableExpression = exports.UnaryExpression = exports.AALiteralExpression = exports.AAMemberExpression = exports.ArrayLiteralExpression = exports.EscapedCharCodeLiteralExpression = exports.LiteralExpression = exports.GroupingExpression = exports.IndexedGetExpression = exports.XmlAttributeGetExpression = exports.DottedGetExpression = exports.NamespacedVariableNameExpression = exports.FunctionParameterExpression = exports.FunctionExpression = exports.CallExpression = exports.BinaryExpression = exports.Expression = void 0;
+exports.TypedArrayExpression = exports.TypeCastExpression = exports.TypeExpression = exports.RegexLiteralExpression = exports.NullCoalescingExpression = exports.TernaryExpression = exports.AnnotationExpression = exports.TaggedTemplateStringExpression = exports.TemplateStringExpression = exports.TemplateStringQuasiExpression = exports.CallfuncExpression = exports.NewExpression = exports.SourceLiteralExpression = exports.VariableExpression = exports.UnaryExpression = exports.AALiteralExpression = exports.AAMemberExpression = exports.ArrayLiteralExpression = exports.EscapedCharCodeLiteralExpression = exports.LiteralExpression = exports.GroupingExpression = exports.IndexedGetExpression = exports.XmlAttributeGetExpression = exports.DottedGetExpression = exports.FunctionParameterExpression = exports.FunctionExpression = exports.CallExpression = exports.BinaryExpression = void 0;
 const TokenKind_1 = require("../lexer/TokenKind");
 const util_1 = require("../util");
 const Parser_1 = require("./Parser");
 const fileUrl = require("file-url");
 const visitors_1 = require("../astUtils/visitors");
+const visitors_2 = require("../astUtils/visitors");
 const reflection_1 = require("../astUtils/reflection");
-const VoidType_1 = require("../types/VoidType");
-const DynamicType_1 = require("../types/DynamicType");
+const interfaces_1 = require("../interfaces");
 const SymbolTable_1 = require("../SymbolTable");
 const TypedFunctionType_1 = require("../types/TypedFunctionType");
-const ObjectType_1 = require("../types/ObjectType");
-const ArrayType_1 = require("../types/ArrayType");
-/** A BrightScript expression */
-class Expression {
-    constructor() {
-        /**
-         * When being considered by the walk visitor, this describes what type of element the current class is.
-         */
-        this.visitMode = visitors_1.InternalWalkMode.visitExpressions;
-    }
-}
-exports.Expression = Expression;
-class BinaryExpression extends Expression {
+const AstNode_1 = require("./AstNode");
+const SymbolTable_2 = require("../SymbolTable");
+const source_map_1 = require("source-map");
+const StringType_1 = require("../types/StringType");
+const DynamicType_1 = require("../types/DynamicType");
+const VoidType_1 = require("../types/VoidType");
+const ReferenceType_1 = require("../types/ReferenceType");
+const UnionType_1 = require("../types/UnionType");
+const types_1 = require("../types");
+const AssociativeArrayType_1 = require("../types/AssociativeArrayType");
+const creators_1 = require("../astUtils/creators");
+class BinaryExpression extends AstNode_1.Expression {
     constructor(left, operator, right) {
         super();
         this.left = left;
         this.operator = operator;
         this.right = right;
-        this.range = util_1.default.createBoundingRange(this.left, this.right);
+        this.kind = AstNode_1.AstNodeKind.BinaryExpression;
+        this.range = util_1.default.createRangeFromPositions(this.left.range.start, this.right.range.end);
     }
     transpile(state) {
         return [
@@ -41,30 +41,41 @@ class BinaryExpression extends Expression {
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'left', visitor, options);
-            (0, visitors_1.walk)(this, 'right', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'left', visitor, options);
+            (0, visitors_2.walk)(this, 'right', visitor, options);
+        }
+    }
+    getType(options) {
+        const operatorKind = this.operator.kind;
+        if (options.flags & SymbolTable_1.SymbolTypeFlag.typetime) {
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (operatorKind) {
+                case TokenKind_1.TokenKind.Or:
+                    return new UnionType_1.UnionType([this.left.getType(options), this.right.getType(options)]);
+                //TODO: Intersection Types?, eg. case TokenKind.And:
+            }
+        }
+        else if (options.flags & SymbolTable_1.SymbolTypeFlag.runtime) {
+            return util_1.default.binaryOperatorResultType(this.left.getType(options), this.operator, this.right.getType(options));
         }
+        return DynamicType_1.DynamicType.instance;
     }
 }
 exports.BinaryExpression = BinaryExpression;
-class CallExpression extends Expression {
+class CallExpression extends AstNode_1.Expression {
     constructor(callee, 
     /**
      * Can either be `(`, or `?(` for optional chaining
      */
-    openingParen, closingParen, args, 
-    /**
-     * 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) {
+    openingParen, closingParen, args, unused) {
         super();
         this.callee = callee;
         this.openingParen = openingParen;
         this.closingParen = closingParen;
         this.args = args;
-        this.namespaceName = namespaceName;
-        this.range = util_1.default.createBoundingRange(this.callee, this.closingParen);
+        this.kind = AstNode_1.AstNodeKind.CallExpression;
+        this.range = util_1.default.createBoundingRange(this.callee, this.openingParen, ...args, this.closingParen);
     }
     transpile(state, nameOverride) {
         let result = [];
@@ -84,24 +95,39 @@ class CallExpression extends Expression {
             let arg = this.args[i];
             result.push(...arg.transpile(state));
         }
-        result.push(state.transpileToken(this.closingParen));
+        if (this.closingParen) {
+            result.push(state.transpileToken(this.closingParen));
+        }
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'callee', visitor, options);
-            (0, visitors_1.walkArray)(this.args, visitor, options, this);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'callee', visitor, options);
+            (0, visitors_2.walkArray)(this.args, visitor, options, this);
         }
     }
+    getType(options) {
+        var _a, _b;
+        const calleeType = this.callee.getType(options);
+        if (options.ignoreCall) {
+            return calleeType;
+        }
+        if ((0, reflection_1.isNewExpression)(this.parent)) {
+            return calleeType;
+        }
+        if ((0, reflection_1.isCallableType)(calleeType) && (!(0, reflection_1.isReferenceType)(calleeType.returnType) || ((_a = calleeType.returnType) === null || _a === void 0 ? void 0 : _a.isResolvable()))) {
+            return calleeType.returnType;
+        }
+        if (!(0, reflection_1.isReferenceType)(calleeType) && ((_b = calleeType.returnType) === null || _b === void 0 ? void 0 : _b.isResolvable())) {
+            return calleeType.returnType;
+        }
+        return new ReferenceType_1.TypePropertyReferenceType(calleeType, 'returnType');
+    }
 }
 exports.CallExpression = CallExpression;
-CallExpression.MaximumArguments = util_1.MAX_PARAM_COUNT;
-class FunctionExpression extends Expression {
-    constructor(parameters, body, functionType, end, leftParen, rightParen, asToken, returnType, 
-    /**
-     * If this function is enclosed within another function, this will reference that parent function
-     */
-    parentFunction, namespaceName, parentSymbolTable) {
+CallExpression.MaximumArguments = 32;
+class FunctionExpression extends AstNode_1.Expression {
+    constructor(parameters, body, functionType, end, leftParen, rightParen, asToken, returnTypeExpression) {
         super();
         this.parameters = parameters;
         this.body = body;
@@ -110,60 +136,29 @@ class FunctionExpression extends Expression {
         this.leftParen = leftParen;
         this.rightParen = rightParen;
         this.asToken = asToken;
-        this.returnType = returnType;
-        this.parentFunction = parentFunction;
-        this.namespaceName = namespaceName;
-        this.parentSymbolTable = parentSymbolTable;
-        this.labelStatements = [];
+        this.returnTypeExpression = returnTypeExpression;
+        this.kind = AstNode_1.AstNodeKind.FunctionExpression;
         /**
          * The list of function calls that are declared within this function scope. This excludes CallExpressions
          * declared in child functions
          */
         this.callExpressions = [];
-        /**
-         * A list of all child functions declared directly within this function
-         */
-        this.childFunctionExpressions = [];
-        if (this.returnType) {
-            this._returnType = this.returnType.type;
+        //if there's a body, and it doesn't have a SymbolTable, assign one
+        if (this.body && !this.body.symbolTable) {
+            this.body.symbolTable = new SymbolTable_2.SymbolTable(`Function Body`);
         }
-        else if (this.functionType.text.toLowerCase() === 'sub') {
-            this._returnType = new VoidType_1.VoidType();
-        }
-        else {
-            this._returnType = new DynamicType_1.DynamicType();
-        }
-        this.symbolTable = new SymbolTable_1.SymbolTable(parentSymbolTable);
-        for (let param of parameters) {
-            this.symbolTable.addSymbol(param.name.text, param.name.range, param.getType());
-        }
-    }
-    get range() {
-        return this.cacheRange();
+        this.symbolTable = new SymbolTable_2.SymbolTable('FunctionExpression', () => { var _a; return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolTable(); });
     }
-    /**
-     * The range of the function
-     */
-    cacheRange() {
-        var _a;
-        if (!this._range) {
-            this._range = util_1.default.createBoundingRange(this.functionType, this.leftParen, ...((_a = this.parameters) !== null && _a !== void 0 ? _a : []), this.rightParen, this.asToken, this.returnType, this.body, this.end);
-        }
-        return this._range;
+    getLeadingTrivia() {
+        var _a, _b;
+        return (_b = (_a = this.functionType) === null || _a === void 0 ? void 0 : _a.leadingTrivia) !== null && _b !== void 0 ? _b : [];
     }
     /**
-     * The type this function returns
+     * 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'
      */
-    getReturnType() {
-        return this._returnType;
-    }
-    /**
-    * 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() {
-        var _a;
-        return util_1.default.createBoundingRange(this.functionType, this.leftParen, ...((_a = this.parameters) !== null && _a !== void 0 ? _a : []), this.rightParen, this.asToken, this.returnType);
+    get range() {
+        return util_1.default.createBoundingRange(this.functionType, this.leftParen, ...this.parameters, this.rightParen, this.asToken, this.returnTypeExpression, this.end);
     }
     transpile(state, name, includeBody = true) {
         let results = [];
@@ -188,12 +183,12 @@ class FunctionExpression extends Expression {
         //right paren
         results.push(state.transpileToken(this.rightParen));
         //as [Type]
-        if (this.asToken) {
+        if (this.asToken && !state.options.removeParameterTypes && this.returnTypeExpression) {
             results.push(' ', 
             //as
             state.transpileToken(this.asToken), ' ', 
             //return type
-            state.sourceNode(this.returnType, this.getReturnType().toTypeString(state.typeContext)));
+            ...this.returnTypeExpression.transpile(state));
         }
         if (includeBody) {
             state.lineage.unshift(this);
@@ -201,52 +196,107 @@ class FunctionExpression extends Expression {
             state.lineage.shift();
             results.push(...body);
         }
-        if (this.end) {
-            results.push('\n');
-            //'end sub'|'end function'
-            results.push(state.indent(), state.transpileToken(this.end));
-        }
+        results.push('\n');
+        //'end sub'|'end function'
+        results.push(state.indent(), state.transpileToken(this.end));
         return results;
     }
-    getTypedef(state, name) {
-        return this.transpile(state, name, false);
+    getTypedef(state) {
+        var _a, _b, _c, _d, _e;
+        let results = [
+            new source_map_1.SourceNode(1, 0, null, [
+                //'function'|'sub'
+                (_a = this.functionType) === null || _a === void 0 ? void 0 : _a.text,
+                //functionName?
+                ...((0, reflection_1.isFunctionStatement)(this.parent) || (0, reflection_1.isMethodStatement)(this.parent) ? [' ', (_c = (_b = this.parent.name) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : ''] : []),
+                //leftParen
+                '(',
+                //parameters
+                ...((_e = (_d = this.parameters) === null || _d === void 0 ? void 0 : _d.map((param, i) => ([
+                    //separating comma
+                    i > 0 ? ', ' : '',
+                    ...param.getTypedef(state)
+                ]))) !== null && _e !== void 0 ? _e : []),
+                //right paren
+                ')',
+                //as <ReturnType>
+                ...(this.asToken ? [
+                    ' as ',
+                    ...this.returnTypeExpression.getTypedef(state)
+                ] : []),
+                '\n',
+                state.indent(),
+                //'end sub'|'end function'
+                this.end.text
+            ])
+        ];
+        return results;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walkArray)(this.parameters, visitor, options, this);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.parameters, visitor, options, this);
+            (0, visitors_2.walk)(this, 'returnTypeExpression', visitor, options);
             //This is the core of full-program walking...it allows us to step into sub functions
-            if (options.walkMode & visitors_1.InternalWalkMode.recurseChildFunctions) {
-                (0, visitors_1.walk)(this, 'returnType', visitor, options);
-                (0, visitors_1.walk)(this, 'body', visitor, options);
+            if (options.walkMode & visitors_2.InternalWalkMode.recurseChildFunctions) {
+                (0, visitors_2.walk)(this, 'body', visitor, options);
             }
         }
     }
-    getFunctionType() {
-        let functionType = new TypedFunctionType_1.TypedFunctionType(this.getReturnType());
-        functionType.isSub = this.functionType.text === 'sub';
+    getType(options) {
+        var _a, _b, _c;
+        //if there's a defined return type, use that
+        let returnType = (_a = this.returnTypeExpression) === null || _a === void 0 ? void 0 : _a.getType(Object.assign(Object.assign({}, options), { typeChain: undefined }));
+        const isSub = this.functionType.kind === TokenKind_1.TokenKind.Sub;
+        //if we don't have a return type and this is a sub, set the return type to `void`. else use `dynamic`
+        if (!returnType) {
+            returnType = isSub ? VoidType_1.VoidType.instance : DynamicType_1.DynamicType.instance;
+        }
+        const resultType = new TypedFunctionType_1.TypedFunctionType(returnType);
+        resultType.isSub = isSub;
         for (let param of this.parameters) {
-            functionType.addParameter(param.name.text, param.getType(), param.isOptional);
+            resultType.addParameter(param.name.text, param.getType(Object.assign(Object.assign({}, options), { typeChain: undefined })), !!param.defaultValue);
+        }
+        // Figure out this function's name if we can
+        let funcName = '';
+        if ((0, reflection_1.isMethodStatement)(this.parent) || (0, reflection_1.isInterfaceMethodStatement)(this.parent)) {
+            funcName = this.parent.getName(Parser_1.ParseMode.BrighterScript);
+            if (options.typeChain) {
+                // Get the typechain info from the parent class
+                (_b = this.parent.parent) === null || _b === void 0 ? void 0 : _b.getType(options);
+            }
+        }
+        else if ((0, reflection_1.isFunctionStatement)(this.parent)) {
+            funcName = this.parent.getName(Parser_1.ParseMode.BrighterScript);
+        }
+        if (funcName) {
+            resultType.setName(funcName);
         }
-        return functionType;
+        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry(funcName, resultType, options.data, this.range));
+        return resultType;
     }
 }
 exports.FunctionExpression = FunctionExpression;
-class FunctionParameterExpression extends Expression {
-    constructor(name, typeInContext, equalsToken, defaultValue, asToken, type, namespaceName) {
+class FunctionParameterExpression extends AstNode_1.Expression {
+    constructor(name, equalToken, defaultValue, asToken, typeExpression) {
         super();
         this.name = name;
-        this.typeInContext = typeInContext;
-        this.equalsToken = equalsToken;
+        this.equalToken = equalToken;
         this.defaultValue = defaultValue;
         this.asToken = asToken;
-        this.type = type;
-        this.namespaceName = namespaceName;
-        this.range = util_1.default.createBoundingRange(this.name, this.equalsToken, this.defaultValue, this.asToken, this.type);
+        this.typeExpression = typeExpression;
+        this.kind = AstNode_1.AstNodeKind.FunctionParameterExpression;
     }
-    getType() {
-        return this.typeInContext;
+    getType(options) {
+        var _a, _b, _c, _d, _e;
+        const paramType = (_d = (_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.getType(Object.assign(Object.assign({}, options), { flags: SymbolTable_1.SymbolTypeFlag.typetime, typeChain: undefined }))) !== null && _b !== void 0 ? _b : (_c = this.defaultValue) === null || _c === void 0 ? void 0 : _c.getType(Object.assign(Object.assign({}, options), { flags: SymbolTable_1.SymbolTypeFlag.runtime, typeChain: undefined }))) !== null && _d !== void 0 ? _d : DynamicType_1.DynamicType.instance;
+        (_e = options.typeChain) === null || _e === void 0 ? void 0 : _e.push(new interfaces_1.TypeChainEntry(this.name.text, paramType, options.data, this.range));
+        return paramType;
+    }
+    get range() {
+        return util_1.default.createBoundingRange(this.name, this.asToken, this.typeExpression, this.defaultValue);
     }
     transpile(state) {
+        var _a, _b;
         let result = [
             //name
             state.transpileToken(this.name)
@@ -257,70 +307,41 @@ class FunctionParameterExpression extends Expression {
             result.push(this.defaultValue.transpile(state));
         }
         //type declaration
-        if (this.asToken) {
+        if (this.asToken && !state.options.removeParameterTypes) {
             result.push(' ');
             result.push(state.transpileToken(this.asToken));
             result.push(' ');
-            result.push(state.sourceNode(this.type, this.getType().toTypeString(state.typeContext)));
+            result.push(...((_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.transpile(state)) !== null && _b !== void 0 ? _b : []));
         }
         return result;
     }
-    walk(visitor, options) {
-        // eslint-disable-next-line no-bitwise
-        if (this.defaultValue && options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'defaultValue', visitor, options);
-            (0, visitors_1.walk)(this, 'type', visitor, options);
-        }
-    }
-    get isOptional() {
-        return !!this.defaultValue;
-    }
-}
-exports.FunctionParameterExpression = FunctionParameterExpression;
-class NamespacedVariableNameExpression extends Expression {
-    constructor(
-    //if this is a `DottedGetExpression`, it must be comprised only of `VariableExpression`s
-    expression) {
-        super();
-        this.expression = expression;
-        this.range = expression.range;
-    }
-    transpile(state) {
+    getTypedef(state) {
+        var _a, _b;
         return [
-            state.sourceNode(this, this.getName(Parser_1.ParseMode.BrightScript))
+            //name
+            this.name.text,
+            //default value
+            ...(this.defaultValue ? [
+                ' = ',
+                ...this.defaultValue.transpile(state)
+            ] : []),
+            //type declaration
+            ...(this.asToken ? [
+                ' as ',
+                ...((_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.getTypedef(state)) !== null && _b !== void 0 ? _b : [''])
+            ] : [])
         ];
     }
-    getNameParts() {
-        let parts = [];
-        if ((0, reflection_1.isVariableExpression)(this.expression)) {
-            parts.push(this.expression.name.text);
-        }
-        else {
-            let expr = this.expression;
-            parts.push(expr.name.text);
-            while ((0, reflection_1.isVariableExpression)(expr) === false) {
-                expr = expr.obj;
-                parts.unshift(expr.name.text);
-            }
-        }
-        return parts;
-    }
-    getName(parseMode = Parser_1.ParseMode.BrighterScript) {
-        if (parseMode === Parser_1.ParseMode.BrighterScript) {
-            return this.getNameParts().join('.');
-        }
-        else {
-            return this.getNameParts().join('_');
-        }
-    }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'expression', visitor, options);
+        // eslint-disable-next-line no-bitwise
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'defaultValue', visitor, options);
+            (0, visitors_2.walk)(this, 'typeExpression', visitor, options);
         }
     }
 }
-exports.NamespacedVariableNameExpression = NamespacedVariableNameExpression;
-class DottedGetExpression extends Expression {
+exports.FunctionParameterExpression = FunctionParameterExpression;
+class DottedGetExpression extends AstNode_1.Expression {
     constructor(obj, name, 
     /**
      * Can either be `.`, or `?.` for optional chaining
@@ -330,12 +351,15 @@ class DottedGetExpression extends Expression {
         this.obj = obj;
         this.name = name;
         this.dot = dot;
+        this.kind = AstNode_1.AstNodeKind.DottedGetExpression;
         this.range = util_1.default.createBoundingRange(this.obj, this.dot, this.name);
     }
     transpile(state) {
         //if the callee starts with a namespace name, transpile the name
         if (state.file.calleeStartsWithNamespace(this)) {
-            return new NamespacedVariableNameExpression(this).transpile(state);
+            return [
+                state.sourceNode(this, this.getName(Parser_1.ParseMode.BrightScript))
+            ];
         }
         else {
             return [
@@ -346,13 +370,29 @@ class DottedGetExpression extends Expression {
         }
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'obj', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
+        }
+    }
+    getType(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const objType = (_a = this.obj) === null || _a === void 0 ? void 0 : _a.getType(options);
+        const result = objType === null || objType === void 0 ? void 0 : objType.getMemberType((_b = this.name) === null || _b === void 0 ? void 0 : _b.text, options);
+        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry((_d = this.name) === null || _d === void 0 ? void 0 : _d.text, result, options.data, (_f = (_e = this.name) === null || _e === void 0 ? void 0 : _e.range) !== null && _f !== void 0 ? _f : this.range));
+        if (result || options.flags & SymbolTable_1.SymbolTypeFlag.typetime) {
+            // All types should be known at typetime
+            return result;
         }
+        // It is possible at runtime that a value has been added dynamically to an object, or something
+        // TODO: maybe have a strict flag on this?
+        return DynamicType_1.DynamicType.instance;
+    }
+    getName(parseMode) {
+        return util_1.default.getAllDottedGetPartsAsString(this, parseMode);
     }
 }
 exports.DottedGetExpression = DottedGetExpression;
-class XmlAttributeGetExpression extends Expression {
+class XmlAttributeGetExpression extends AstNode_1.Expression {
     constructor(obj, name, 
     /**
      * Can either be `@`, or `?@` for optional chaining
@@ -362,6 +402,7 @@ class XmlAttributeGetExpression extends Expression {
         this.obj = obj;
         this.name = name;
         this.at = at;
+        this.kind = AstNode_1.AstNodeKind.XmlAttributeGetExpression;
         this.range = util_1.default.createBoundingRange(this.obj, this.at, this.name);
     }
     transpile(state) {
@@ -372,13 +413,13 @@ class XmlAttributeGetExpression extends Expression {
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'obj', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
         }
     }
 }
 exports.XmlAttributeGetExpression = XmlAttributeGetExpression;
-class IndexedGetExpression extends Expression {
+class IndexedGetExpression extends AstNode_1.Expression {
     constructor(obj, index, 
     /**
      * Can either be `[` or `?[`. If `?.[` is used, this will be `[` and `optionalChainingToken` will be `?.`
@@ -391,33 +432,47 @@ class IndexedGetExpression extends Expression {
         this.openingSquare = openingSquare;
         this.closingSquare = closingSquare;
         this.questionDotToken = questionDotToken;
+        this.kind = AstNode_1.AstNodeKind.IndexedGetExpression;
         this.range = util_1.default.createBoundingRange(this.obj, this.openingSquare, this.questionDotToken, this.openingSquare, this.index, this.closingSquare);
     }
     transpile(state) {
+        var _a, _b;
         return [
             ...this.obj.transpile(state),
             this.questionDotToken ? state.transpileToken(this.questionDotToken) : '',
             state.transpileToken(this.openingSquare),
-            ...this.index.transpile(state),
-            state.transpileToken(this.closingSquare)
+            ...((_b = (_a = this.index) === null || _a === void 0 ? void 0 : _a.transpile(state)) !== null && _b !== void 0 ? _b : []),
+            this.closingSquare ? state.transpileToken(this.closingSquare) : ''
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'obj', visitor, options);
-            (0, visitors_1.walk)(this, 'index', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
+            (0, visitors_2.walk)(this, 'index', visitor, options);
         }
     }
+    getType(options) {
+        const objType = this.obj.getType(options);
+        if ((0, reflection_1.isArrayType)(objType)) {
+            // This is used on an array. What is the default type of that array?
+            return objType.defaultType;
+        }
+        return super.getType(options);
+    }
 }
 exports.IndexedGetExpression = IndexedGetExpression;
-class GroupingExpression extends Expression {
+class GroupingExpression extends AstNode_1.Expression {
     constructor(tokens, expression) {
         super();
         this.tokens = tokens;
         this.expression = expression;
+        this.kind = AstNode_1.AstNodeKind.GroupingExpression;
         this.range = util_1.default.createBoundingRange(this.tokens.left, this.expression, this.tokens.right);
     }
     transpile(state) {
+        if ((0, reflection_1.isTypeCastExpression)(this.expression)) {
+            return this.expression.transpile(state);
+        }
         return [
             state.transpileToken(this.tokens.left),
             ...this.expression.transpile(state),
@@ -425,18 +480,26 @@ class GroupingExpression extends Expression {
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'expression', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'expression', visitor, options);
         }
     }
+    getType(options) {
+        return this.expression.getType(options);
+    }
 }
 exports.GroupingExpression = GroupingExpression;
-class LiteralExpression extends Expression {
+class LiteralExpression extends AstNode_1.Expression {
     constructor(token) {
         super();
         this.token = token;
-        this.range = this.token.range;
-        this.type = util_1.default.tokenToBscType(token);
+        this.kind = AstNode_1.AstNodeKind.LiteralExpression;
+    }
+    get range() {
+        return this.token.range;
+    }
+    getType(options) {
+        return util_1.default.tokenToBscType(this.token);
     }
     transpile(state) {
         let text;
@@ -444,7 +507,7 @@ class LiteralExpression extends Expression {
             //wrap quasis with quotes (and escape inner quotemarks)
             text = `"${this.token.text.replace(/"/g, '""')}"`;
         }
-        else if ((0, reflection_1.isStringType)(this.type)) {
+        else if (this.token.kind === TokenKind_1.TokenKind.StringLiteral) {
             text = this.token.text;
             //add trailing quotemark if it's missing. We will have already generated a diagnostic for this.
             if (text.endsWith('"') === false) {
@@ -467,10 +530,11 @@ exports.LiteralExpression = LiteralExpression;
  * 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
  */
-class EscapedCharCodeLiteralExpression extends Expression {
+class EscapedCharCodeLiteralExpression extends AstNode_1.Expression {
     constructor(token) {
         super();
         this.token = token;
+        this.kind = AstNode_1.AstNodeKind.EscapedCharCodeLiteralExpression;
         this.range = token.range;
     }
     transpile(state) {
@@ -483,15 +547,15 @@ class EscapedCharCodeLiteralExpression extends Expression {
     }
 }
 exports.EscapedCharCodeLiteralExpression = EscapedCharCodeLiteralExpression;
-class ArrayLiteralExpression extends Expression {
+class ArrayLiteralExpression extends AstNode_1.Expression {
     constructor(elements, open, close, hasSpread = false) {
-        var _a;
         super();
         this.elements = elements;
         this.open = open;
         this.close = close;
         this.hasSpread = hasSpread;
-        this.range = util_1.default.createBoundingRange(this.open, ...((_a = this.elements) !== null && _a !== void 0 ? _a : []), this.close);
+        this.kind = AstNode_1.AstNodeKind.ArrayLiteralExpression;
+        this.range = util_1.default.createBoundingRange(this.open, ...this.elements, this.close);
     }
     transpile(state) {
         let result = [];
@@ -524,25 +588,31 @@ class ArrayLiteralExpression extends Expression {
             result.push('\n');
             result.push(state.indent());
         }
-        result.push(state.transpileToken(this.close));
+        if (this.close) {
+            result.push(state.transpileToken(this.close));
+        }
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walkArray)(this.elements, visitor, options, this);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.elements, visitor, options, this);
         }
     }
+    getType(options) {
+        const innerTypes = this.elements.filter(x => !(0, reflection_1.isCommentStatement)(x)).map(expr => expr.getType(options));
+        return new types_1.ArrayType(...innerTypes);
+    }
 }
 exports.ArrayLiteralExpression = ArrayLiteralExpression;
-class AAMemberExpression extends Expression {
+class AAMemberExpression extends AstNode_1.Expression {
     constructor(keyToken, colonToken, 
     /** The expression evaluated to determine the member's initial value. */
-    value, type) {
+    value) {
         super();
         this.keyToken = keyToken;
         this.colonToken = colonToken;
         this.value = value;
-        this.type = type;
+        this.kind = AstNode_1.AstNodeKind.AAMemberExpression;
         this.range = util_1.default.createBoundingRange(this.keyToken, this.colonToken, this.value);
     }
     transpile(state) {
@@ -550,31 +620,21 @@ class AAMemberExpression extends Expression {
         return [];
     }
     walk(visitor, options) {
-        (0, visitors_1.walk)(this, 'value', visitor, options);
+        (0, visitors_2.walk)(this, 'value', visitor, options);
+    }
+    getType(options) {
+        return this.value.getType(options);
     }
 }
 exports.AAMemberExpression = AAMemberExpression;
-class AALiteralExpression extends Expression {
-    constructor(elements, open, close, functionExpression) {
-        var _a;
+class AALiteralExpression extends AstNode_1.Expression {
+    constructor(elements, open, close) {
         super();
         this.elements = elements;
         this.open = open;
         this.close = close;
-        this.functionExpression = functionExpression;
-        this.symbolTable = new SymbolTable_1.SymbolTable();
-        this.memberTable = new SymbolTable_1.SymbolTable();
-        this.range = util_1.default.createBoundingRange(this.open, ...((_a = this.elements) !== null && _a !== void 0 ? _a : []), this.close);
-        this.buildSymbolTable();
-    }
-    buildSymbolTable() {
-        this.symbolTable.clear();
-        this.symbolTable.addSymbol('m', { start: this.open.range.start, end: this.close.range.end }, new ObjectType_1.ObjectType('object', this.memberTable));
-        for (const element of this.elements) {
-            if ((0, reflection_1.isAAMemberExpression)(element)) {
-                this.memberTable.addSymbol(element.keyToken.text, element.keyToken.range, (0, Parser_1.getBscTypeFromExpression)(element.value, this.functionExpression));
-            }
-        }
+        this.kind = AstNode_1.AstNodeKind.AALiteralExpression;
+        this.range = util_1.default.createBoundingRange(this.open, ...this.elements, this.close);
     }
     transpile(state) {
         let result = [];
@@ -625,54 +685,80 @@ class AALiteralExpression extends Expression {
             result.push(state.indent());
         }
         //close curly
-        result.push(state.transpileToken(this.close));
+        if (this.close) {
+            result.push(state.transpileToken(this.close));
+        }
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walkArray)(this.elements, visitor, options, this);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.elements, visitor, options, this);
+        }
+    }
+    getType(options) {
+        const resultType = new AssociativeArrayType_1.AssociativeArrayType();
+        for (const element of this.elements) {
+            if ((0, reflection_1.isAAMemberExpression)(element)) {
+                resultType.addMember(element.keyToken.text, { definingNode: element }, element.getType(options), SymbolTable_1.SymbolTypeFlag.runtime);
+            }
         }
+        return resultType;
     }
 }
 exports.AALiteralExpression = AALiteralExpression;
-class UnaryExpression extends Expression {
+class UnaryExpression extends AstNode_1.Expression {
     constructor(operator, right) {
         super();
         this.operator = operator;
         this.right = right;
+        this.kind = AstNode_1.AstNodeKind.UnaryExpression;
         this.range = util_1.default.createBoundingRange(this.operator, this.right);
     }
     transpile(state) {
+        let separatingWhitespace;
+        if ((0, reflection_1.isVariableExpression)(this.right)) {
+            separatingWhitespace = this.right.name.leadingWhitespace;
+        }
+        else if ((0, reflection_1.isLiteralExpression)(this.right)) {
+            separatingWhitespace = this.right.token.leadingWhitespace;
+        }
+        else {
+            separatingWhitespace = ' ';
+        }
         return [
             state.transpileToken(this.operator),
-            ' ',
+            separatingWhitespace,
             ...this.right.transpile(state)
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'right', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'right', visitor, options);
         }
     }
+    getType(options) {
+        return util_1.default.unaryOperatorResultType(this.operator, this.right.getType(options));
+    }
 }
 exports.UnaryExpression = UnaryExpression;
-class VariableExpression extends Expression {
-    constructor(name, namespaceName) {
+class VariableExpression extends AstNode_1.Expression {
+    constructor(name) {
+        var _a;
         super();
         this.name = name;
-        this.namespaceName = namespaceName;
-        this.range = this.name.range;
+        this.kind = AstNode_1.AstNodeKind.VariableExpression;
+        this.range = (_a = this.name) === null || _a === void 0 ? void 0 : _a.range;
     }
     getName(parseMode) {
-        return parseMode === Parser_1.ParseMode.BrightScript ? this.name.text : this.name.text;
+        return this.name.text;
     }
     transpile(state) {
-        var _a;
         let result = [];
+        const namespace = this.findAncestor(reflection_1.isNamespaceStatement);
         //if the callee is the name of a known namespace function
-        if (state.file.calleeIsKnownNamespaceFunction(this, (_a = this.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript))) {
+        if (state.file.calleeIsKnownNamespaceFunction(this, namespace === null || namespace === void 0 ? void 0 : namespace.getName(Parser_1.ParseMode.BrighterScript))) {
             result.push(state.sourceNode(this, [
-                this.namespaceName.getName(Parser_1.ParseMode.BrightScript),
+                namespace.getName(Parser_1.ParseMode.BrightScript),
                 '_',
                 this.getName(Parser_1.ParseMode.BrightScript)
             ]));
@@ -686,24 +772,54 @@ class VariableExpression extends Expression {
     walk(visitor, options) {
         //nothing to walk
     }
+    getType(options) {
+        var _a;
+        let resultType = util_1.default.tokenToBscType(this.name);
+        const nameKey = this.name.text;
+        if (!resultType) {
+            const symbolTable = this.getSymbolTable();
+            resultType = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getSymbolType(nameKey, Object.assign(Object.assign({}, options), { fullName: nameKey, tableProvider: () => this.getSymbolTable() }));
+        }
+        (_a = options.typeChain) === null || _a === void 0 ? void 0 : _a.push(new interfaces_1.TypeChainEntry(nameKey, resultType, options.data, this.range));
+        return resultType;
+    }
 }
 exports.VariableExpression = VariableExpression;
-class SourceLiteralExpression extends Expression {
+class SourceLiteralExpression extends AstNode_1.Expression {
     constructor(token) {
         super();
         this.token = token;
-        this.range = token.range;
+        this.kind = AstNode_1.AstNodeKind.SourceLiteralExpression;
+        this.range = token === null || token === void 0 ? void 0 : token.range;
+    }
+    /**
+     * Find the index of the function in its parent
+     */
+    findFunctionIndex(parentFunction, func) {
+        let index = -1;
+        parentFunction.findChild((node) => {
+            if ((0, reflection_1.isFunctionExpression)(node)) {
+                index++;
+                if (node === func) {
+                    return true;
+                }
+            }
+        }, {
+            walkMode: visitors_1.WalkMode.visitAllRecursive
+        });
+        return index;
     }
     getFunctionName(state, parseMode) {
-        let functionExpression = state.file.getFunctionExpressionAtPosition(this.token.range.start);
+        let func = state.file.getFunctionScopeAtPosition(this.token.range.start).func;
         let nameParts = [];
-        while (functionExpression.parentFunction) {
-            let index = functionExpression.parentFunction.childFunctionExpressions.indexOf(functionExpression);
+        let parentFunction;
+        while ((parentFunction = func.findAncestor(reflection_1.isFunctionExpression))) {
+            let index = this.findFunctionIndex(parentFunction, func);
             nameParts.unshift(`anon${index}`);
-            functionExpression = functionExpression.parentFunction;
+            func = parentFunction;
         }
         //get the index of this function in its parent
-        nameParts.unshift(functionExpression.functionStatement.getName(parseMode));
+        nameParts.unshift(func.functionStatement.getName(parseMode));
         return nameParts.join('$');
     }
     transpile(state) {
@@ -727,10 +843,10 @@ class SourceLiteralExpression extends Expression {
                 text = `"${locationUrl.substring(0, 4)}" + "${locationUrl.substring(4)}:${this.token.range.start.line + 1}"`;
                 break;
             case TokenKind_1.TokenKind.PkgPathLiteral:
-                text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}"`;
+                text = `"${util_1.default.sanitizePkgPath(state.file.pkgPath)}"`;
                 break;
             case TokenKind_1.TokenKind.PkgLocationLiteral:
-                text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}:" + str(LINE_NUM)`;
+                text = `"${util_1.default.sanitizePkgPath(state.file.pkgPath)}:" + str(LINE_NUM)`;
                 break;
             case TokenKind_1.TokenKind.LineNumLiteral:
             default:
@@ -752,11 +868,12 @@ exports.SourceLiteralExpression = SourceLiteralExpression;
  * except we need to uniquely identify these statements so we can
  * do more type checking.
  */
-class NewExpression extends Expression {
+class NewExpression extends AstNode_1.Expression {
     constructor(newKeyword, call) {
         super();
         this.newKeyword = newKeyword;
         this.call = call;
+        this.kind = AstNode_1.AstNodeKind.NewExpression;
         this.range = util_1.default.createBoundingRange(this.newKeyword, this.call);
     }
     /**
@@ -764,29 +881,29 @@ class NewExpression extends Expression {
      */
     get className() {
         //the parser guarantees the callee of a new statement's call object will be
-        //a NamespacedVariableNameExpression
+        //either a VariableExpression or a DottedGet
         return this.call.callee;
     }
-    get namespaceName() {
-        return this.call.namespaceName;
-    }
     transpile(state) {
-        var _a, _b;
-        const cls = (_b = state.file.getClassFileLink(this.className.getName(Parser_1.ParseMode.BrighterScript), (_a = this.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript))) === null || _b === void 0 ? void 0 : _b.item;
+        var _a;
+        const namespace = this.findAncestor(reflection_1.isNamespaceStatement);
+        const cls = (_a = state.file.getClassFileLink(this.className.getName(Parser_1.ParseMode.BrighterScript), namespace === null || namespace === void 0 ? void 0 : namespace.getName(Parser_1.ParseMode.BrighterScript))) === null || _a === void 0 ? void 0 : _a.item;
         //new statements within a namespace block can omit the leading namespace if the class resides in that same namespace.
         //So we need to figure out if this is a namespace-omitted class, or if this class exists without a namespace.
         return this.call.transpile(state, cls === null || cls === void 0 ? void 0 : cls.getName(Parser_1.ParseMode.BrightScript));
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'call', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'call', visitor, options);
         }
     }
+    getType(options) {
+        return this.call.getType(options);
+    }
 }
 exports.NewExpression = NewExpression;
-class CallfuncExpression extends Expression {
+class CallfuncExpression extends AstNode_1.Expression {
     constructor(callee, operator, methodName, openingParen, args, closingParen) {
-        var _a;
         super();
         this.callee = callee;
         this.operator = operator;
@@ -794,7 +911,8 @@ class CallfuncExpression extends Expression {
         this.openingParen = openingParen;
         this.args = args;
         this.closingParen = closingParen;
-        this.range = util_1.default.createBoundingRange(this.callee, this.operator, this.methodName, this.openingParen, ...((_a = this.args) !== null && _a !== void 0 ? _a : []), this.closingParen);
+        this.kind = AstNode_1.AstNodeKind.CallfuncExpression;
+        this.range = util_1.default.createBoundingRange(callee, operator, methodName, openingParen, ...args, closingParen);
     }
     transpile(state) {
         let result = [];
@@ -820,10 +938,37 @@ class CallfuncExpression extends Expression {
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'callee', visitor, options);
-            (0, visitors_1.walkArray)(this.args, visitor, options, this);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'callee', visitor, options);
+            (0, visitors_2.walkArray)(this.args, visitor, options, this);
+        }
+    }
+    getType(options) {
+        var _a, _b, _c;
+        let result = DynamicType_1.DynamicType.instance;
+        // a little hacky here with checking options.ignoreCall because callFuncExpression has the method name
+        // It's nicer for CallExpression, because it's a call on any expression.
+        const calleeType = this.callee.getType(Object.assign(Object.assign({}, options), { flags: SymbolTable_1.SymbolTypeFlag.runtime }));
+        if ((0, reflection_1.isComponentType)(calleeType) || (0, reflection_1.isReferenceType)(calleeType)) {
+            const funcType = (_b = (_a = calleeType).getCallFuncType) === null || _b === void 0 ? void 0 : _b.call(_a, this.methodName.text, options);
+            if (funcType) {
+                (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry(this.methodName.text, funcType, options.data, this.methodName.range, (0, creators_1.createToken)(TokenKind_1.TokenKind.Callfunc)));
+                if (options.ignoreCall) {
+                    result = funcType;
+                }
+            }
+            /* TODO:
+                make callfunc return types work
+            else if (isCallableType(funcType) && (!isReferenceType(funcType.returnType) || funcType.returnType.isResolvable())) {
+                result = funcType.returnType;
+            } else if (!isReferenceType(funcType) && (funcType as any)?.returnType?.isResolvable()) {
+                result = (funcType as any).returnType;
+            } else {
+                return new TypePropertyReferenceType(funcType, 'returnType');
+            }
+            */
         }
+        return result;
     }
 }
 exports.CallfuncExpression = CallfuncExpression;
@@ -831,12 +976,12 @@ exports.CallfuncExpression = 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.
  */
-class TemplateStringQuasiExpression extends Expression {
+class TemplateStringQuasiExpression extends AstNode_1.Expression {
     constructor(expressions) {
-        var _a;
         super();
         this.expressions = expressions;
-        this.range = util_1.default.createBoundingRange(...((_a = this.expressions) !== null && _a !== void 0 ? _a : []));
+        this.kind = AstNode_1.AstNodeKind.TemplateStringQuasiExpression;
+        this.range = util_1.default.createBoundingRange(...expressions);
     }
     transpile(state, skipEmptyStrings = true) {
         let result = [];
@@ -853,28 +998,30 @@ class TemplateStringQuasiExpression extends Expression {
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walkArray)(this.expressions, visitor, options, this);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.expressions, visitor, options, this);
         }
     }
 }
 exports.TemplateStringQuasiExpression = TemplateStringQuasiExpression;
-class TemplateStringExpression extends Expression {
+class TemplateStringExpression extends AstNode_1.Expression {
     constructor(openingBacktick, quasis, expressions, closingBacktick) {
-        var _a;
         super();
         this.openingBacktick = openingBacktick;
         this.quasis = quasis;
         this.expressions = expressions;
         this.closingBacktick = closingBacktick;
-        //the expression always starts and ends with a quasi, so we don't need to consider the expression locations
-        this.range = util_1.default.createBoundingRange(this.openingBacktick, ...((_a = this.quasis) !== null && _a !== void 0 ? _a : []), this.closingBacktick);
+        this.kind = AstNode_1.AstNodeKind.TemplateStringExpression;
+        this.range = util_1.default.createBoundingRange(openingBacktick, quasis[0], quasis[quasis.length - 1], closingBacktick);
+    }
+    getType(options) {
+        return StringType_1.StringType.instance;
     }
     transpile(state) {
         if (this.quasis.length === 1 && this.expressions.length === 0) {
             return this.quasis[0].transpile(state);
         }
-        let result = [];
+        let result = ['('];
         let plus = '';
         //helper function to figure out when to include the plus
         function add(...items) {
@@ -893,7 +1040,7 @@ class TemplateStringExpression extends Expression {
             if (expression) {
                 //skip the toString wrapper around certain expressions
                 if ((0, reflection_1.isEscapedCharCodeLiteralExpression)(expression) ||
-                    ((0, reflection_1.isLiteralExpression)(expression) && (0, reflection_1.isStringType)(expression.type))) {
+                    ((0, reflection_1.isLiteralExpression)(expression) && (0, reflection_1.isStringType)(expression.getType()))) {
                     add(...expression.transpile(state));
                     //wrap all other expressions with a bslib_toString call to prevent runtime type mismatch errors
                 }
@@ -902,33 +1049,34 @@ class TemplateStringExpression extends Expression {
                 }
             }
         }
+        //the expression should be wrapped in parens so it can be used line a single expression at runtime
+        result.push(')');
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
             //walk the quasis and expressions in left-to-right order
             for (let i = 0; i < this.quasis.length; i++) {
-                (0, visitors_1.walk)(this.quasis, i, visitor, options, this);
+                (0, visitors_2.walk)(this.quasis, i, visitor, options, this);
                 //this skips the final loop iteration since we'll always have one more quasi than expression
                 if (this.expressions[i]) {
-                    (0, visitors_1.walk)(this.expressions, i, visitor, options, this);
+                    (0, visitors_2.walk)(this.expressions, i, visitor, options, this);
                 }
             }
         }
     }
 }
 exports.TemplateStringExpression = TemplateStringExpression;
-class TaggedTemplateStringExpression extends Expression {
+class TaggedTemplateStringExpression extends AstNode_1.Expression {
     constructor(tagName, openingBacktick, quasis, expressions, closingBacktick) {
-        var _a;
         super();
         this.tagName = tagName;
         this.openingBacktick = openingBacktick;
         this.quasis = quasis;
         this.expressions = expressions;
         this.closingBacktick = closingBacktick;
-        //the expression always starts and ends with a quasi, so we don't need to consider the expression locations
-        this.range = util_1.default.createBoundingRange(this.tagName, this.openingBacktick, ...((_a = this.quasis) !== null && _a !== void 0 ? _a : []), this.closingBacktick);
+        this.kind = AstNode_1.AstNodeKind.TaggedTemplateStringExpression;
+        this.range = util_1.default.createBoundingRange(tagName, openingBacktick, quasis[0], quasis[quasis.length - 1], closingBacktick);
     }
     transpile(state) {
         let result = [];
@@ -955,34 +1103,29 @@ class TaggedTemplateStringExpression extends Expression {
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
             //walk the quasis and expressions in left-to-right order
             for (let i = 0; i < this.quasis.length; i++) {
-                (0, visitors_1.walk)(this.quasis, i, visitor, options, this);
+                (0, visitors_2.walk)(this.quasis, i, visitor, options, this);
                 //this skips the final loop iteration since we'll always have one more quasi than expression
                 if (this.expressions[i]) {
-                    (0, visitors_1.walk)(this.expressions, i, visitor, options, this);
+                    (0, visitors_2.walk)(this.expressions, i, visitor, options, this);
                 }
             }
         }
     }
 }
 exports.TaggedTemplateStringExpression = TaggedTemplateStringExpression;
-class AnnotationExpression extends Expression {
+class AnnotationExpression extends AstNode_1.Expression {
     constructor(atToken, nameToken) {
         super();
         this.atToken = atToken;
         this.nameToken = nameToken;
+        this.kind = AstNode_1.AstNodeKind.AnnotationExpression;
         this.name = nameToken.text;
     }
     get range() {
-        return this.cacheRange();
-    }
-    cacheRange() {
-        if (!this._range) {
-            this._range = util_1.default.createBoundingRange(this.atToken, this.nameToken, this.call);
-        }
-        return this._range;
+        return util_1.default.createBoundingRange(this.atToken, this.nameToken, this.call);
     }
     /**
      * Convert annotation arguments to JavaScript types
@@ -994,6 +1137,9 @@ class AnnotationExpression extends Expression {
         }
         return this.call.args.map(e => expressionToValue(e, strict));
     }
+    getLeadingTrivia() {
+        return this.atToken.leadingTrivia;
+    }
     transpile(state) {
         return [];
     }
@@ -1010,7 +1156,7 @@ class AnnotationExpression extends Expression {
     }
 }
 exports.AnnotationExpression = AnnotationExpression;
-class TernaryExpression extends Expression {
+class TernaryExpression extends AstNode_1.Expression {
     constructor(test, questionMarkToken, consequent, colonToken, alternate) {
         super();
         this.test = test;
@@ -1018,7 +1164,8 @@ class TernaryExpression extends Expression {
         this.consequent = consequent;
         this.colonToken = colonToken;
         this.alternate = alternate;
-        this.range = util_1.default.createBoundingRange(this.test, this.questionMarkToken, this.consequent, this.colonToken, this.alternate);
+        this.kind = AstNode_1.AstNodeKind.TernaryExpression;
+        this.range = util_1.default.createBoundingRange(test, questionMarkToken, consequent, colonToken, alternate);
     }
     transpile(state) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
@@ -1046,21 +1193,22 @@ class TernaryExpression extends Expression {
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'test', visitor, options);
-            (0, visitors_1.walk)(this, 'consequent', visitor, options);
-            (0, visitors_1.walk)(this, 'alternate', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'test', visitor, options);
+            (0, visitors_2.walk)(this, 'consequent', visitor, options);
+            (0, visitors_2.walk)(this, 'alternate', visitor, options);
         }
     }
 }
 exports.TernaryExpression = TernaryExpression;
-class NullCoalescingExpression extends Expression {
+class NullCoalescingExpression extends AstNode_1.Expression {
     constructor(consequent, questionQuestionToken, alternate) {
         super();
         this.consequent = consequent;
         this.questionQuestionToken = questionQuestionToken;
         this.alternate = alternate;
-        this.range = util_1.default.createBoundingRange(this.consequent, this.questionQuestionToken, this.alternate);
+        this.kind = AstNode_1.AstNodeKind.NullCoalescingExpression;
+        this.range = util_1.default.createBoundingRange(consequent, questionQuestionToken, alternate);
     }
     transpile(state) {
         let result = [];
@@ -1089,18 +1237,22 @@ class NullCoalescingExpression extends Expression {
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            (0, visitors_1.walk)(this, 'consequent', visitor, options);
-            (0, visitors_1.walk)(this, 'alternate', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'consequent', visitor, options);
+            (0, visitors_2.walk)(this, 'alternate', visitor, options);
         }
     }
 }
 exports.NullCoalescingExpression = NullCoalescingExpression;
-class RegexLiteralExpression extends Expression {
+class RegexLiteralExpression extends AstNode_1.Expression {
     constructor(tokens) {
         super();
         this.tokens = tokens;
-        this.range = this.tokens.regexLiteral.range;
+        this.kind = AstNode_1.AstNodeKind.RegexLiteralExpression;
+    }
+    get range() {
+        var _a, _b;
+        return (_b = (_a = this.tokens) === null || _a === void 0 ? void 0 : _a.regexLiteral) === null || _b === void 0 ? void 0 : _b.range;
     }
     transpile(state) {
         var _a, _b;
@@ -1131,109 +1283,6 @@ class RegexLiteralExpression extends Expression {
     }
 }
 exports.RegexLiteralExpression = RegexLiteralExpression;
-class TypeExpression extends Expression {
-    constructor(tokens, namespaceName) {
-        super();
-        this.tokens = tokens;
-        this.namespaceName = namespaceName;
-        this.range = util_1.default.createBoundingRange(this.tokens.type);
-    }
-    /**
-     * The this TypeExpression refers to
-     */
-    get type() {
-        if (this._type) {
-            return this._type;
-        }
-        this._type = this.getType(Parser_1.ParseMode.BrighterScript);
-        return this._type;
-    }
-    /**
-     * Derive a BscType from the type token
-     * Can deal with multiple brackets to make multidimensional arrays, eg. float[][]
-     * Defaults to `DynamicType`
-     */
-    getType(parseMode = Parser_1.ParseMode.BrighterScript) {
-        let exprType = this.tokens.type
-            ? util_1.default.tokenToBscType(this.tokens.type, parseMode === Parser_1.ParseMode.BrighterScript, this.namespaceName)
-            : new DynamicType_1.DynamicType();
-        return exprType;
-    }
-    /**
-     * Is this a valid, (eg. known) type?
-     */
-    isValidType(parseMode = Parser_1.ParseMode.BrighterScript) {
-        return !!util_1.default.tokenToBscType(this.tokens.type, parseMode === Parser_1.ParseMode.BrighterScript, this.namespaceName);
-    }
-    /**
-     * Gives a human readable string that says the type
-     * @returns text to display to show the type
-     */
-    getText() {
-        let result = this.tokens.type.text;
-        return result;
-    }
-    transpile(state) {
-        let result = [];
-        //type declaration
-        result.push(state.sourceNode({ range: this.range }, this.type.toTypeString(state.typeContext)));
-        return result;
-    }
-    walk(visitor, options) {
-        //nothing to walk
-    }
-}
-exports.TypeExpression = TypeExpression;
-class ArrayTypeExpression extends TypeExpression {
-    constructor(innerTypes, // this is an array so that in the future when we support union types
-    bracketTokens, namespaceName) {
-        super({}, namespaceName);
-        this.innerTypes = innerTypes;
-        this.bracketTokens = bracketTokens;
-        this.namespaceName = namespaceName;
-        this.range = util_1.default.createBoundingRange(this.bracketTokens.leftBracket, this.bracketTokens.rightBracket, ...this.innerTypes);
-    }
-    /*
-     * TODO - Support union types
-    */
-    get defaultTypeExpression() {
-        return this.innerTypes[0];
-    }
-    /**
-     * Derive a BscType from the type token
-     * Returns an array type with the inner types based on the inner type expressions
-     */
-    getType(parseMode = Parser_1.ParseMode.BrighterScript) {
-        const innerBscTypes = this.innerTypes.map(inner => inner.getType(parseMode));
-        return new ArrayType_1.ArrayType(...innerBscTypes);
-    }
-    /**
-     * Is this a valid, (eg. known) type?
-     */
-    isValidType(parseMode = Parser_1.ParseMode.BrighterScript) {
-        if (parseMode === Parser_1.ParseMode.BrighterScript) {
-            return this.innerTypes.reduce((validSoFar, innerType) => {
-                return validSoFar && innerType.isValidType(parseMode);
-            }, true);
-        }
-        return false;
-    }
-    /**
-     * Gives a human readable string that says the type
-     * @returns text to display to show the type
-     */
-    getText() {
-        return this.defaultTypeExpression.getText() + '[]';
-    }
-    walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            for (let i = 0; i < this.innerTypes.length; i++) {
-                (0, visitors_1.walk)(this.innerTypes, i, visitor, options, this);
-            }
-        }
-    }
-}
-exports.ArrayTypeExpression = ArrayTypeExpression;
 function expressionToValue(expr, strict) {
     if (!expr) {
         return null;
@@ -1267,11 +1316,92 @@ function expressionToValue(expr, strict) {
     return strict ? null : expr;
 }
 function numberExpressionToValue(expr, operator = '') {
-    if ((0, reflection_1.isIntegerType)(expr.type) || (0, reflection_1.isLongIntegerType)(expr.type)) {
+    if ((0, reflection_1.isIntegerType)(expr.getType()) || (0, reflection_1.isLongIntegerType)(expr.getType())) {
         return parseInt(operator + expr.token.text);
     }
     else {
         return parseFloat(operator + expr.token.text);
     }
 }
+class TypeExpression extends AstNode_1.Expression {
+    constructor(
+    /**
+     * The standard AST expression that represents the type for this TypeExpression.
+     */
+    expression) {
+        super();
+        this.expression = expression;
+        this.kind = AstNode_1.AstNodeKind.TypeExpression;
+        this.range = expression === null || expression === void 0 ? void 0 : expression.range;
+    }
+    transpile(state) {
+        return [this.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime }).toTypeString()];
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'expression', visitor, options);
+        }
+    }
+    getType(options) {
+        return this.expression.getType(Object.assign(Object.assign({}, options), { flags: SymbolTable_1.SymbolTypeFlag.typetime }));
+    }
+    getTypedef(state) {
+        // TypeDefs should pass through any valid type names
+        return this.expression.transpile(state);
+    }
+    getName(parseMode = Parser_1.ParseMode.BrighterScript) {
+        //TODO: this may not support Complex Types, eg. generics or Unions
+        return util_1.default.getAllDottedGetPartsAsString(this.expression, parseMode);
+    }
+    getNameParts() {
+        //TODO: really, this code is only used to get Namespaces. It could be more clear.
+        return util_1.default.getAllDottedGetParts(this.expression).map(x => x.text);
+    }
+}
+exports.TypeExpression = TypeExpression;
+class TypeCastExpression extends AstNode_1.Expression {
+    constructor(obj, asToken, typeExpression) {
+        super();
+        this.obj = obj;
+        this.asToken = asToken;
+        this.typeExpression = typeExpression;
+        this.kind = AstNode_1.AstNodeKind.TypeCastExpression;
+        this.range = util_1.default.createBoundingRange(this.obj, this.asToken, this.typeExpression);
+    }
+    transpile(state) {
+        return this.obj.transpile(state);
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
+            (0, visitors_2.walk)(this, 'typeExpression', visitor, options);
+        }
+    }
+    getType(options) {
+        return this.typeExpression.getType(options);
+    }
+}
+exports.TypeCastExpression = TypeCastExpression;
+class TypedArrayExpression extends AstNode_1.Expression {
+    constructor(innerType, leftBracket, rightBracket) {
+        super();
+        this.innerType = innerType;
+        this.leftBracket = leftBracket;
+        this.rightBracket = rightBracket;
+        this.kind = AstNode_1.AstNodeKind.TypedArrayExpression;
+        this.range = util_1.default.createBoundingRange(this.innerType, this.leftBracket, this.rightBracket);
+    }
+    transpile(state) {
+        return [this.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime }).toTypeString()];
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'innerType', visitor, options);
+        }
+    }
+    getType(options) {
+        return new types_1.ArrayType(this.innerType.getType(options));
+    }
+}
+exports.TypedArrayExpression = TypedArrayExpression;
 //# sourceMappingURL=Expression.js.map