brighterscript 0.66.0-alpha.2 → 0.66.0-alpha.3

package/dist/types/VoidType.js

@@ -12,7 +12,8 @@ class VoidType extends BscType_1.BscType {
     }
     isTypeCompatible(targetType) {
         return ((0, reflection_1.isVoidType)(targetType) ||
-            (0, reflection_1.isDynamicType)(targetType));
+            (0, reflection_1.isDynamicType)(targetType) ||
+            (0, reflection_1.isObjectType)(targetType));
     }
     toString() {
         var _a;

package/dist/types/VoidType.js.map

@@ -1 +1 @@
-{"version":3,"file":"VoidType.js","sourceRoot":"","sources":["../../src/types/VoidType.ts"],"names":[],"mappings":";;;AAAA,uDAAmE;AACnE,uCAAoC;AACpC,+CAA4C;AAE5C,MAAa,QAAS,SAAQ,iBAAO;IACjC,YACW,QAAiB;QAExB,KAAK,EAAE,CAAC;QAFD,aAAQ,GAAR,QAAQ,CAAS;QAKZ,SAAI,GAAG,yBAAW,CAAC,QAAQ,CAAC;IAF5C,CAAC;IAMM,gBAAgB,CAAC,UAAmB;QACvC,OAAO,CACH,IAAA,uBAAU,EAAC,UAAU,CAAC;YACtB,IAAA,0BAAa,EAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,QAAQ;;QACX,OAAO,MAAA,IAAI,CAAC,QAAQ,mCAAI,MAAM,CAAC;IACnC,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,OAAO,CAAC,UAAmB;QAC9B,OAAO,IAAA,uBAAU,EAAC,UAAU,CAAC,CAAC;IAClC,CAAC;;AA5BL,4BA6BC;AApBiB,iBAAQ,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"VoidType.js","sourceRoot":"","sources":["../../src/types/VoidType.ts"],"names":[],"mappings":";;;AAAA,uDAAiF;AACjF,uCAAoC;AACpC,+CAA4C;AAE5C,MAAa,QAAS,SAAQ,iBAAO;IACjC,YACW,QAAiB;QAExB,KAAK,EAAE,CAAC;QAFD,aAAQ,GAAR,QAAQ,CAAS;QAKZ,SAAI,GAAG,yBAAW,CAAC,QAAQ,CAAC;IAF5C,CAAC;IAMM,gBAAgB,CAAC,UAAmB;QACvC,OAAO,CACH,IAAA,uBAAU,EAAC,UAAU,CAAC;YACtB,IAAA,0BAAa,EAAC,UAAU,CAAC;YACzB,IAAA,yBAAY,EAAC,UAAU,CAAC,CAC3B,CAAC;IACN,CAAC;IAEM,QAAQ;;QACX,OAAO,MAAA,IAAI,CAAC,QAAQ,mCAAI,MAAM,CAAC;IACnC,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,OAAO,CAAC,UAAmB;QAC9B,OAAO,IAAA,uBAAU,EAAC,UAAU,CAAC,CAAC;IAClC,CAAC;;AA7BL,4BA8BC;AArBiB,iBAAQ,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC"}

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export * from './DoubleType';
 export * from './DynamicType';
 export * from './EnumType';
 export * from './FloatType';
-export * from './FunctionType';
+export * from './TypedFunctionType';
 export * from './helpers';
 export * from './InheritableType';
 export * from './IntegerType';

package/dist/types/index.js

@@ -22,7 +22,7 @@ __exportStar(require("./DoubleType"), exports);
 __exportStar(require("./DynamicType"), exports);
 __exportStar(require("./EnumType"), exports);
 __exportStar(require("./FloatType"), exports);
-__exportStar(require("./FunctionType"), exports);
+__exportStar(require("./TypedFunctionType"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./InheritableType"), exports);
 __exportStar(require("./IntegerType"), exports);

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,gDAA8B;AAC9B,4CAA0B;AAC1B,8CAA4B;AAC5B,+CAA6B;AAC7B,gDAA8B;AAC9B,6CAA2B;AAC3B,8CAA4B;AAC5B,iDAA+B;AAC/B,4CAA0B;AAC1B,oDAAkC;AAClC,gDAA8B;AAC9B,kDAAgC;AAChC,gDAA8B;AAC9B,oDAAkC;AAClC,kDAAgC;AAChC,+CAA6B;AAC7B,kDAAgC;AAChC,+CAA6B;AAC7B,sDAAoC;AACpC,8CAA4B;AAC5B,6CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,gDAA8B;AAC9B,4CAA0B;AAC1B,8CAA4B;AAC5B,+CAA6B;AAC7B,gDAA8B;AAC9B,6CAA2B;AAC3B,8CAA4B;AAC5B,sDAAoC;AACpC,4CAA0B;AAC1B,oDAAkC;AAClC,gDAA8B;AAC9B,kDAAgC;AAChC,gDAA8B;AAC9B,oDAAkC;AAClC,kDAAgC;AAChC,+CAA6B;AAC7B,kDAAgC;AAChC,+CAA6B;AAC7B,sDAAoC;AACpC,8CAA4B;AAC5B,6CAA2B"}

package/dist/util.d.ts

@@ -5,7 +5,6 @@ import { BooleanType } from './types/BooleanType';
 import { DoubleType } from './types/DoubleType';
 import { DynamicType } from './types/DynamicType';
 import { FloatType } from './types/FloatType';
-import { FunctionType } from './types/FunctionType';
 import { IntegerType } from './types/IntegerType';
 import { InvalidType } from './types/InvalidType';
 import { LongIntegerType } from './types/LongIntegerType';
@@ -18,7 +17,10 @@ import type { Identifier, Locatable, Token } from './lexer/Token';
 import { SourceNode } from 'source-map';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
-import type { Expression, Statement } from './parser/AstNode';
+import type { AstNode } from './parser/AstNode';
+import { type Expression, type Statement } from './parser/AstNode';
+import type { BscType } from './types/BscType';
+import { FunctionType } from './types/FunctionType';
 export declare class Util {
     clearConsole(): void;
     /**
@@ -288,7 +290,17 @@ export declare class Util {
     /**
      * Convert a token into a BscType
      */
-    tokenToBscType(token: Token): DynamicType | FloatType | IntegerType | DoubleType | LongIntegerType | StringType | BooleanType | InvalidType | VoidType | FunctionType | ObjectType;
+    tokenToBscType(token: Token): DynamicType | ObjectType | FloatType | IntegerType | DoubleType | LongIntegerType | StringType | BooleanType | InvalidType | VoidType | FunctionType;
+    isNumberType(targetType: BscType): boolean;
+    /**
+     * Return the type of the result of a binary operator
+     * Note: compound assignments (eg. +=) internally use a binary expression, so that's why TokenKind.PlusEqual, etc. are here too
+     */
+    binaryOperatorResultType(leftType: BscType, operator: Token, rightType: BscType): BscType;
+    /**
+     * Return the type of the result of a binary operator
+     */
+    unaryOperatorResultType(operator: Token, exprType: BscType): BscType;
     /**
      * Get the extension for the given file path. Basically the part after the final dot, except for
      * `d.bs` which is treated as single extension
@@ -322,7 +334,7 @@ export declare class Util {
      * @param relatedInformationFallbackLocation a default location to use for all `relatedInformation` entries that are missing a location
      */
     toDiagnostic(diagnostic: Diagnostic | BsDiagnostic, relatedInformationFallbackLocation: string): {
-        severity: import("vscode-languageserver-types").DiagnosticSeverity;
+        severity: import("vscode-languageserver").DiagnosticSeverity;
         range: Range;
         message: string;
         relatedInformation: {
@@ -359,8 +371,13 @@ export declare class Util {
      * @param node any ast expression
      * @returns an array of the parts of the dotted get. If not fully a dotted get, then returns undefined
      */
-    getAllDottedGetParts(node: Expression | Statement): Identifier[] | undefined;
+    getAllDottedGetParts(node: AstNode): Identifier[] | undefined;
+    /**
+     * Given an expression, return all the DottedGet name parts as a string.
+     * Mostly used to convert namespaced item full names to a strings
+     */
     getAllDottedGetPartsAsString(node: Expression | Statement, parseMode?: ParseMode): string;
+    stringJoin(strings: string[], separator: string): string;
     /**
      * Break an expression into each part.
      */

package/dist/util.js

@@ -13,7 +13,6 @@ const BooleanType_1 = require("./types/BooleanType");
 const DoubleType_1 = require("./types/DoubleType");
 const DynamicType_1 = require("./types/DynamicType");
 const FloatType_1 = require("./types/FloatType");
-const FunctionType_1 = require("./types/FunctionType");
 const IntegerType_1 = require("./types/IntegerType");
 const InvalidType_1 = require("./types/InvalidType");
 const LongIntegerType_1 = require("./types/LongIntegerType");
@@ -27,7 +26,9 @@ const reflection_1 = require("./astUtils/reflection");
 const visitors_1 = require("./astUtils/visitors");
 const source_map_1 = require("source-map");
 const requireRelative = require("require-relative");
+const AstNode_1 = require("./parser/AstNode");
 const creators_1 = require("./astUtils/creators");
+const FunctionType_1 = require("./types/FunctionType");
 class Util {
     clearConsole() {
         // process.stdout.write('\x1Bc');
@@ -315,7 +316,6 @@ class Util {
         config.allowBrighterScriptInBrightScript = config.allowBrighterScriptInBrightScript === true ? true : false;
         config.emitDefinitions = config.emitDefinitions === true ? true : false;
         config.removeParameterTypes = config.removeParameterTypes === true ? true : false;
-        config.enableTypeValidation = config.enableTypeValidation === true ? true : false;
         if (typeof config.logLevel === 'string') {
             config.logLevel = Logger_1.LogLevel[config.logLevel.toLowerCase()];
         }
@@ -649,7 +649,7 @@ class Util {
         const diagnosticCode = typeof diagnostic.code === 'string' ? diagnostic.code.toLowerCase() : diagnostic.code;
         for (let flag of (_b = (_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.commentFlags) !== null && _b !== void 0 ? _b : []) {
             //this diagnostic is affected by this flag
-            if (this.rangeContains(flag.affectedRange, diagnostic.range.start)) {
+            if (diagnostic.range && this.rangeContains(flag.affectedRange, diagnostic.range.start)) {
                 //if the flag acts upon this diagnostic's code
                 if (flag.codes === null || flag.codes.includes(diagnosticCode)) {
                     return true;
@@ -938,8 +938,7 @@ class Util {
             case TokenKind_1.TokenKind.FloatLiteral:
                 return FloatType_1.FloatType.instance;
             case TokenKind_1.TokenKind.Function:
-                //TODO should there be a more generic function type without a signature that's assignable to all other function types?
-                return new FunctionType_1.FunctionType(new DynamicType_1.DynamicType(token.text));
+                return new FunctionType_1.FunctionType(token.text);
             case TokenKind_1.TokenKind.Integer:
                 return new IntegerType_1.IntegerType(token.text);
             case TokenKind_1.TokenKind.IntegerLiteral:
@@ -972,7 +971,7 @@ class Util {
                     case 'float':
                         return new FloatType_1.FloatType(token.text);
                     case 'function':
-                        return new FunctionType_1.FunctionType(new DynamicType_1.DynamicType(token.text));
+                        return new FunctionType_1.FunctionType(token.text);
                     case 'integer':
                         return new IntegerType_1.IntegerType(token.text);
                     case 'invalid':
@@ -988,6 +987,157 @@ class Util {
                 }
         }
     }
+    isNumberType(targetType) {
+        return (0, reflection_1.isIntegerType)(targetType) ||
+            (0, reflection_1.isFloatType)(targetType) ||
+            (0, reflection_1.isDoubleType)(targetType) ||
+            (0, reflection_1.isLongIntegerType)(targetType);
+    }
+    /**
+     * Return the type of the result of a binary operator
+     * Note: compound assignments (eg. +=) internally use a binary expression, so that's why TokenKind.PlusEqual, etc. are here too
+     */
+    binaryOperatorResultType(leftType, operator, rightType) {
+        let hasDouble = (0, reflection_1.isDoubleType)(leftType) || (0, reflection_1.isDoubleType)(rightType);
+        let hasFloat = (0, reflection_1.isFloatType)(leftType) || (0, reflection_1.isFloatType)(rightType);
+        let hasLongInteger = (0, reflection_1.isLongIntegerType)(leftType) || (0, reflection_1.isLongIntegerType)(rightType);
+        let hasInvalid = (0, reflection_1.isInvalidType)(leftType) || (0, reflection_1.isInvalidType)(rightType);
+        let bothNumbers = this.isNumberType(leftType) && this.isNumberType(rightType);
+        let bothStrings = (0, reflection_1.isStringType)(leftType) && (0, reflection_1.isStringType)(rightType);
+        let eitherBooleanOrNum = (this.isNumberType(leftType) || (0, reflection_1.isBooleanType)(leftType)) && (this.isNumberType(rightType) || (0, reflection_1.isBooleanType)(rightType));
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (operator.kind) {
+            // Math operators
+            case TokenKind_1.TokenKind.Plus:
+            case TokenKind_1.TokenKind.PlusEqual:
+                if (bothStrings) {
+                    // "string" + "string" is the only binary expression allowed with strings
+                    return StringType_1.StringType.instance;
+                }
+            // eslint-disable-next-line no-fallthrough
+            case TokenKind_1.TokenKind.Minus:
+            case TokenKind_1.TokenKind.MinusEqual:
+            case TokenKind_1.TokenKind.Star:
+            case TokenKind_1.TokenKind.StarEqual:
+            case TokenKind_1.TokenKind.Mod:
+                if (bothNumbers) {
+                    if (hasDouble) {
+                        return DoubleType_1.DoubleType.instance;
+                    }
+                    else if (hasFloat) {
+                        return FloatType_1.FloatType.instance;
+                    }
+                    else if (hasLongInteger) {
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    return IntegerType_1.IntegerType.instance;
+                }
+                break;
+            case TokenKind_1.TokenKind.Forwardslash:
+            case TokenKind_1.TokenKind.ForwardslashEqual:
+                if (bothNumbers) {
+                    if (hasDouble) {
+                        return DoubleType_1.DoubleType.instance;
+                    }
+                    else if (hasFloat) {
+                        return FloatType_1.FloatType.instance;
+                    }
+                    else if (hasLongInteger) {
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    return FloatType_1.FloatType.instance;
+                }
+                break;
+            case TokenKind_1.TokenKind.Backslash:
+            case TokenKind_1.TokenKind.BackslashEqual:
+                if (bothNumbers) {
+                    if (hasLongInteger) {
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    return IntegerType_1.IntegerType.instance;
+                }
+                break;
+            case TokenKind_1.TokenKind.Caret:
+                if (bothNumbers) {
+                    if (hasDouble || hasLongInteger) {
+                        return DoubleType_1.DoubleType.instance;
+                    }
+                    else if (hasFloat) {
+                        return FloatType_1.FloatType.instance;
+                    }
+                    return IntegerType_1.IntegerType.instance;
+                }
+                break;
+            // Bitshift operators
+            case TokenKind_1.TokenKind.LeftShift:
+            case TokenKind_1.TokenKind.LeftShiftEqual:
+            case TokenKind_1.TokenKind.RightShift:
+            case TokenKind_1.TokenKind.RightShiftEqual:
+                if (bothNumbers) {
+                    if (hasLongInteger) {
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    // Bitshifts are allowed with non-integer numerics
+                    // but will always truncate to ints
+                    return IntegerType_1.IntegerType.instance;
+                }
+                break;
+            // Comparison operators
+            // All comparison operators result in boolean
+            case TokenKind_1.TokenKind.Equal:
+            case TokenKind_1.TokenKind.LessGreater:
+                // = and <> can accept invalid
+                if (hasInvalid || bothStrings || eitherBooleanOrNum) {
+                    return BooleanType_1.BooleanType.instance;
+                }
+                break;
+            case TokenKind_1.TokenKind.Greater:
+            case TokenKind_1.TokenKind.Less:
+            case TokenKind_1.TokenKind.GreaterEqual:
+            case TokenKind_1.TokenKind.LessEqual:
+                if (bothStrings || bothNumbers) {
+                    return BooleanType_1.BooleanType.instance;
+                }
+                break;
+            // Logical operators
+            case TokenKind_1.TokenKind.Or:
+            case TokenKind_1.TokenKind.And:
+                if (eitherBooleanOrNum) {
+                    return BooleanType_1.BooleanType.instance;
+                }
+                break;
+        }
+        return DynamicType_1.DynamicType.instance;
+    }
+    /**
+     * Return the type of the result of a binary operator
+     */
+    unaryOperatorResultType(operator, exprType) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (operator.kind) {
+            // Math operators
+            case TokenKind_1.TokenKind.Minus:
+                if (this.isNumberType(exprType)) {
+                    // a negative number will be the same type, eg, double->double, int->int, etc.
+                    return exprType;
+                }
+                break;
+            case TokenKind_1.TokenKind.Not:
+                if ((0, reflection_1.isBooleanType)(exprType)) {
+                    return BooleanType_1.BooleanType.instance;
+                }
+                else if (this.isNumberType(exprType)) {
+                    //numbers can be "notted"
+                    // by default they go to ints, except longints, which stay that way
+                    if ((0, reflection_1.isLongIntegerType)(exprType)) {
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    return IntegerType_1.IntegerType.instance;
+                }
+                break;
+        }
+        return DynamicType_1.DynamicType.instance;
+    }
     /**
      * Get the extension for the given file path. Basically the part after the final dot, except for
      * `d.bs` which is treated as single extension
@@ -1222,55 +1372,70 @@ class Util {
      * @returns an array of the parts of the dotted get. If not fully a dotted get, then returns undefined
      */
     getAllDottedGetParts(node) {
+        //this is a hot function and has been optimized. Don't rewrite unless necessary
         const parts = [];
         let nextPart = node;
-        while (nextPart) {
-            if ((0, reflection_1.isAssignmentStatement)(node)) {
-                return [node.name];
-            }
-            else if ((0, reflection_1.isDottedGetExpression)(nextPart)) {
-                parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.name);
-                nextPart = nextPart.obj;
-            }
-            else if ((0, reflection_1.isCallExpression)(nextPart)) {
-                nextPart = nextPart.callee;
-            }
-            else if ((0, reflection_1.isTypeExpression)(nextPart)) {
-                nextPart = nextPart.expression;
-            }
-            else if ((0, reflection_1.isVariableExpression)(nextPart)) {
-                parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.name);
-                break;
-            }
-            else if ((0, reflection_1.isLiteralExpression)(nextPart)) {
-                parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.token);
-                break;
-            }
-            else if ((0, reflection_1.isIndexedGetExpression)(nextPart)) {
-                nextPart = nextPart.obj;
-            }
-            else if ((0, reflection_1.isFunctionParameterExpression)(nextPart)) {
-                return [nextPart.name];
-            }
-            else if ((0, reflection_1.isGroupingExpression)(nextPart)) {
-                parts.push((0, creators_1.createIdentifier)('()', nextPart.range));
-                break;
-            }
-            else {
-                //we found a non-DottedGet expression, so return because this whole operation is invalid.
-                return undefined;
+        loop: while (nextPart) {
+            switch (nextPart === null || nextPart === void 0 ? void 0 : nextPart.kind) {
+                case AstNode_1.AstNodeKind.AssignmentStatement:
+                    return [node.name];
+                case AstNode_1.AstNodeKind.DottedGetExpression:
+                    parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.name);
+                    nextPart = nextPart.obj;
+                    continue;
+                case AstNode_1.AstNodeKind.CallExpression:
+                    nextPart = nextPart.callee;
+                    continue;
+                case AstNode_1.AstNodeKind.TypeExpression:
+                    nextPart = nextPart.expression;
+                    continue;
+                case AstNode_1.AstNodeKind.VariableExpression:
+                    parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.name);
+                    break loop;
+                case AstNode_1.AstNodeKind.LiteralExpression:
+                    parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.token);
+                    break loop;
+                case AstNode_1.AstNodeKind.IndexedGetExpression:
+                    nextPart = nextPart.obj;
+                    continue;
+                case AstNode_1.AstNodeKind.FunctionParameterExpression:
+                    return [nextPart.name];
+                case AstNode_1.AstNodeKind.GroupingExpression:
+                    parts.push((0, creators_1.createIdentifier)('()', nextPart.range));
+                    break loop;
+                default:
+                    //we found a non-DottedGet expression, so return because this whole operation is invalid.
+                    return undefined;
             }
         }
         return parts.reverse();
     }
+    /**
+     * Given an expression, return all the DottedGet name parts as a string.
+     * Mostly used to convert namespaced item full names to a strings
+     */
     getAllDottedGetPartsAsString(node, parseMode = Parser_1.ParseMode.BrighterScript) {
+        var _a, _b;
+        //this is a hot function and has been optimized. Don't rewrite unless necessary
+        /* eslint-disable no-var */
+        var sep = parseMode === Parser_1.ParseMode.BrighterScript ? '.' : '_';
+        const parts = (_a = this.getAllDottedGetParts(node)) !== null && _a !== void 0 ? _a : [];
+        var result = (_b = parts[0]) === null || _b === void 0 ? void 0 : _b.text;
+        for (var i = 1; i < parts.length; i++) {
+            result += sep + parts[i].text;
+        }
+        return result;
+        /* eslint-enable no-var */
+    }
+    stringJoin(strings, separator) {
         var _a;
-        const sep = parseMode === Parser_1.ParseMode.BrighterScript ? '.' : '_';
-        const hello = (_a = this.getAllDottedGetParts(node)) === null || _a === void 0 ? void 0 : _a.map(part => part.text).join(sep);
-        if (!hello) {
-            console.log(node);
+        // eslint-disable-next-line no-var
+        var result = (_a = strings[0]) !== null && _a !== void 0 ? _a : '';
+        // eslint-disable-next-line no-var
+        for (var i = 1; i < strings.length; i++) {
+            result += separator + strings[i];
         }
-        return hello;
+        return result;
     }
     /**
      * Break an expression into each part.
@@ -1301,36 +1466,37 @@ class Util {
     getDottedGetPath(expression) {
         let parts = [];
         let nextPart = expression;
-        while (nextPart) {
-            if ((0, reflection_1.isDottedGetExpression)(nextPart)) {
-                parts.unshift(nextPart);
-                nextPart = nextPart.obj;
-            }
-            else if ((0, reflection_1.isIndexedGetExpression)(nextPart) || (0, reflection_1.isXmlAttributeGetExpression)(nextPart)) {
-                nextPart = nextPart.obj;
-                parts = [];
-            }
-            else if ((0, reflection_1.isCallExpression)(nextPart) || (0, reflection_1.isCallfuncExpression)(nextPart)) {
-                nextPart = nextPart.callee;
-                parts = [];
-            }
-            else if ((0, reflection_1.isNewExpression)(nextPart)) {
-                nextPart = nextPart.call.callee;
-                parts = [];
-            }
-            else if ((0, reflection_1.isTypeExpression)(nextPart)) {
-                nextPart = nextPart.expression;
-            }
-            else if ((0, reflection_1.isVariableExpression)(nextPart)) {
-                parts.unshift(nextPart);
-                break;
-            }
-            else {
-                parts = [];
-                break;
+        loop: while (nextPart) {
+            switch (nextPart === null || nextPart === void 0 ? void 0 : nextPart.kind) {
+                case AstNode_1.AstNodeKind.DottedGetExpression:
+                    parts.push(nextPart);
+                    nextPart = nextPart.obj;
+                    continue;
+                case AstNode_1.AstNodeKind.IndexedGetExpression:
+                case AstNode_1.AstNodeKind.XmlAttributeGetExpression:
+                    nextPart = nextPart.obj;
+                    parts = [];
+                    continue;
+                case AstNode_1.AstNodeKind.CallExpression:
+                case AstNode_1.AstNodeKind.CallfuncExpression:
+                    nextPart = nextPart.callee;
+                    parts = [];
+                    continue;
+                case AstNode_1.AstNodeKind.NewExpression:
+                    nextPart = nextPart.call.callee;
+                    parts = [];
+                    continue;
+                case AstNode_1.AstNodeKind.TypeExpression:
+                    nextPart = nextPart.expression;
+                    continue;
+                case AstNode_1.AstNodeKind.VariableExpression:
+                    parts.push(nextPart);
+                    break loop;
+                default:
+                    return [];
             }
         }
-        return parts;
+        return parts.reverse();
     }
     /**
      * Returns an integer if valid, or undefined. Eliminates checking for NaN
@@ -1380,7 +1546,7 @@ class Util {
     processTypeChain(typeChain) {
         let fullChainName = '';
         let fullErrorName = '';
-        let missingItemName = '';
+        let itemName = '';
         let previousTypeName = '';
         let parentTypeName = '';
         let errorRange;
@@ -1393,16 +1559,16 @@ class Util {
             parentTypeName = previousTypeName;
             fullErrorName = previousTypeName ? `${previousTypeName}.${chainItem.name}` : chainItem.name;
             previousTypeName = chainItem.type.toString();
-            missingItemName = chainItem.name;
+            itemName = chainItem.name;
             if (!chainItem.isResolved) {
                 errorRange = chainItem.range;
                 break;
             }
         }
         return {
-            missingItemName: missingItemName,
-            missingItemParentTypeName: parentTypeName,
-            fullNameOfMissingItem: fullErrorName,
+            itemName: itemName,
+            itemParentTypeName: parentTypeName,
+            fullNameOfItem: fullErrorName,
             fullChainName: fullChainName,
             range: errorRange
         };