brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/util.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_PARAM_COUNT = exports.util = exports.standardizePath = exports.Util = void 0;
+exports.util = exports.standardizePath = exports.Util = void 0;
 const fs = require("fs");
 const fsExtra = require("fs-extra");
 const jsonc_parser_1 = require("jsonc-parser");
 const path = require("path");
 const roku_deploy_1 = require("roku-deploy");
+const vscode_languageserver_1 = require("vscode-languageserver");
 const vscode_uri_1 = require("vscode-uri");
 const xml2js = require("xml2js");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
@@ -13,9 +14,7 @@ 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 TypedFunctionType_1 = require("./types/TypedFunctionType");
 const IntegerType_1 = require("./types/IntegerType");
-const InvalidType_1 = require("./types/InvalidType");
 const LongIntegerType_1 = require("./types/LongIntegerType");
 const ObjectType_1 = require("./types/ObjectType");
 const StringType_1 = require("./types/StringType");
@@ -26,29 +25,44 @@ const TokenKind_1 = require("./lexer/TokenKind");
 const reflection_1 = require("./astUtils/reflection");
 const visitors_1 = require("./astUtils/visitors");
 const source_map_1 = require("source-map");
-const SGTypes_1 = require("./parser/SGTypes");
 const requireRelative = require("require-relative");
+const AstNode_1 = require("./parser/AstNode");
+const SymbolTable_1 = require("./SymbolTable");
+const creators_1 = require("./astUtils/creators");
+const diagnosticUtils_1 = require("./diagnosticUtils");
+const types_1 = require("./types");
+const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
+const ComponentType_1 = require("./types/ComponentType");
 const FunctionType_1 = require("./types/FunctionType");
-const LazyType_1 = require("./types/LazyType");
 class Util {
+    constructor() {
+        /**
+         * A cache of `Range` objects. The key is a 52bit integer created from the 4 range integers and leveraging bitshifting.
+         * The whole point of this cache is to reduce garbage collection churn, so we didn't want to use string concatenation for the key
+         */
+        this.rangeCache = new Map();
+        /**
+         * A cache of `Position` objects. The key is a 26bit integer created from line and character and leveraging bitshifting
+         * The whole point of this cache is to reduce garbage collection churn, so we didn't want to use string concatenation for the key
+         */
+        this.positionCache = new Map();
+    }
     clearConsole() {
         // process.stdout.write('\x1Bc');
     }
     /**
      * Returns the number of parent directories in the filPath
-     * @param filePath
      */
     getParentDirectoryCount(filePath) {
         if (!filePath) {
             return -1;
         }
         else {
-            return filePath.replace(/^pkg:\//, '').split(/[\\\/]/).length - 1;
+            return filePath.replace(/^pkg:/, '').split(/[\\\/]/).length - 1;
         }
     }
     /**
      * Determine if the file exists
-     * @param filePath
      */
     async pathExists(filePath) {
         if (!filePath) {
@@ -60,7 +74,6 @@ class Util {
     }
     /**
      * Determine if the file exists
-     * @param filePath
      */
     pathExistsSync(filePath) {
         if (!filePath) {
@@ -74,18 +87,16 @@ class Util {
      * Determine if this path is a directory
      */
     isDirectorySync(dirPath) {
-        return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
+        return dirPath !== undefined && fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
     }
     /**
      * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
      */
     sanitizePkgPath(pkgPath) {
-        pkgPath = pkgPath.replace(/\\/g, '/');
-        //if there's no protocol, assume it's supposed to start with `pkg:/`
-        if (!this.startsWithProtocol(pkgPath)) {
-            pkgPath = 'pkg:/' + pkgPath;
-        }
-        return pkgPath;
+        //convert all slashes to forwardslash
+        pkgPath = pkgPath.replace(/[\/\\]+/g, '/');
+        //ensure every path has the leading pkg:/
+        return 'pkg:/' + pkgPath.replace(/^pkg:\//i, '');
     }
     /**
      * Determine if the given path starts with a protocol
@@ -93,9 +104,15 @@ class Util {
     startsWithProtocol(path) {
         return !!/^[-a-z]+:\//i.exec(path);
     }
+    /**
+     * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
+     * @deprecated use `sanitizePkgPath instead. Will be removed in v1
+     */
+    getRokuPkgPath(pkgPath) {
+        return this.sanitizePkgPath(pkgPath);
+    }
     /**
      * Given a path to a file/directory, replace all path separators with the current system's version.
-     * @param filePath
      */
     pathSepNormalize(filePath, separator) {
         if (!filePath) {
@@ -107,7 +124,7 @@ class Util {
     /**
      * Find the path to the config file.
      * If the config file path doesn't exist
-     * @param configFilePath
+     * @param cwd the current working directory where the search for configs should begin
      */
     getConfigFilePath(cwd) {
         cwd = cwd !== null && cwd !== void 0 ? cwd : process.cwd();
@@ -141,13 +158,13 @@ class Util {
                 colIndex++;
             }
         }
-        return this.createRange(lineIndex, colIndex, lineIndex, colIndex + length);
+        return exports.util.createRange(lineIndex, colIndex, lineIndex, colIndex + length);
     }
     /**
      * Load the contents of a config file.
      * If the file extends another config, this will load the base config as well.
-     * @param configFilePath
-     * @param parentProjectPaths
+     * @param configFilePath the relative or absolute path to a brighterscript config json file
+     * @param parentProjectPaths a list of parent config files. This is used by this method to recursively build the config list
      */
     loadConfigFile(configFilePath, parentProjectPaths, cwd = process.cwd()) {
         var _a;
@@ -216,7 +233,8 @@ class Util {
     }
     /**
      * Convert relative paths to absolute paths, relative to the given directory. Also de-dupes the paths. Modifies the array in-place
-     * @param paths the list of paths to be resolved and deduped
+     * @param collection usually a bsconfig.
+     * @param key a key of the config to read paths from (usually this is `'plugins'` or `'require'`)
      * @param relativeDir the path to the folder where the paths should be resolved relative to. This should be an absolute path
      */
     resolvePathsRelativeTo(collection, key, relativeDir) {
@@ -234,8 +252,8 @@ class Util {
     }
     /**
      * Do work within the scope of a changed current working directory
-     * @param targetCwd
-     * @param callback
+     * @param targetCwd the cwd where the work should be performed
+     * @param callback a function to call when the cwd has been changed to `targetCwd`
      */
     cwdWork(targetCwd, callback) {
         let originalCwd = process.cwd();
@@ -257,16 +275,20 @@ class Util {
             throw err;
         }
         else {
+            //justification: `result` is set as long as `err` is not set and vice versa
             return result;
         }
     }
     /**
      * Given a BsConfig object, start with defaults,
      * merge with bsconfig.json and the provided options.
-     * @param config
+     * @param config a bsconfig object to use as the baseline for the resulting config
      */
     normalizeAndResolveConfig(config) {
         let result = this.normalizeConfig({});
+        if (config === null || config === void 0 ? void 0 : config.noProject) {
+            return result;
+        }
         //if no options were provided, try to find a bsconfig.json file
         if (!config || !config.project) {
             result.project = this.getConfigFilePath(config === null || config === void 0 ? void 0 : config.cwd);
@@ -276,7 +298,7 @@ class Util {
             result.project = config.project;
         }
         if (result.project) {
-            let configFile = this.loadConfigFile(result.project, null, config === null || config === void 0 ? void 0 : config.cwd);
+            let configFile = this.loadConfigFile(result.project, undefined, config === null || config === void 0 ? void 0 : config.cwd);
             result = Object.assign(result, configFile);
         }
         //override the defaults with the specified options
@@ -285,43 +307,60 @@ class Util {
     }
     /**
      * Set defaults for any missing items
-     * @param config
+     * @param config a bsconfig object to use as the baseline for the resulting config
      */
     normalizeConfig(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        config = config || {};
-        config.cwd = (_a = config.cwd) !== null && _a !== void 0 ? _a : process.cwd();
-        config.deploy = config.deploy === true ? true : false;
-        //use default files array from rokuDeploy
-        config.files = (_b = config.files) !== null && _b !== void 0 ? _b : [...roku_deploy_1.DefaultFiles];
-        config.createPackage = config.createPackage === false ? false : true;
-        let rootFolderName = path.basename(config.cwd);
-        config.outFile = (_c = config.outFile) !== null && _c !== void 0 ? _c : `./out/${rootFolderName}.zip`;
-        config.sourceMap = config.sourceMap === true;
-        config.username = (_d = config.username) !== null && _d !== void 0 ? _d : 'rokudev';
-        config.watch = config.watch === true ? true : false;
-        config.emitFullPaths = config.emitFullPaths === true ? true : false;
-        config.retainStagingFolder = config.retainStagingFolder === true ? true : false;
-        config.copyToStaging = config.copyToStaging === false ? false : true;
-        config.ignoreErrorCodes = (_e = config.ignoreErrorCodes) !== null && _e !== void 0 ? _e : [];
-        config.diagnosticFilters = (_f = config.diagnosticFilters) !== null && _f !== void 0 ? _f : [];
-        config.plugins = (_g = config.plugins) !== null && _g !== void 0 ? _g : [];
-        config.autoImportComponentScript = config.autoImportComponentScript === true ? true : false;
-        config.showDiagnosticsInConsole = config.showDiagnosticsInConsole === false ? false : true;
-        config.sourceRoot = config.sourceRoot ? standardizePath(config.sourceRoot) : undefined;
-        config.allowBrighterScriptInBrightScript = config.allowBrighterScriptInBrightScript === true ? true : false;
-        config.emitDefinitions = config.emitDefinitions === true ? true : false;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        config = config !== null && config !== void 0 ? config : {};
+        const cwd = (_a = config.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+        const rootFolderName = path.basename(cwd);
+        const retainStagingDir = ((_b = config.retainStagingDir) !== null && _b !== void 0 ? _b : config.retainStagingDir) === true ? true : false;
+        let logLevel = Logger_1.LogLevel.log;
         if (typeof config.logLevel === 'string') {
-            config.logLevel = Logger_1.LogLevel[config.logLevel.toLowerCase()];
-        }
-        config.logLevel = (_h = config.logLevel) !== null && _h !== void 0 ? _h : Logger_1.LogLevel.log;
-        return config;
+            logLevel = (_c = Logger_1.LogLevel[config.logLevel.toLowerCase()]) !== null && _c !== void 0 ? _c : Logger_1.LogLevel.log;
+        }
+        let bslibDestinationDir = (_d = config.bslibDestinationDir) !== null && _d !== void 0 ? _d : 'source';
+        if (bslibDestinationDir !== 'source') {
+            // strip leading and trailing slashes
+            bslibDestinationDir = bslibDestinationDir.replace(/^(\/*)(.*?)(\/*)$/, '$2');
+        }
+        const configWithDefaults = {
+            cwd: cwd,
+            deploy: config.deploy === true ? true : false,
+            //use default files array from rokuDeploy
+            files: (_e = config.files) !== null && _e !== void 0 ? _e : [...roku_deploy_1.DefaultFiles],
+            createPackage: config.createPackage === false ? false : true,
+            outFile: (_f = config.outFile) !== null && _f !== void 0 ? _f : `./out/${rootFolderName}.zip`,
+            sourceMap: config.sourceMap === true,
+            username: (_g = config.username) !== null && _g !== void 0 ? _g : 'rokudev',
+            watch: config.watch === true ? true : false,
+            emitFullPaths: config.emitFullPaths === true ? true : false,
+            retainStagingDir: retainStagingDir,
+            copyToStaging: config.copyToStaging === false ? false : true,
+            ignoreErrorCodes: (_h = config.ignoreErrorCodes) !== null && _h !== void 0 ? _h : [],
+            diagnosticSeverityOverrides: (_j = config.diagnosticSeverityOverrides) !== null && _j !== void 0 ? _j : {},
+            diagnosticFilters: (_k = config.diagnosticFilters) !== null && _k !== void 0 ? _k : [],
+            plugins: (_l = config.plugins) !== null && _l !== void 0 ? _l : [],
+            pruneEmptyCodeFiles: config.pruneEmptyCodeFiles === true ? true : false,
+            autoImportComponentScript: config.autoImportComponentScript === true ? true : false,
+            showDiagnosticsInConsole: config.showDiagnosticsInConsole === false ? false : true,
+            sourceRoot: config.sourceRoot ? standardizePath(config.sourceRoot) : undefined,
+            allowBrighterScriptInBrightScript: config.allowBrighterScriptInBrightScript === true ? true : false,
+            emitDefinitions: config.emitDefinitions === true ? true : false,
+            removeParameterTypes: config.removeParameterTypes === true ? true : false,
+            logLevel: logLevel,
+            bslibDestinationDir: bslibDestinationDir,
+            legacyCallfuncHandling: config.legacyCallfuncHandling === true ? true : false
+        };
+        //mutate `config` in case anyone is holding a reference to the incomplete one
+        const merged = Object.assign(config, configWithDefaults);
+        return merged;
     }
     /**
      * Get the root directory from options.
      * Falls back to options.cwd.
      * Falls back to process.cwd
-     * @param options
+     * @param options a bsconfig object
      */
     getRootDir(options) {
         if (!options) {
@@ -333,19 +372,8 @@ class Util {
         rootDir = path.resolve(cwd, rootDir);
         return rootDir;
     }
-    /**
-     * Format a string with placeholders replaced by argument indexes
-     * @param subject
-     * @param params
-     */
-    stringFormat(subject, ...args) {
-        return subject.replace(/{(\d+)}/g, (match, num) => {
-            return typeof args[num] !== 'undefined' ? args[num] : match;
-        });
-    }
     /**
      * Given a list of callables as a dictionary indexed by their full name (namespace included, transpiled to underscore-separated.
-     * @param callables
      */
     getCallableContainersByLowerName(callables) {
         //find duplicate functions
@@ -365,32 +393,39 @@ class Util {
     }
     /**
      * Split a file by newline characters (LF or CRLF)
-     * @param text
      */
     getLines(text) {
         return text.split(/\r?\n/);
     }
     /**
-     * Compute the pkg path for the target relative to the source file's location
-     * @param sourcePkgPath The pkgPath of the file that contains the target path
-     * @param targetPath a full pkgPath, or a path relative to the containing file
+     * Given an absolute path to a source file, and a target path,
+     * compute the pkg path for the target relative to the source file's location
      */
-    getPkgPathFromTarget(sourcePkgPath, targetPath) {
+    getPkgPathFromTarget(containingFilePathAbsolute, targetPath) {
         var _a;
-        const [protocol] = (_a = /^[-a-z0-9_]+:\/?/i.exec(targetPath)) !== null && _a !== void 0 ? _a : [];
-        //if the target path is only a file protocol (with or without the trailing slash such as `pkg:` or `pkg:/`), nothing more can be done
-        if ((targetPath === null || targetPath === void 0 ? void 0 : targetPath.length) === (protocol === null || protocol === void 0 ? void 0 : protocol.length)) {
-            return null;
+        // https://regex101.com/r/w7CG2N/1
+        const regexp = /^(?:pkg|libpkg):(\/)?/i;
+        const [fullScheme, slash] = (_a = regexp.exec(targetPath)) !== null && _a !== void 0 ? _a : [];
+        //if the target starts with 'pkg:' or 'libpkg:' then it's an absolute path. Return as is
+        if (slash) {
+            targetPath = targetPath.substring(fullScheme.length);
+            if (targetPath === '') {
+                return null;
+            }
+            else {
+                return path.normalize(targetPath);
+            }
         }
-        //if the target starts with 'pkg:', return as-is
-        if (protocol) {
-            return targetPath;
+        //if the path is exactly `pkg:` or `libpkg:`
+        if (targetPath === fullScheme && !slash) {
+            return null;
         }
+        //remove the filename
+        let containingFolder = path.normalize(path.dirname(containingFilePathAbsolute));
         //start with the containing folder, split by slash
-        const containingFolder = path.posix.normalize(path.dirname(sourcePkgPath));
-        let result = containingFolder.split(/[\\/]/);
+        let result = containingFolder.split(path.sep);
         //split on slash
-        let targetParts = path.posix.normalize(targetPath).split(/[\\/]/);
+        let targetParts = path.normalize(targetPath).split(path.sep);
         for (let part of targetParts) {
             if (part === '' || part === '.') {
                 //do nothing, it means current directory
@@ -404,7 +439,7 @@ class Util {
                 result.push(part);
             }
         }
-        return result.join('/');
+        return result.join(path.sep);
     }
     /**
      * Compute the relative path from the source file to the target file
@@ -466,6 +501,10 @@ class Util {
      * ```
      */
     rangesIntersect(a, b) {
+        //stop if the either range is misisng
+        if (!a || !b) {
+            return false;
+        }
         // Check if `a` is before `b`
         if (a.end.line < b.start.line || (a.end.line === b.start.line && a.end.character <= b.start.character)) {
             return false;
@@ -487,6 +526,10 @@ class Util {
      * ```
      */
     rangesIntersectOrTouch(a, b) {
+        //stop if the either range is misisng
+        if (!a || !b) {
+            return false;
+        }
         // Check if `a` is before `b`
         if (a.end.line < b.start.line || (a.end.line === b.start.line && a.end.character < b.start.character)) {
             return false;
@@ -501,34 +544,97 @@ class Util {
     /**
      * Test if `position` is in `range`. If the position is at the edges, will return true.
      * Adapted from core vscode
-     * @param range
-     * @param position
      */
     rangeContains(range, position) {
         return this.comparePositionToRange(position, range) === 0;
     }
     comparePositionToRange(position, range) {
-        if (position.line < range.start.line || (position.line === range.start.line && position.character < range.start.character)) {
+        //stop if the either range is missng
+        if (!position || !range) {
+            return 0;
+        }
+        if (this.comparePosition(position, range.start) < 0) {
+            return -1;
+        }
+        if (this.comparePosition(position, range.end) > 0) {
+            return 1;
+        }
+        return 0;
+    }
+    comparePosition(a, b) {
+        //stop if the either position is missing
+        if (!a || !b) {
+            return 0;
+        }
+        if (a.line < b.line || (a.line === b.line && a.character < b.character)) {
             return -1;
         }
-        if (position.line > range.end.line || (position.line === range.end.line && position.character > range.end.character)) {
+        if (a.line > b.line || (a.line === b.line && a.character > b.character)) {
             return 1;
         }
         return 0;
     }
     /**
-    * Test if `insideRange` is wholly in `range` - the start and end of `insideRange` must be contained in `range`
-    * Adapted from core vscode
-    * @param range
-    * @param insideRange
-    */
-    rangeContainsRange(range, insideRange) {
-        return this.comparePositionToRange(insideRange.start, range) === 0 &&
-            this.comparePositionToRange(insideRange.end, range) === 0;
+     * Combine all the documentation found before a token (i.e. comment tokens)
+     */
+    getTokenDocumentation(tokens, token) {
+        const comments = [];
+        const idx = tokens === null || tokens === void 0 ? void 0 : tokens.indexOf(token);
+        if (!idx || idx === -1) {
+            return undefined;
+        }
+        for (let i = idx - 1; i >= 0; i--) {
+            const token = tokens[i];
+            //skip whitespace and newline chars
+            if (token.kind === TokenKind_1.TokenKind.Comment) {
+                comments.push(token);
+            }
+            else if (token.kind === TokenKind_1.TokenKind.Newline || token.kind === TokenKind_1.TokenKind.Whitespace) {
+                //skip these tokens
+                continue;
+                //any other token means there are no more comments
+            }
+            else {
+                break;
+            }
+        }
+        if (comments.length > 0) {
+            return comments.reverse().map(x => x.text.replace(/^('|rem)/i, '').trim()).map(line => {
+                if (line.startsWith('@')) {
+                    // Handle jsdoc/brightscriptdoc tags specially
+                    // make sure they are on their own markdown line, and add italics
+                    const firstSpaceIndex = line.indexOf(' ');
+                    if (firstSpaceIndex === -1) {
+                        return `\n_${line}_`;
+                    }
+                    const firstWord = line.substring(0, firstSpaceIndex);
+                    return `\n_${firstWord}_ ${line.substring(firstSpaceIndex + 1)}`;
+                }
+                return line;
+            }).join('\n');
+        }
+    }
+    /**
+     * Combine all the documentation for a node - uses the AstNode's leadingTrivia property
+     */
+    getNodeDocumentation(node) {
+        if (!node) {
+            return;
+        }
+        const leadingTrivia = node.getLeadingTrivia();
+        return this.getTokenDocumentation(leadingTrivia, leadingTrivia[leadingTrivia.length - 1]);
+    }
+    /**
+     * Prefixes a component name so it can be used as type in the symbol table, without polluting available symbols
+     *
+     * @param sgNodeName the Name of the component
+     * @returns the node name, prefixed with `roSGNode`
+     */
+    getSgNodeTypeName(sgNodeName) {
+        return 'roSGNode' + sgNodeName;
     }
     /**
      * Parse an xml file and get back a javascript object containing its results
-     * @param text
      */
     parseXml(text) {
         return new Promise((resolve, reject) => {
@@ -560,7 +666,6 @@ class Util {
     }
     /**
      * Given a URI, convert that to a regular fs path
-     * @param uri
      */
     uriToPath(uri) {
         let parsedPath = vscode_uri_1.URI.parse(uri).fsPath;
@@ -575,7 +680,6 @@ class Util {
     }
     /**
      * Force the drive letter to lower case
-     * @param fullPath
      */
     driveLetterToLower(fullPath) {
         if (fullPath) {
@@ -590,6 +694,19 @@ class Util {
         }
         return fullPath;
     }
+    /**
+     * Replace the first instance of `search` in `subject` with `replacement`
+     */
+    replaceCaseInsensitive(subject, search, replacement) {
+        let idx = subject.toLowerCase().indexOf(search.toLowerCase());
+        if (idx > -1) {
+            let result = subject.substring(0, idx) + replacement + subject.substring(idx + search.length);
+            return result;
+        }
+        else {
+            return subject;
+        }
+    }
     /**
      * Determine if two arrays containing primitive values are equal.
      * This considers order and compares by equality.
@@ -607,14 +724,12 @@ class Util {
     }
     /**
      * Given a file path, convert it to a URI string
-     * @param srcPath The absolute path to the source file on disk
      */
-    pathToUri(srcPath) {
-        return vscode_uri_1.URI.file(srcPath).toString();
+    pathToUri(filePath) {
+        return vscode_uri_1.URI.file(filePath).toString();
     }
     /**
      * Get the outDir from options, taking into account cwd and absolute outFile paths
-     * @param options
      */
     getOutDir(options) {
         options = this.normalizeConfig(options);
@@ -636,8 +751,7 @@ class Util {
     }
     /**
      * Given a path to a brs file, compute the path to a theoretical d.bs file.
-     * Only `.brs` files can have a typedef, so return undefined for everything else
-     * @param brsSrcPath The absolute path to the .brs source file on disk
+     * Only `.brs` files can have typedef path, so return undefined for everything else
      */
     getTypedefPath(brsSrcPath) {
         const typedefPath = brsSrcPath
@@ -652,24 +766,23 @@ class Util {
     }
     /**
      * Determine whether this diagnostic should be supressed or not, based on brs comment-flags
-     * @param diagnostic
      */
     diagnosticIsSuppressed(diagnostic) {
         var _a, _b;
         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)) {
+                if (flag.codes === null || (diagnosticCode !== undefined && flag.codes.includes(diagnosticCode))) {
                     return true;
                 }
             }
         }
+        return false;
     }
     /**
-     * Walks up the chain
-     * @param currentPath
+     * Walks up the chain to find the closest bsconfig.json file
      */
     async findClosestConfigFile(currentPath) {
         //make the path absolute
@@ -695,7 +808,7 @@ class Util {
     }
     /**
      * Set a timeout for the specified milliseconds, and resolve the promise once the timeout is finished.
-     * @param milliseconds
+     * @param milliseconds the minimum number of milliseconds to sleep for
      */
     sleep(milliseconds) {
         return new Promise((resolve) => {
@@ -710,11 +823,11 @@ class Util {
     }
     /**
      * Given an array, map and then flatten
-     * @param arr
-     * @param cb
+     * @param array the array to flatMap over
+     * @param callback a function that is called for every array item
      */
-    flatMap(array, cb) {
-        return Array.prototype.concat.apply([], array.map(cb));
+    flatMap(array, callback) {
+        return Array.prototype.concat.apply([], array.map(callback));
     }
     /**
      * Determines if the position is greater than the range. This means
@@ -758,8 +871,6 @@ class Util {
     }
     /**
      * If the two items have lines that touch
-     * @param first
-     * @param second
      */
     linesTouch(first, second) {
         if (first && second && (first.range.start.line === second.range.start.line ||
@@ -789,7 +900,8 @@ class Util {
      */
     getScriptImportAtPosition(scriptImports, position) {
         let scriptImport = scriptImports.find((x) => {
-            return x.filePathRange.start.line === position.line &&
+            return x.filePathRange &&
+                x.filePathRange.start.line === position.line &&
                 //column between start and end
                 position.character >= x.filePathRange.start.character &&
                 position.character <= x.filePathRange.end.character;
@@ -833,7 +945,9 @@ class Util {
             rangeLines.push(lines[i]);
         }
         const lastLine = rangeLines.pop();
-        rangeLines.push(lastLine.substring(0, endCharacter));
+        if (lastLine !== undefined) {
+            rangeLines.push(lastLine.substring(0, endCharacter));
+        }
         return rangeLines.join('\n');
     }
     /**
@@ -849,61 +963,86 @@ class Util {
      * Helper for creating `Range` objects. Prefer using this function because vscode-languageserver's `Range.create()` is significantly slower
      */
     createRange(startLine, startCharacter, endLine, endCharacter) {
-        return {
-            start: {
-                line: startLine,
-                character: startCharacter
-            },
-            end: {
-                line: endLine,
-                character: endCharacter
-            }
-        };
+        // eslint-disable-next-line no-bitwise
+        const key = (startLine << 39) + (startCharacter << 26) + (endLine << 13) + endCharacter;
+        let range = this.rangeCache.get(key);
+        if (!range) {
+            range = {
+                start: this.createPosition(startLine, startCharacter),
+                end: this.createPosition(endLine, endCharacter)
+            };
+            this.rangeCache.set(key, range);
+        }
+        return range;
     }
     /**
      * Create a `Range` from two `Position`s
      */
     createRangeFromPositions(startPosition, endPosition) {
-        return {
-            start: {
-                line: startPosition.line,
-                character: startPosition.character
-            },
-            end: {
-                line: endPosition.line,
-                character: endPosition.character
-            }
-        };
+        return this.createRange(startPosition.line, startPosition.character, endPosition.line, endPosition.character);
     }
     /**
-     * Given a list of ranges, create a range that starts with the first non-null lefthand range, and ends with the first non-null
-     * righthand range. Returns undefined if none of the items have a range.
+     *  Gets the bounding range of a bunch of ranges or objects that have ranges
+     *  TODO: this does a full iteration of the args. If the args were guaranteed to be in range order, we could optimize this
      */
     createBoundingRange(...locatables) {
-        let leftmostRange;
-        let rightmostRange;
-        for (let i = 0; i < locatables.length; i++) {
-            //set the leftmost non-null-range item
-            const left = locatables[i];
+        let startPosition;
+        let endPosition;
+        for (let locatable of locatables) {
             //the range might be a getter, so access it exactly once
-            const leftRange = left === null || left === void 0 ? void 0 : left.range;
-            if (!leftmostRange && leftRange) {
-                leftmostRange = leftRange;
+            const locatableRange = vscode_languageserver_1.Range.is(locatable) ? locatable : locatable === null || locatable === void 0 ? void 0 : locatable.range;
+            if (!locatableRange) {
+                continue;
             }
-            //set the rightmost non-null-range item
-            const right = locatables[locatables.length - 1 - i];
-            //the range might be a getter, so access it exactly once
-            const rightRange = right === null || right === void 0 ? void 0 : right.range;
-            if (!rightmostRange && rightRange) {
-                rightmostRange = rightRange;
+            if (!startPosition) {
+                startPosition = locatableRange.start;
             }
-            //if we have both sides, quit
-            if (leftmostRange && rightmostRange) {
-                break;
+            else if (this.comparePosition(locatableRange.start, startPosition) < 0) {
+                startPosition = locatableRange.start;
+            }
+            if (!endPosition) {
+                endPosition = locatableRange.end;
+            }
+            else if (this.comparePosition(locatableRange.end, endPosition) > 0) {
+                endPosition = locatableRange.end;
+            }
+        }
+        if (startPosition && endPosition) {
+            return this.createRangeFromPositions(startPosition, endPosition);
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Gets the bounding range of an object that contains a bunch of tokens
+     * @param tokens Object with tokens in it
+     * @returns Range containing all the tokens
+     */
+    createBoundingRangeFromTokens(tokens) {
+        var _a;
+        let startPosition;
+        let endPosition;
+        for (let key in tokens) {
+            let locatableRange = (_a = tokens === null || tokens === void 0 ? void 0 : tokens[key]) === null || _a === void 0 ? void 0 : _a.range;
+            if (!locatableRange) {
+                continue;
+            }
+            if (!startPosition) {
+                startPosition = locatableRange.start;
+            }
+            else if (this.comparePosition(locatableRange.start, startPosition) < 0) {
+                startPosition = locatableRange.start;
+            }
+            if (!endPosition) {
+                endPosition = locatableRange.end;
+            }
+            else if (this.comparePosition(locatableRange.end, endPosition) > 0) {
+                endPosition = locatableRange.end;
             }
         }
-        if (leftmostRange) {
-            return this.createRangeFromPositions(leftmostRange.start, rightmostRange.end);
+        if (startPosition && endPosition) {
+            return this.createRangeFromPositions(startPosition, endPosition);
         }
         else {
             return undefined;
@@ -913,10 +1052,17 @@ class Util {
      * Create a `Position` object. Prefer this over `Position.create` for performance reasons
      */
     createPosition(line, character) {
-        return {
-            line: line,
-            character: character
-        };
+        // eslint-disable-next-line no-bitwise
+        const key = (line << 13) + character;
+        let position = this.positionCache.get(key);
+        if (!position) {
+            position = {
+                line: line,
+                character: character
+            };
+            this.positionCache.set(key, position);
+        }
+        return position;
     }
     /**
      * Convert a list of tokens into a string, including their leading whitespace
@@ -924,8 +1070,7 @@ class Util {
     tokensToString(tokens) {
         let result = '';
         //skip iterating the final token
-        for (let i = 0; i < tokens.length; i++) {
-            let token = tokens[i];
+        for (let token of tokens) {
             result += token.leadingWhitespace + token.text;
         }
         return result;
@@ -933,39 +1078,36 @@ class Util {
     /**
      * Convert a token into a BscType
      */
-    tokenToBscType(token, allowBrighterscriptTypes = true, currentNamespaceName) {
-        if (!token) {
-            return new DynamicType_1.DynamicType();
-        }
+    tokenToBscType(token) {
         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (token.kind) {
             case TokenKind_1.TokenKind.Boolean:
                 return new BooleanType_1.BooleanType(token.text);
             case TokenKind_1.TokenKind.True:
             case TokenKind_1.TokenKind.False:
-                return new BooleanType_1.BooleanType();
+                return BooleanType_1.BooleanType.instance;
             case TokenKind_1.TokenKind.Double:
                 return new DoubleType_1.DoubleType(token.text);
             case TokenKind_1.TokenKind.DoubleLiteral:
-                return new DoubleType_1.DoubleType();
+                return DoubleType_1.DoubleType.instance;
             case TokenKind_1.TokenKind.Dynamic:
                 return new DynamicType_1.DynamicType(token.text);
             case TokenKind_1.TokenKind.Float:
                 return new FloatType_1.FloatType(token.text);
             case TokenKind_1.TokenKind.FloatLiteral:
-                return new FloatType_1.FloatType();
+                return FloatType_1.FloatType.instance;
             case TokenKind_1.TokenKind.Function:
-                return new FunctionType_1.FunctionType();
+                return new FunctionType_1.FunctionType(token.text);
             case TokenKind_1.TokenKind.Integer:
                 return new IntegerType_1.IntegerType(token.text);
             case TokenKind_1.TokenKind.IntegerLiteral:
-                return new IntegerType_1.IntegerType();
+                return IntegerType_1.IntegerType.instance;
             case TokenKind_1.TokenKind.Invalid:
-                return new InvalidType_1.InvalidType(token.text);
+                return DynamicType_1.DynamicType.instance; // TODO: use InvalidType better new InvalidType(token.text);
             case TokenKind_1.TokenKind.LongInteger:
                 return new LongIntegerType_1.LongIntegerType(token.text);
             case TokenKind_1.TokenKind.LongIntegerLiteral:
-                return new LongIntegerType_1.LongIntegerType();
+                return LongIntegerType_1.LongIntegerType.instance;
             case TokenKind_1.TokenKind.Object:
                 return new ObjectType_1.ObjectType(token.text);
             case TokenKind_1.TokenKind.String:
@@ -974,59 +1116,303 @@ class Util {
             case TokenKind_1.TokenKind.TemplateStringExpressionBegin:
             case TokenKind_1.TokenKind.TemplateStringExpressionEnd:
             case TokenKind_1.TokenKind.TemplateStringQuasi:
-                return new StringType_1.StringType();
+                return StringType_1.StringType.instance;
             case TokenKind_1.TokenKind.Void:
                 return new VoidType_1.VoidType(token.text);
             case TokenKind_1.TokenKind.Identifier:
-                let typeText = token.text.trim().toLowerCase();
-                let typeClass;
-                switch (typeText) {
+                switch (token.text.toLowerCase()) {
                     case 'boolean':
-                        typeClass = new BooleanType_1.BooleanType(token.text);
-                        break;
+                        return new BooleanType_1.BooleanType(token.text);
                     case 'double':
-                        typeClass = new DoubleType_1.DoubleType(token.text);
-                        break;
+                        return new DoubleType_1.DoubleType(token.text);
+                    case 'dynamic':
+                        return new DynamicType_1.DynamicType(token.text);
                     case 'float':
-                        typeClass = new FloatType_1.FloatType(token.text);
-                        break;
+                        return new FloatType_1.FloatType(token.text);
                     case 'function':
-                        typeClass = new TypedFunctionType_1.TypedFunctionType(new DynamicType_1.DynamicType(token.text));
-                        break;
+                        return new FunctionType_1.FunctionType(token.text);
                     case 'integer':
-                        typeClass = new IntegerType_1.IntegerType(token.text);
-                        break;
+                        return new IntegerType_1.IntegerType(token.text);
                     case 'invalid':
-                        typeClass = new InvalidType_1.InvalidType(token.text);
-                        break;
+                        return DynamicType_1.DynamicType.instance; // TODO: use InvalidType better new InvalidType(token.text);
                     case 'longinteger':
-                        typeClass = new LongIntegerType_1.LongIntegerType(token.text);
-                        break;
+                        return new LongIntegerType_1.LongIntegerType(token.text);
                     case 'object':
-                        typeClass = new ObjectType_1.ObjectType(token.text);
-                        break;
+                        return new ObjectType_1.ObjectType(token.text);
                     case 'string':
-                        typeClass = new StringType_1.StringType(token.text);
-                        break;
+                        return new StringType_1.StringType(token.text);
                     case 'void':
-                        typeClass = new VoidType_1.VoidType(token.text);
-                        break;
-                    case 'dynamic':
-                        typeClass = new DynamicType_1.DynamicType(token.text);
-                        break;
+                        return new VoidType_1.VoidType(token.text);
+                }
+        }
+    }
+    /**
+     * Deciphers the correct types for fields based on docs
+     * https://developer.roku.com/en-ca/docs/references/scenegraph/xml-elements/interface.md
+     * @param typeDescriptor the type descriptor from the docs
+     * @returns {BscType} the known type, or dynamic
+     */
+    getNodeFieldType(typeDescriptor, lookupTable) {
+        const typeDescriptorLower = typeDescriptor.toLowerCase().trim();
+        const bscType = this.tokenToBscType((0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, typeDescriptorLower));
+        if (bscType) {
+            return bscType;
+        }
+        function getRect2dType() {
+            const rect2dType = new AssociativeArrayType_1.AssociativeArrayType();
+            rect2dType.addMember('height', {}, FloatType_1.FloatType.instance, SymbolTable_1.SymbolTypeFlag.runtime);
+            rect2dType.addMember('width', {}, FloatType_1.FloatType.instance, SymbolTable_1.SymbolTypeFlag.runtime);
+            rect2dType.addMember('x', {}, FloatType_1.FloatType.instance, SymbolTable_1.SymbolTypeFlag.runtime);
+            rect2dType.addMember('y', {}, FloatType_1.FloatType.instance, SymbolTable_1.SymbolTypeFlag.runtime);
+            return rect2dType;
+        }
+        function getColorType() {
+            return (0, types_1.unionTypeFactory)([IntegerType_1.IntegerType.instance, StringType_1.StringType.instance]);
+        }
+        if (typeDescriptorLower.startsWith('array of ')) {
+            let arrayOfTypeName = typeDescriptorLower.substring(9); //cut off beginning 'array of'
+            if (arrayOfTypeName.endsWith('s')) {
+                // remove "s" in "floats", etc.
+                arrayOfTypeName = arrayOfTypeName.substring(0, arrayOfTypeName.length - 1);
+            }
+            if (arrayOfTypeName.endsWith('\'')) {
+                // remove "'" in "float's", etc.
+                arrayOfTypeName = arrayOfTypeName.substring(0, arrayOfTypeName.length - 1);
+            }
+            let arrayType = this.getNodeFieldType(arrayOfTypeName, lookupTable);
+            return new types_1.ArrayType(arrayType);
+        }
+        else if (typeDescriptorLower.startsWith('option ')) {
+            const actualTypeName = typeDescriptorLower.substring('option '.length); //cut off beginning 'option '
+            return this.getNodeFieldType(actualTypeName, lookupTable);
+        }
+        else if (typeDescriptorLower.startsWith('value ')) {
+            const actualTypeName = typeDescriptorLower.substring('value '.length); //cut off beginning 'value '
+            return this.getNodeFieldType(actualTypeName, lookupTable);
+        }
+        else if (typeDescriptorLower === 'uri') {
+            return StringType_1.StringType.instance;
+        }
+        else if (typeDescriptorLower === 'color') {
+            return getColorType();
+        }
+        else if (typeDescriptorLower === 'vector2d' || typeDescriptorLower === 'floatarray') {
+            return new types_1.ArrayType(FloatType_1.FloatType.instance);
+        }
+        else if (typeDescriptorLower === 'vector2darray') {
+            return new types_1.ArrayType(new types_1.ArrayType(FloatType_1.FloatType.instance));
+        }
+        else if (typeDescriptorLower === 'intarray') {
+            return new types_1.ArrayType(IntegerType_1.IntegerType.instance);
+        }
+        else if (typeDescriptorLower === 'colorarray') {
+            return new types_1.ArrayType(getColorType());
+        }
+        else if (typeDescriptorLower === 'boolarray') {
+            return new types_1.ArrayType(BooleanType_1.BooleanType.instance);
+        }
+        else if (typeDescriptorLower === 'stringarray' || typeDescriptorLower === 'strarray') {
+            return new types_1.ArrayType(StringType_1.StringType.instance);
+        }
+        else if (typeDescriptorLower === 'int') {
+            return IntegerType_1.IntegerType.instance;
+        }
+        else if (typeDescriptorLower === 'time') {
+            return DoubleType_1.DoubleType.instance;
+        }
+        else if (typeDescriptorLower === 'str') {
+            return StringType_1.StringType.instance;
+        }
+        else if (typeDescriptorLower === 'bool') {
+            return BooleanType_1.BooleanType.instance;
+        }
+        else if (typeDescriptorLower === 'array') {
+            return new types_1.ArrayType();
+        }
+        else if (typeDescriptorLower === 'assocarray' || typeDescriptorLower === 'associative array' || typeDescriptorLower === 'associativearray') {
+            return new AssociativeArrayType_1.AssociativeArrayType();
+        }
+        else if (typeDescriptorLower === 'node') {
+            return ComponentType_1.ComponentType.instance;
+        }
+        else if (typeDescriptorLower === 'nodearray') {
+            return new types_1.ArrayType(ComponentType_1.ComponentType.instance);
+        }
+        else if (typeDescriptorLower === 'rect2d') {
+            return getRect2dType();
+        }
+        else if (typeDescriptorLower === 'rect2darray') {
+            return new types_1.ArrayType(getRect2dType());
+        }
+        else if (lookupTable) {
+            //try doing a lookup
+            return lookupTable.getSymbolType(typeDescriptorLower, { flags: SymbolTable_1.SymbolTypeFlag.typetime });
+        }
+        //  TODO: Handle  'rect2d', 'rect2dArray',
+        return DynamicType_1.DynamicType.instance;
+    }
+    /**
+     * 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) {
+        if (((0, reflection_1.isAnyReferenceType)(leftType) && !leftType.isResolvable()) ||
+            ((0, reflection_1.isAnyReferenceType)(rightType) && !rightType.isResolvable())) {
+            return new types_1.BinaryOperatorReferenceType(leftType, operator, rightType, (lhs, op, rhs) => {
+                return this.binaryOperatorResultType(lhs, op, rhs);
+            });
+        }
+        if ((0, reflection_1.isEnumMemberType)(leftType)) {
+            leftType = leftType.underlyingType;
+        }
+        if ((0, reflection_1.isEnumMemberType)(rightType)) {
+            rightType = rightType.underlyingType;
+        }
+        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 hasDynamic = (0, reflection_1.isDynamicType)(leftType) || (0, reflection_1.isDynamicType)(rightType);
+        let bothNumbers = (0, reflection_1.isNumberType)(leftType) && (0, reflection_1.isNumberType)(rightType);
+        let bothStrings = (0, reflection_1.isStringType)(leftType) && (0, reflection_1.isStringType)(rightType);
+        let eitherBooleanOrNum = ((0, reflection_1.isNumberType)(leftType) || (0, reflection_1.isBooleanType)(leftType)) && ((0, reflection_1.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 / dynamic
+                if (hasDynamic || 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;
                 }
-                if (!typeClass && allowBrighterscriptTypes) {
-                    typeClass = new LazyType_1.LazyType((context) => {
-                        var _a, _b;
-                        return (_b = (_a = context === null || context === void 0 ? void 0 : context.scope) === null || _a === void 0 ? void 0 : _a.getNamedTypeStatement(typeText, currentNamespaceName === null || currentNamespaceName === void 0 ? void 0 : currentNamespaceName.getName())) === null || _b === void 0 ? void 0 : _b.getThisBscType();
-                    });
+                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 ((0, reflection_1.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 ((0, reflection_1.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;
                 }
-                return typeClass;
+                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
+     * @returns the file extension (i.e. ".d.bs", ".bs", ".brs", ".xml", ".jpg", etc...)
      */
     getExtension(filePath) {
         filePath = filePath.toLowerCase();
@@ -1034,10 +1420,7 @@ class Util {
             return '.d.bs';
         }
         else {
-            const idx = filePath.lastIndexOf('.');
-            if (idx > -1) {
-                return filePath.substring(idx);
-            }
+            return path.extname(filePath).toLowerCase();
         }
     }
     /**
@@ -1060,6 +1443,10 @@ class Util {
                     else if (typeof theExport === 'function') {
                         plugin = theExport();
                     }
+                    else {
+                        //this should never happen; somehow an invalid plugin has made it into here
+                        throw new Error(`TILT: Encountered an invalid plugin: ${String(plugin)}`);
+                    }
                     if (!plugin.name) {
                         plugin.name = pathOrModule;
                     }
@@ -1091,7 +1478,7 @@ class Util {
             }
             if ((0, reflection_1.isVariableExpression)(expression)) {
                 variableExpressions.push(expression);
-                uniqueVarNames.add(expression.name.text);
+                uniqueVarNames.add(expression.tokens.name.text);
             }
         }
         // Collect all expressions. Most of these expressions are fairly small so this should be quick!
@@ -1103,6 +1490,10 @@ class Util {
         expressionWalker(expression);
         return { expressions: expressions, varExpressions: variableExpressions, uniqueVarNames: [...uniqueVarNames] };
     }
+    concatAnnotationLeadingTrivia(stmt, otherTrivia) {
+        var _a, _b;
+        return [...((_b = (_a = stmt.annotations) === null || _a === void 0 ? void 0 : _a.map(anno => anno.getLeadingTrivia()).flat()) !== null && _b !== void 0 ? _b : []), ...otherTrivia];
+    }
     /**
      * Create a SourceNode that maps every line to itself. Useful for creating maps for files
      * that haven't changed at all, but we still need the map
@@ -1117,86 +1508,39 @@ class Util {
         }
         return new source_map_1.SourceNode(null, null, source, chunks);
     }
-    /**
-     * Creates a new SGAttribute object, but keeps the existing Range references (since those should be immutable)
-     */
-    cloneSGAttribute(attr, value) {
-        return new SGTypes_1.SGAttribute({ text: attr.tokens.key.text, range: attr.range }, { text: '=' }, { text: '"' }, { text: value, range: attr.tokens.value.range }, { text: '"' });
-    }
-    /**
-     * Shorthand for creating a new source node
-     */
-    sourceNode(source, locatable, code) {
-        if (code !== undefined) {
-            const node = new source_map_1.SourceNode(null, null, source, code);
-            if (locatable.range) {
-                //convert 0-based Range line to 1-based SourceNode line
-                node.line = locatable.range.start.line + 1;
-                //SourceNode columns are 0-based so no conversion necessary
-                node.column = locatable.range.start.character;
-            }
-            return node;
-        }
-    }
-    /**
-     * Remove leading simple protocols from a path (if present)
-     */
-    removeProtocol(pkgPath) {
-        let match = /^[-a-z_]+:\//.exec(pkgPath);
-        if (match) {
-            return pkgPath.substring(match[0].length);
-        }
-        else {
-            return pkgPath;
-        }
-    }
     /**
      * Converts a path into a standardized format (drive letter to lower, remove extra slashes, use single slash type, resolve relative parts, etc...)
      */
     standardizePath(thePath) {
         return exports.util.driveLetterToLower((0, roku_deploy_1.standardizePath)(thePath));
     }
-    /**
-     * Copy the version of bslib from local node_modules to the staging folder
-     */
-    async copyBslibToStaging(stagingDir) {
-        //copy bslib to the output directory
-        await fsExtra.ensureDir(standardizePath(`${stagingDir}/source`));
-        // eslint-disable-next-line
-        const bslib = require('@rokucommunity/bslib');
-        let source = bslib.source;
-        //apply the `bslib_` prefix to the functions
-        let match;
-        const positions = [];
-        const regexp = /^(\s*(?:function|sub)\s+)([a-z0-9_]+)/mg;
-        // eslint-disable-next-line no-cond-assign
-        while (match = regexp.exec(source)) {
-            positions.push(match.index + match[1].length);
-        }
-        for (let i = positions.length - 1; i >= 0; i--) {
-            const position = positions[i];
-            source = source.slice(0, position) + 'bslib_' + source.slice(position);
-        }
-        await fsExtra.writeFile(`${stagingDir}/source/bslib.brs`, source);
-    }
     /**
      * Given a Diagnostic or BsDiagnostic, return a deep clone of the diagnostic.
      * @param diagnostic the diagnostic to clone
      * @param relatedInformationFallbackLocation a default location to use for all `relatedInformation` entries that are missing a location
      */
-    toDiagnostic(diagnostic, fileUri) {
+    toDiagnostic(diagnostic, relatedInformationFallbackLocation) {
         var _a;
+        let relatedInformation = (_a = diagnostic.relatedInformation) !== null && _a !== void 0 ? _a : [];
+        if (relatedInformation.length > diagnosticUtils_1.MAX_RELATED_INFOS_COUNT) {
+            const relatedInfoLength = relatedInformation.length;
+            relatedInformation = relatedInformation.slice(0, diagnosticUtils_1.MAX_RELATED_INFOS_COUNT);
+            relatedInformation.push({
+                message: `...and ${relatedInfoLength - diagnosticUtils_1.MAX_RELATED_INFOS_COUNT} more`,
+                location: exports.util.createLocation('   ', exports.util.createRange(0, 0, 0, 0))
+            });
+        }
         return {
             severity: diagnostic.severity,
             range: diagnostic.range,
             message: diagnostic.message,
-            relatedInformation: (_a = diagnostic.relatedInformation) === null || _a === void 0 ? void 0 : _a.map(x => {
+            relatedInformation: relatedInformation.map(x => {
                 //clone related information just in case a plugin added circular ref info here
                 const clone = Object.assign({}, x);
                 if (!clone.location) {
                     // use the fallback location if available
-                    if (fileUri) {
-                        clone.location = exports.util.createLocation(fileUri, diagnostic.range);
+                    if (relatedInformationFallbackLocation) {
+                        clone.location = exports.util.createLocation(relatedInformationFallbackLocation, diagnostic.range);
                     }
                     else {
                         //remove this related information so it doesn't bring crash the language server
@@ -1205,81 +1549,16 @@ class Util {
                 }
                 return clone;
                 //filter out null relatedInformation items
-            }).filter(x => x),
+            }).filter((x) => Boolean(x)),
             code: diagnostic.code,
             source: 'brs'
         };
     }
     /**
-     * Gets the minimum and maximum number of allowed params
-     * @param params The list of callable parameters to check
-     * @returns the minimum and maximum number of allowed params
-     */
-    getMinMaxParamCount(params) {
-        //get min/max parameter count for callable
-        let minParams = 0;
-        let maxParams = 0;
-        let continueCheckingForRequired = true;
-        for (let param of params) {
-            maxParams++;
-            //optional parameters must come last, so we can assume that minParams won't increase once we hit
-            //the first isOptional
-            if (continueCheckingForRequired && !param.isOptional) {
-                minParams++;
-            }
-            else {
-                continueCheckingForRequired = false;
-            }
-        }
-        return { min: minParams, max: maxParams };
-    }
-    /**
-     * Gets the minimum and maximum number of allowed params for ALL functions with the name of the function call
-     * @param callablesByLowerName The map of callable containers
-     * @param expCall function call expression to use for the name
-     * @returns the minimum and maximum number of allowed params
+     * Get the first locatable item found at the specified position
+     * @param locatables an array of items that have a `range` property
+     * @param position the position that the locatable must contain
      */
-    getMinMaxParamCountByFunctionCall(callablesByLowerName, expCall) {
-        const callablesWithThisName = this.getCallableContainersByName(callablesByLowerName, expCall);
-        if ((callablesWithThisName === null || callablesWithThisName === void 0 ? void 0 : callablesWithThisName.length) > 0) {
-            const paramCount = { min: exports.MAX_PARAM_COUNT, max: 0 };
-            for (const callableContainer of callablesWithThisName) {
-                let specificParamCount = exports.util.getMinMaxParamCount(callableContainer.callable.params);
-                if (specificParamCount.max > paramCount.max) {
-                    paramCount.max = specificParamCount.max;
-                }
-                if (specificParamCount.min < paramCount.min) {
-                    paramCount.min = specificParamCount.min;
-                }
-            }
-            return paramCount;
-        }
-    }
-    /**
-     * Finds the array of callables from a container map, based on the name of the function call
-     * If the callable was called in a function in a namespace, functions in that namespace are preferred
-     * @param callablesByLowerName The map of callable containers
-     * @param expCall function call expression to use for the name
-     * @return an array with callable containers - could be empty if nothing was found
-     */
-    getCallableContainersByName(callablesByLowerName, expCall) {
-        let callablesWithThisName = [];
-        const lowerName = expCall.name.text.toLowerCase();
-        if (expCall.functionExpression.namespaceName) {
-            // prefer namespaced function
-            const potentialNamespacedCallable = expCall.functionExpression.namespaceName.getName(Parser_1.ParseMode.BrightScript).toLowerCase() + '_' + lowerName;
-            callablesWithThisName = callablesByLowerName.get(potentialNamespacedCallable.toLowerCase());
-        }
-        if (!callablesWithThisName || callablesWithThisName.length === 0) {
-            // just try it as is
-            callablesWithThisName = callablesByLowerName.get(lowerName);
-        }
-        return callablesWithThisName;
-    }
-    /**
-    * Get the first locatable item found at the specified position
-    * @param position
-    */
     getFirstLocatableAt(locatables, position) {
         for (let token of locatables) {
             if (exports.util.rangeContains(token.range, position)) {
@@ -1332,8 +1611,7 @@ class Util {
         const chunks = text.split(separator);
         const result = [];
         let offset = 0;
-        for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i];
+        for (let chunk of chunks) {
             //only keep nonzero chunks
             if (chunk.length > 0) {
                 result.push({
@@ -1345,56 +1623,83 @@ class Util {
         }
         return result;
     }
-    /*
+    /**
      * Wrap the given code in a markdown code fence (with the language)
      */
     mdFence(code, language = '') {
         return '```' + language + '\n' + code + '\n```';
     }
-    /**
-     * Finds a callable from a container map based on the name AND number of arguments
-     * If the callable was called in a function in a namespace, functions in that namespace are preferred
-     * The first callable that matches the name AND will accept the number of arguments given is returned
-     * @return a callable containers that matches the call
-     */
-    getCallableContainerByFunctionCall(callablesByLowerName, expCall) {
-        const callablesWithThisName = this.getCallableContainersByName(callablesByLowerName, expCall);
-        if ((callablesWithThisName === null || callablesWithThisName === void 0 ? void 0 : callablesWithThisName.length) > 0) {
-            for (const callableContainer of callablesWithThisName) {
-                const paramCount = exports.util.getMinMaxParamCount(callableContainer.callable.params);
-                if (paramCount.min <= expCall.args.length && paramCount.max >= expCall.args.length) {
-                    return callableContainer;
-                }
-            }
-        }
-    }
     /**
      * Gets each part of the dotted get.
-     * @param expression
+     * @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(expression) {
+    getAllDottedGetParts(node) {
+        //this is a hot function and has been optimized. Don't rewrite unless necessary
         const parts = [];
-        let nextPart = expression;
-        while (nextPart) {
-            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.isNamespacedVariableNameExpression)(nextPart)) {
-                nextPart = nextPart.expression;
-            }
-            else if ((0, reflection_1.isVariableExpression)(nextPart)) {
-                parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.name);
-                break;
-            }
-            else {
-                //we found a non-DottedGet expression, so return because this whole operation is invalid.
-                return undefined;
+        let nextPart = node;
+        loop: while (nextPart) {
+            switch (nextPart === null || nextPart === void 0 ? void 0 : nextPart.kind) {
+                case AstNode_1.AstNodeKind.AssignmentStatement:
+                    return [node.tokens.name];
+                case AstNode_1.AstNodeKind.DottedGetExpression:
+                    parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.tokens.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.tokens.name);
+                    break loop;
+                case AstNode_1.AstNodeKind.LiteralExpression:
+                    parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.tokens.value);
+                    break loop;
+                case AstNode_1.AstNodeKind.IndexedGetExpression:
+                    nextPart = nextPart.obj;
+                    continue;
+                case AstNode_1.AstNodeKind.FunctionParameterExpression:
+                    return [nextPart.tokens.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;
+        // 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 result;
+    }
     /**
      * Break an expression into each part.
      */
@@ -1408,7 +1713,7 @@ class Util {
             else if ((0, reflection_1.isCallExpression)(nextPart) || (0, reflection_1.isCallfuncExpression)(nextPart)) {
                 nextPart = nextPart.callee;
             }
-            else if ((0, reflection_1.isNamespacedVariableNameExpression)(nextPart)) {
+            else if ((0, reflection_1.isTypeExpression)(nextPart)) {
                 nextPart = nextPart.expression;
             }
             else {
@@ -1418,6 +1723,44 @@ class Util {
         }
         return parts;
     }
+    /**
+     * Break an expression into each part, and return any VariableExpression or DottedGet expresisons from left-to-right.
+     */
+    getDottedGetPath(expression) {
+        let parts = [];
+        let nextPart = expression;
+        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.reverse();
+    }
     /**
      * Returns an integer if valid, or undefined. Eliminates checking for NaN
      */
@@ -1440,19 +1783,156 @@ class Util {
     validateTooDeepFile(file) {
         var _a;
         //find any files nested too deep
-        let pkgPath = (_a = file.pkgPath) !== null && _a !== void 0 ? _a : file.pkgPath.toString();
-        let rootFolder = pkgPath.replace(/^pkg:\//, '').split(/[\\\/]/)[0].toLowerCase();
+        let destPath = (_a = file === null || file === void 0 ? void 0 : file.destPath) === null || _a === void 0 ? void 0 : _a.toString();
+        let rootFolder = destPath === null || destPath === void 0 ? void 0 : destPath.replace(/^pkg:/, '').split(/[\\\/]/)[0].toLowerCase();
         if ((0, reflection_1.isBrsFile)(file) && rootFolder !== 'source') {
             return;
         }
         if ((0, reflection_1.isXmlFile)(file) && rootFolder !== 'components') {
             return;
         }
-        let fileDepth = this.getParentDirectoryCount(pkgPath);
+        let fileDepth = this.getParentDirectoryCount(destPath);
         if (fileDepth >= 8) {
             file.addDiagnostics([Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.detectedTooDeepFileSource(fileDepth)), { file: file, range: this.createRange(0, 0, 0, Number.MAX_VALUE) })]);
         }
     }
+    /**
+     * Find the index of the last item in the array that matches.
+     */
+    findLastIndex(array, matcher) {
+        for (let i = array.length - 1; i >= 0; i--) {
+            if (matcher(array[i])) {
+                return i;
+            }
+        }
+    }
+    processTypeChain(typeChain) {
+        var _a, _b, _c, _d;
+        let fullChainName = '';
+        let fullErrorName = '';
+        let itemName = '';
+        let previousTypeName = '';
+        let parentTypeName = '';
+        let errorRange;
+        let containsDynamic = false;
+        for (let i = 0; i < typeChain.length; i++) {
+            const chainItem = typeChain[i];
+            const dotSep = (_b = (_a = chainItem.separatorToken) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '.';
+            if (i > 0) {
+                fullChainName += dotSep;
+            }
+            fullChainName += chainItem.name;
+            parentTypeName = previousTypeName;
+            fullErrorName = previousTypeName ? `${previousTypeName}${dotSep}${chainItem.name}` : chainItem.name;
+            previousTypeName = (_d = (_c = chainItem.type) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : '';
+            itemName = chainItem.name;
+            containsDynamic = containsDynamic || ((0, reflection_1.isDynamicType)(chainItem.type) && !(0, reflection_1.isAnyReferenceType)(chainItem.type));
+            if (!chainItem.isResolved) {
+                errorRange = chainItem.range;
+                break;
+            }
+        }
+        return {
+            itemName: itemName,
+            itemParentTypeName: parentTypeName,
+            fullNameOfItem: fullErrorName,
+            fullChainName: fullChainName,
+            range: errorRange,
+            containsDynamic: containsDynamic
+        };
+    }
+    isInTypeExpression(expression) {
+        //TODO: this is much faster than node.findAncestor(), but may need to be updated for "complicated" type expressions
+        if ((0, reflection_1.isTypeExpression)(expression) ||
+            (0, reflection_1.isTypeExpression)(expression.parent) ||
+            (0, reflection_1.isTypedArrayExpression)(expression) ||
+            (0, reflection_1.isTypedArrayExpression)(expression.parent)) {
+            return true;
+        }
+        if ((0, reflection_1.isBinaryExpression)(expression.parent)) {
+            let currentExpr = expression.parent;
+            while ((0, reflection_1.isBinaryExpression)(currentExpr) && currentExpr.tokens.operator.kind === TokenKind_1.TokenKind.Or) {
+                currentExpr = currentExpr.parent;
+            }
+            return (0, reflection_1.isTypeExpression)(currentExpr) || (0, reflection_1.isTypedArrayExpression)(currentExpr);
+        }
+        return false;
+    }
+    setContainsUnresolvedSymbol(symbolLowerNameSet, symbol) {
+        var _a, _b;
+        const possibleOriginalSymbolNamesLower = [];
+        let nameSoFar = '';
+        for (const tce of symbol.typeChain) {
+            if (nameSoFar.length > 0) {
+                nameSoFar += '.';
+            }
+            nameSoFar += tce.name.toLowerCase();
+            possibleOriginalSymbolNamesLower.push(nameSoFar);
+        }
+        const possibleNamespace = (_b = (_a = symbol.containingNamespaces) === null || _a === void 0 ? void 0 : _a.join('.')) !== null && _b !== void 0 ? _b : '';
+        for (const possibleNameLower of possibleOriginalSymbolNamesLower) {
+            if (symbolLowerNameSet.has(possibleNameLower)) {
+                return true;
+            }
+            if (possibleNamespace) {
+                const fullName = possibleNamespace + '.' + possibleNameLower;
+                if (symbolLowerNameSet.has(fullName.toLowerCase())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    truncate(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        let leadingText = options.leadingText;
+        let items = (_a = options === null || options === void 0 ? void 0 : options.items) !== null && _a !== void 0 ? _a : [];
+        let trailingText = (_b = options === null || options === void 0 ? void 0 : options.trailingText) !== null && _b !== void 0 ? _b : '';
+        let maxLength = (_c = options === null || options === void 0 ? void 0 : options.maxLength) !== null && _c !== void 0 ? _c : 160;
+        let itemSeparator = (_d = options === null || options === void 0 ? void 0 : options.itemSeparator) !== null && _d !== void 0 ? _d : ', ';
+        let partBuilder = (_e = options === null || options === void 0 ? void 0 : options.partBuilder) !== null && _e !== void 0 ? _e : ((x) => x.toString());
+        let parts = [];
+        let length = leadingText.length + ((_f = trailingText === null || trailingText === void 0 ? void 0 : trailingText.length) !== null && _f !== void 0 ? _f : 0);
+        //calculate the max number of items we could fit in the given space
+        for (let i = 0; i < items.length; i++) {
+            let part = partBuilder(items[i]);
+            if (i > 0) {
+                part = itemSeparator + part;
+            }
+            parts.push(part);
+            length += part.length;
+            //exit the loop if we've maxed out our length
+            if (length >= maxLength) {
+                break;
+            }
+        }
+        let message;
+        //we have enough space to include all the parts
+        if (parts.length >= items.length) {
+            message = leadingText + parts.join('') + trailingText;
+            //we require truncation
+        }
+        else {
+            //account for truncation message length including max possible "more" items digits, trailing text length, and the separator between last item and trailing text
+            length = leadingText.length + `...and ${items.length} more`.length + itemSeparator.length + ((_g = trailingText === null || trailingText === void 0 ? void 0 : trailingText.length) !== null && _g !== void 0 ? _g : 0);
+            message = leadingText;
+            for (let i = 0; i < parts.length; i++) {
+                //always include at least 2 items. if this part would overflow the max, then skip it and finalize the message
+                if (i > 1 && length + parts[i].length > maxLength) {
+                    message += itemSeparator + `...and ${items.length - i} more` + trailingText;
+                    return message;
+                }
+                else {
+                    message += parts[i];
+                    length += parts[i].length;
+                }
+            }
+        }
+        return message;
+    }
+    getAstNodeFriendlyName(node) {
+        return node === null || node === void 0 ? void 0 : node.kind.replace(/Statement|Expression/g, '');
+    }
 }
 exports.Util = Util;
 /**
@@ -1469,5 +1949,4 @@ function standardizePath(stringParts, ...expressions) {
 exports.standardizePath = standardizePath;
 exports.util = new Util();
 exports.default = exports.util;
-exports.MAX_PARAM_COUNT = 32;
 //# sourceMappingURL=util.js.map