brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/util.js

@@ -5,35 +5,74 @@ const fs = require("fs");
 const fsExtra = require("fs-extra");
 const jsonc_parser_1 = require("jsonc-parser");
 const path = require("path");
-const rokuDeploy = require("roku-deploy");
+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");
+const interfaces_1 = require("./interfaces");
 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");
 const ObjectType_1 = require("./types/ObjectType");
 const StringType_1 = require("./types/StringType");
 const VoidType_1 = require("./types/VoidType");
 const Parser_1 = require("./parser/Parser");
-const Logger_1 = require("./Logger");
-const lexer_1 = require("./lexer");
-const astUtils_1 = require("./astUtils");
-const CustomType_1 = require("./types/CustomType");
+const logging_1 = require("./logging");
+const Token_1 = require("./lexer/Token");
+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 creators_1 = require("./astUtils/creators");
+const diagnosticUtils_1 = require("./diagnosticUtils");
+const UnionType_1 = require("./types/UnionType");
+const ArrayType_1 = require("./types/ArrayType");
+const ReferenceType_1 = require("./types/ReferenceType");
+const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
+const ComponentType_1 = require("./types/ComponentType");
+const FunctionType_1 = require("./types/FunctionType");
+const helpers_1 = require("./types/helpers");
+const InvalidType_1 = require("./types/InvalidType");
+const types_1 = require("./types");
+const IntersectionType_1 = require("./types/IntersectionType");
 class Util {
+    constructor() {
+        this.isWindows = process.platform === 'win32';
+        this.standardizePathCache = new Map();
+        this.pathToURICache = new Map();
+    }
     clearConsole() {
         // process.stdout.write('\x1Bc');
     }
+    /**
+     * Get the version of brighterscript
+     */
+    getBrighterScriptVersion() {
+        try {
+            return fsExtra.readJsonSync(`${__dirname}/../package.json`).version;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    /**
+     * Returns the number of parent directories in the filPath
+     */
+    getParentDirectoryCount(filePath) {
+        if (!filePath) {
+            return -1;
+        }
+        else {
+            return filePath.replace(/^pkg:/, '').split(/[\\\/]/).length - 1;
+        }
+    }
     /**
      * Determine if the file exists
-     * @param filePath
      */
     async pathExists(filePath) {
         if (!filePath) {
@@ -45,7 +84,6 @@ class Util {
     }
     /**
      * Determine if the file exists
-     * @param filePath
      */
     pathExistsSync(filePath) {
         if (!filePath) {
@@ -59,40 +97,39 @@ class Util {
      * Determine if this path is a directory
      */
     isDirectorySync(dirPath) {
-        return 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;
+        try {
+            return dirPath !== undefined && fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
+        }
+        catch (e) {
+            return false;
         }
-        return pkgPath;
     }
     /**
-     * Determine if the given path starts with a protocol
+     * Read a file from disk. If a failure occurrs, simply return undefined
+     * @param filePath path to the file
+     * @returns the string contents, or undefined if the file doesn't exist
      */
-    startsWithProtocol(path) {
-        return !!/^[-a-z]+:\//i.exec(path);
+    readFileSync(filePath) {
+        try {
+            return fsExtra.readFileSync(filePath);
+        }
+        catch (e) {
+            return undefined;
+        }
     }
     /**
-     * Given a path to a file/directory, replace all path separators with the current system's version.
-     * @param filePath
+     * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
      */
-    pathSepNormalize(filePath, separator) {
-        if (!filePath) {
-            return filePath;
-        }
-        separator = separator ? separator : path.sep;
-        return filePath.replace(/[\\/]+/g, separator);
+    sanitizePkgPath(pkgPath) {
+        //convert all slashes to forwardslash
+        pkgPath = pkgPath.replace(/[\/\\]+/g, '/');
+        //ensure every path has the leading pkg:/
+        return 'pkg:/' + pkgPath.replace(/^pkg:\//i, '');
     }
     /**
      * 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();
@@ -126,15 +163,16 @@ 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;
         if (configFilePath) {
             //if the config file path starts with question mark, then it's optional. return undefined if it doesn't exist
             if (configFilePath.startsWith('?')) {
@@ -155,16 +193,24 @@ class Util {
             //load the project file
             let projectFileContents = fsExtra.readFileSync(configFilePath).toString();
             let parseErrors = [];
-            let projectConfig = jsonc_parser_1.parse(projectFileContents, parseErrors);
+            let projectConfig = (_a = (0, jsonc_parser_1.parse)(projectFileContents, parseErrors, {
+                allowEmptyContent: true,
+                allowTrailingComma: true,
+                disallowComments: false
+            })) !== null && _a !== void 0 ? _a : {};
             if (parseErrors.length > 0) {
                 let err = parseErrors[0];
-                let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.bsConfigJsonHasSyntaxErrors(jsonc_parser_1.printParseErrorCode(parseErrors[0].error))), { file: {
-                        srcPath: configFilePath
-                    }, range: this.getRangeFromOffsetLength(projectFileContents, err.offset, err.length) });
+                let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.syntaxError(`Syntax errors in bsconfig.json: ${(0, jsonc_parser_1.printParseErrorCode)(parseErrors[0].error)}`)), { location: {
+                        uri: this.pathToUri(configFilePath),
+                        range: this.getRangeFromOffsetLength(projectFileContents, err.offset, err.length)
+                    } });
                 throw diagnostic; //eslint-disable-line @typescript-eslint/no-throw-literal
             }
-            this.resolvePluginPaths(projectConfig, configFilePath);
             let projectFileCwd = path.dirname(configFilePath);
+            //`plugins` paths should be relative to the current bsconfig
+            this.resolvePathsRelativeTo(projectConfig, 'plugins', projectFileCwd);
+            //`require` paths should be relative to cwd
+            exports.util.resolvePathsRelativeTo(projectConfig, 'require', projectFileCwd);
             let result;
             //if the project has a base file, load it
             if (projectConfig && typeof projectConfig.extends === 'string') {
@@ -179,75 +225,50 @@ class Util {
                 result._ancestors = parentProjectPaths;
             }
             //make any paths in the config absolute (relative to the CURRENT config file)
-            if (result.outFile) {
-                result.outFile = path.resolve(projectFileCwd, result.outFile);
-            }
             if (result.rootDir) {
                 result.rootDir = path.resolve(projectFileCwd, result.rootDir);
             }
+            if (result.outDir) {
+                result.outDir = path.resolve(projectFileCwd, result.outDir);
+            }
             if (result.cwd) {
                 result.cwd = path.resolve(projectFileCwd, result.cwd);
             }
+            if (result.sourceRoot && result.resolveSourceRoot) {
+                result.sourceRoot = path.resolve(projectFileCwd, result.sourceRoot);
+            }
             return result;
         }
     }
     /**
-     * Relative paths to scripts in plugins should be resolved relatively to the bsconfig file
-     * and de-duplicated
-     * @param config Parsed configuration
-     * @param configFilePath Path of the configuration file
+     * Convert relative paths to absolute paths, relative to the given directory. Also de-dupes the paths. Modifies the array in-place
+     * @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
      */
-    resolvePluginPaths(config, configFilePath) {
+    resolvePathsRelativeTo(collection, key, relativeDir) {
         var _a;
-        if (((_a = config.plugins) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            const relPath = path.dirname(configFilePath);
-            const exists = {};
-            config.plugins = config.plugins.map(p => {
-                return (p === null || p === void 0 ? void 0 : p.startsWith('.')) ? path.resolve(relPath, p) : p;
-            }).filter(p => {
-                if (!p || exists[p]) {
-                    return false;
-                }
-                exists[p] = true;
-                return true;
-            });
-        }
-    }
-    /**
-     * Do work within the scope of a changed current working directory
-     * @param targetCwd
-     * @param callback
-     */
-    cwdWork(targetCwd, callback) {
-        let originalCwd = process.cwd();
-        if (targetCwd) {
-            process.chdir(targetCwd);
-        }
-        let result;
-        let err;
-        try {
-            result = callback();
-        }
-        catch (e) {
-            err = e;
-        }
-        if (targetCwd) {
-            process.chdir(originalCwd);
+        if (!collection[key]) {
+            return;
         }
-        if (err) {
-            throw err;
-        }
-        else {
-            return result;
+        const result = new Set();
+        for (const p of (_a = collection[key]) !== null && _a !== void 0 ? _a : []) {
+            if (p) {
+                result.add((p === null || p === void 0 ? void 0 : p.startsWith('.')) ? path.resolve(relativeDir, p) : p);
+            }
         }
+        collection[key] = [...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({});
+        let result = this.normalizeConfig(Object.assign({}, config));
+        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);
@@ -257,7 +278,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
@@ -266,42 +287,81 @@ 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.deploy = config.deploy === true ? true : false;
-        //use default options from rokuDeploy
-        config.files = (_a = config.files) !== null && _a !== void 0 ? _a : rokuDeploy.getOptions().files;
-        config.createPackage = config.createPackage === false ? false : true;
-        let rootFolderName = path.basename(process.cwd());
-        config.outFile = (_b = config.outFile) !== null && _b !== void 0 ? _b : `./out/${rootFolderName}.zip`;
-        config.sourceMap = config.sourceMap === true;
-        config.username = (_c = config.username) !== null && _c !== void 0 ? _c : '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 = (_d = config.ignoreErrorCodes) !== null && _d !== void 0 ? _d : [];
-        config.diagnosticFilters = (_e = config.diagnosticFilters) !== null && _e !== void 0 ? _e : [];
-        config.plugins = (_f = config.plugins) !== null && _f !== void 0 ? _f : [];
-        config.autoImportComponentScript = config.autoImportComponentScript === true ? true : false;
-        config.showDiagnosticsInConsole = config.showDiagnosticsInConsole === false ? false : true;
-        config.sourceRoot = config.sourceRoot ? standardizePath(config.sourceRoot) : undefined;
-        config.cwd = (_g = config.cwd) !== null && _g !== void 0 ? _g : process.cwd();
-        config.emitDefinitions = config.emitDefinitions === true ? true : false;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        config = config !== null && config !== void 0 ? config : {};
+        const cwd = (_a = config.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+        let logLevel = logging_1.LogLevel.log;
         if (typeof config.logLevel === 'string') {
-            config.logLevel = Logger_1.LogLevel[config.logLevel.toLowerCase()];
+            logLevel = (_b = logging_1.LogLevel[config.logLevel.toLowerCase()]) !== null && _b !== void 0 ? _b : logging_1.LogLevel.log;
+        }
+        let bslibDestinationDir = (_c = config.bslibDestinationDir) !== null && _c !== void 0 ? _c : 'source';
+        if (bslibDestinationDir !== 'source') {
+            // strip leading and trailing slashes
+            bslibDestinationDir = bslibDestinationDir.replace(/^(\/*)(.*?)(\/*)$/, '$2');
+        }
+        let noEmit;
+        if ('noEmit' in config) {
+            noEmit = config.noEmit;
         }
-        config.logLevel = (_h = config.logLevel) !== null && _h !== void 0 ? _h : Logger_1.LogLevel.log;
-        return config;
+        else if ('copyToStaging' in config) {
+            noEmit = !config.copyToStaging; //invert the old value
+        }
+        else {
+            noEmit = false; //default case
+        }
+        let outDir;
+        if ('outDir' in config) {
+            outDir = (_d = config.outDir) !== null && _d !== void 0 ? _d : './out';
+        }
+        else if ('stagingFolderPath' in config) {
+            outDir = config.stagingFolderPath;
+        }
+        else if ('stagingDir' in config) {
+            outDir = config.stagingDir;
+        }
+        else {
+            outDir = './out'; //default case
+        }
+        const configWithDefaults = {
+            cwd: cwd,
+            //use default files array from rokuDeploy
+            files: (_e = config.files) !== null && _e !== void 0 ? _e : [...roku_deploy_1.DefaultFiles],
+            outDir: outDir,
+            sourceMap: config.sourceMap === true,
+            relativeSourceMaps: config.relativeSourceMaps === true,
+            watch: config.watch === true ? true : false,
+            emitFullPaths: config.emitFullPaths === true ? true : false,
+            noEmit: noEmit,
+            ignoreErrorCodes: (_f = config.ignoreErrorCodes) !== null && _f !== void 0 ? _f : [],
+            diagnosticSeverityOverrides: (_g = config.diagnosticSeverityOverrides) !== null && _g !== void 0 ? _g : {},
+            diagnosticFilters: (_h = config.diagnosticFilters) !== null && _h !== void 0 ? _h : [],
+            diagnosticFiltersV0Compatibility: config.diagnosticFiltersV0Compatibility === true ? true : false,
+            plugins: (_j = config.plugins) !== null && _j !== void 0 ? _j : [],
+            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,
+            resolveSourceRoot: config.resolveSourceRoot === true ? true : false,
+            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,
+            validate: config.validate === false ? false : true
+        };
+        //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) {
@@ -313,19 +373,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
@@ -344,33 +393,34 @@ class Util {
         return result;
     }
     /**
-     * Split a file by newline characters (LF or CRLF)
-     * @param text
+     * 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
      */
-    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
-     */
-    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
@@ -384,19 +434,41 @@ class Util {
                 result.push(part);
             }
         }
-        return result.join('/');
+        return result.join(path.sep);
+    }
+    /**
+     * Compute the replacement text for a file-path string (used in `import` statements and XML `<script uri>` attributes)
+     * when the target file is being renamed. Preserves the original path style: `pkg:/...` stays `pkg:/...`,
+     * relative paths stay relative (recomputed from the containing file's pkg path).
+     *
+     * @param originalText the path string as it appears in source (no surrounding quotes)
+     * @param containingFilePkgPath pkg path of the file containing the reference
+     * @param newTargetPkgPath pkg path of the renamed file (path-separator agnostic)
+     * @returns the new path string, or `null` if the original style is unsupported
+     */
+    computeRenamedReferencePath(originalText, containingFilePkgPath, newTargetPkgPath) {
+        if (!originalText) {
+            return null;
+        }
+        const newPkgPathForwardSlash = path.normalize(newTargetPkgPath).split(path.sep).join('/');
+        const schemeMatch = /^(pkg|libpkg):\//i.exec(originalText);
+        if (schemeMatch) {
+            return `${schemeMatch[1]}:/${newPkgPathForwardSlash}`;
+        }
+        const relative = this.getRelativePath(containingFilePkgPath, newTargetPkgPath);
+        return relative.split(path.sep).join('/');
     }
     /**
      * Compute the relative path from the source file to the target file
-     * @param pkgSourcePathAbsolute  - the absolute path to the source relative to the package location
-     * @param pkgTargetPathAbsolute  - the absolute path ro the target relative to the package location
+     * @param pkgSrcPath  - the absolute path to the source, where cwd is the package location
+     * @param pkgTargetPath  - the absolute path to the target, where cwd is the package location
      */
-    getRelativePath(pkgSourcePathAbsolute, pkgTargetPathAbsolute) {
-        pkgSourcePathAbsolute = path.normalize(pkgSourcePathAbsolute);
-        pkgTargetPathAbsolute = path.normalize(pkgTargetPathAbsolute);
+    getRelativePath(pkgSrcPath, pkgTargetPath) {
+        pkgSrcPath = path.normalize(pkgSrcPath);
+        pkgTargetPath = path.normalize(pkgTargetPath);
         //break by path separator
-        let sourceParts = pkgSourcePathAbsolute.split(path.sep);
-        let targetParts = pkgTargetPathAbsolute.split(path.sep);
+        let sourceParts = pkgSrcPath.split(path.sep);
+        let targetParts = pkgTargetPath.split(path.sep);
         let commonParts = [];
         //find their common root
         for (let i = 0; i < targetParts.length; i++) {
@@ -419,16 +491,26 @@ class Util {
         resultParts = [...resultParts, ...targetParts];
         return path.join(...resultParts);
     }
+    getImportPackagePath(srcPath, pkgTargetPath) {
+        const srcExt = this.getExtension(srcPath);
+        const lowerSrcExt = srcExt.toLowerCase();
+        const lowerTargetExt = this.getExtension(pkgTargetPath).toLowerCase();
+        if (lowerSrcExt === '.bs' && lowerTargetExt === '.brs') {
+            // if source is .bs, use that as the import extenstion
+            return pkgTargetPath.substring(0, pkgTargetPath.length - lowerTargetExt.length) + srcExt;
+        }
+        return pkgTargetPath;
+    }
     /**
      * Walks left in a DottedGetExpression and returns a VariableExpression if found, or undefined if not found
      */
     findBeginningVariableExpression(dottedGet) {
         let left = dottedGet;
         while (left) {
-            if (astUtils_1.isVariableExpression(left)) {
+            if ((0, reflection_1.isVariableExpression)(left)) {
                 return left;
             }
-            else if (astUtils_1.isDottedGetExpression(left)) {
+            else if ((0, reflection_1.isDottedGetExpression)(left)) {
                 left = left.obj;
             }
             else {
@@ -437,9 +519,19 @@ class Util {
         }
     }
     /**
-     * Does a touch b in any way?
+     * Do `a` and `b` overlap by at least one character. This returns false if they are at the edges. Here's some examples:
+     * ```
+     * | true | true | true | true | true | false | false | false | false |
+     * |------|------|------|------|------|-------|-------|-------|-------|
+     * | aa   |  aaa |  aaa | aaa  |  a   |  aa   |    aa | a     |     a |
+     * |  bbb | bb   |  bbb |  b   | bbb  |    bb |  bb   |     b | a     |
+     * ```
      */
     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;
@@ -451,74 +543,159 @@ class Util {
         // These ranges must intersect
         return true;
     }
+    /**
+     * Do `a` and `b` overlap by at least one character or touch at the edges
+     * ```
+     * | true | true | true | true | true | true  | true  | false | false |
+     * |------|------|------|------|------|-------|-------|-------|-------|
+     * | aa   |  aaa |  aaa | aaa  |  a   |  aa   |    aa | a     |     a |
+     * |  bbb | bb   |  bbb |  b   | bbb  |    bb |  bb   |     b | a     |
+     * ```
+     */
+    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;
+        }
+        // Check if `b` is before `a`
+        if (b.end.line < a.start.line || (b.end.line === a.start.line && b.end.character < a.start.character)) {
+            return false;
+        }
+        // These ranges must intersect
+        return true;
+    }
     /**
      * 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;
     }
     /**
-     * Parse an xml file and get back a javascript object containing its results
-     * @param text
+     * Is the inner range completely enclosed in the outer range
      */
-    parseXml(text) {
-        return new Promise((resolve, reject) => {
-            xml2js.parseString(text, (err, data) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
-                }
-            });
-        });
+    isRangeInRange(inner, outer) {
+        return this.comparePosition(inner.start, outer.start) === 1 &&
+            this.comparePosition(inner.end, outer.end) === -1;
     }
-    propertyCount(object) {
-        let count = 0;
-        for (let key in object) {
-            if (object.hasOwnProperty(key)) {
-                count++;
+    /**
+     * Combine all the documentation for a node - uses the AstNode's leadingTrivia property
+     * @param node the node to get the documentation for
+     * @param options extra options
+     * @param options.prettyPrint if true, will format the comment text for markdown
+     * @param options.commentTokens out Array of tokens that match the comment lines
+     */
+    getNodeDocumentation(node, options = { prettyPrint: true }) {
+        var _a, _b, _c, _d;
+        if (!node) {
+            return '';
+        }
+        options = options !== null && options !== void 0 ? options : { prettyPrint: true };
+        options.commentTokens = (_a = options.commentTokens) !== null && _a !== void 0 ? _a : [];
+        const nodeTrivia = (_b = node.leadingTrivia) !== null && _b !== void 0 ? _b : [];
+        const leadingTrivia = (0, reflection_1.isStatement)(node)
+            ? [...((_d = (_c = node.annotations) === null || _c === void 0 ? void 0 : _c.map(anno => { var _a; return (_a = anno.leadingTrivia) !== null && _a !== void 0 ? _a : []; }).flat()) !== null && _d !== void 0 ? _d : []), ...nodeTrivia]
+            : nodeTrivia;
+        const tokens = leadingTrivia === null || leadingTrivia === void 0 ? void 0 : leadingTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Newline || t.kind === TokenKind_1.TokenKind.Comment);
+        const comments = [];
+        let newLinesInRow = 0;
+        for (let i = tokens.length - 1; i >= 0; i--) {
+            const token = tokens[i];
+            //skip whitespace and newline chars
+            if (token.kind === TokenKind_1.TokenKind.Comment) {
+                comments.push(token);
+                newLinesInRow = 0;
+            }
+            else if (token.kind === TokenKind_1.TokenKind.Newline) {
+                //skip these tokens
+                newLinesInRow++;
+                if (newLinesInRow > 1) {
+                    // stop processing on empty line.
+                    break;
+                }
+                //any other token means there are no more comments
+            }
+            else {
+                break;
             }
         }
-        return count;
-    }
-    padLeft(subject, totalLength, char) {
-        totalLength = totalLength > 1000 ? 1000 : totalLength;
-        while (subject.length < totalLength) {
-            subject = char + subject;
+        const jsDocCommentBlockLine = /(\/\*{2,}|\*{1,}\/)/i;
+        let usesjsDocCommentBlock = false;
+        if (comments.length === 0) {
+            return '';
         }
-        return subject;
+        return comments.reverse()
+            .map(x => ({ line: x.text.replace(/^('|rem)/i, '').trim(), token: x }))
+            .filter(({ line }) => {
+            if (jsDocCommentBlockLine.exec(line)) {
+                usesjsDocCommentBlock = true;
+                return false;
+            }
+            return true;
+        }).map(({ line, token }) => {
+            if (usesjsDocCommentBlock) {
+                if (line.startsWith('*')) {
+                    //remove jsDoc leading '*'
+                    line = line.slice(1).trim();
+                }
+            }
+            if (options.prettyPrint && 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)}`;
+            }
+            if (options.commentTokens) {
+                options.commentTokens.push(token);
+            }
+            return line;
+        }).join('\n');
     }
     /**
-     * Given a URI, convert that to a regular fs path
-     * @param uri
+     * 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`
      */
-    uriToPath(uri) {
-        let parsedPath = vscode_uri_1.URI.parse(uri).fsPath;
-        //Uri annoyingly coverts all drive letters to lower case...so this will bring back whatever case it came in as
-        let match = /\/\/\/([a-z]:)/i.exec(uri);
-        if (match) {
-            let originalDriveCasing = match[1];
-            parsedPath = originalDriveCasing + parsedPath.substring(2);
-        }
-        const normalizedPath = path.normalize(parsedPath);
-        return normalizedPath;
+    getSgNodeTypeName(sgNodeName) {
+        return 'roSGNode' + sgNodeName;
     }
     /**
      * Force the drive letter to lower case
-     * @param fullPath
      */
     driveLetterToLower(fullPath) {
         if (fullPath) {
@@ -534,53 +711,72 @@ class Util {
         return fullPath;
     }
     /**
-     * Determine if two arrays containing primitive values are equal.
-     * This considers order and compares by equality.
+     * Replace the first instance of `search` in `subject` with `replacement`
      */
-    areArraysEqual(arr1, arr2) {
-        if (arr1.length !== arr2.length) {
-            return false;
+    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;
         }
-        for (let i = 0; i < arr1.length; i++) {
-            if (arr1[i] !== arr2[i]) {
-                return false;
-            }
+        else {
+            return subject;
         }
-        return true;
     }
     /**
-     * Given a file path, convert it to a URI string
-     * @param srcPath The absolute path to the source file on disk
+     * Does the string appear to be a uri (i.e. does it start with `file:`)
      */
-    pathToUri(srcPath) {
-        return vscode_uri_1.URI.file(srcPath).toString();
+    isUriLike(filePath) {
+        return (filePath === null || filePath === void 0 ? void 0 : filePath.indexOf('file:')) === 0; // eslint-disable-line @typescript-eslint/prefer-string-starts-ends-with
     }
     /**
-     * Get the outDir from options, taking into account cwd and absolute outFile paths
-     * @param options
+     * Given a file path, convert it to a URI string
      */
-    getOutDir(options) {
-        options = this.normalizeConfig(options);
-        let cwd = path.normalize(options.cwd ? options.cwd : process.cwd());
-        if (path.isAbsolute(options.outFile)) {
-            return path.dirname(options.outFile);
+    pathToUri(filePath) {
+        if (!filePath) {
+            return filePath;
+        }
+        else if (this.pathToURICache.has(filePath)) {
+            return this.pathToURICache.get(filePath);
+        }
+        else if (this.isUriLike(filePath)) {
+            return filePath;
         }
         else {
-            return path.normalize(path.join(cwd, path.dirname(options.outFile)));
+            const uri = vscode_uri_1.URI.file(filePath).toString();
+            this.pathToURICache.set(filePath, uri);
+            return uri;
+        }
+    }
+    /**
+     * Given a URI, convert that to a regular fs path
+     */
+    uriToPath(uri) {
+        //if this doesn't look like a URI, then assume it's already a path
+        if (this.isUriLike(uri) === false) {
+            return uri;
+        }
+        let parsedPath = vscode_uri_1.URI.parse(uri).fsPath;
+        //Uri annoyingly converts all drive letters to lower case...so this will bring back whatever case it came in as
+        let match = /\/\/\/([a-z]:)/i.exec(uri);
+        if (match) {
+            let originalDriveCasing = match[1];
+            parsedPath = originalDriveCasing + parsedPath.substring(2);
         }
+        const normalizedPath = path.normalize(parsedPath);
+        return normalizedPath;
     }
     /**
      * Get paths to all files on disc that match this project's source list
      */
     async getFilePaths(options) {
         let rootDir = this.getRootDir(options);
-        let files = await rokuDeploy.getFilePaths(options.files, rootDir);
+        let files = await roku_deploy_1.rokuDeploy.getFilePaths(options.files, rootDir);
         return files;
     }
     /**
      * 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
@@ -593,51 +789,9 @@ class Util {
             return undefined;
         }
     }
-    /**
-     * Determine whether this diagnostic should be supressed or not, based on brs comment-flags
-     * @param diagnostic
-     */
-    diagnosticIsSuppressed(diagnostic) {
-        var _a, _b;
-        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 the flag acts upon this diagnostic's code
-                if (flag.codes === null || flag.codes.includes(diagnostic.code)) {
-                    return true;
-                }
-            }
-        }
-    }
-    /**
-     * Walks up the chain
-     * @param currentPath
-     */
-    async findClosestConfigFile(currentPath) {
-        //make the path absolute
-        currentPath = path.resolve(path.normalize(currentPath));
-        let previousPath;
-        //using ../ on the root of the drive results in the same file path, so that's how we know we reached the top
-        while (previousPath !== currentPath) {
-            previousPath = currentPath;
-            let bsPath = path.join(currentPath, 'bsconfig.json');
-            let brsPath = path.join(currentPath, 'brsconfig.json');
-            if (await this.pathExists(bsPath)) {
-                return bsPath;
-            }
-            else if (await this.pathExists(brsPath)) {
-                return brsPath;
-            }
-            else {
-                //walk upwards one directory
-                currentPath = path.resolve(path.join(currentPath, '../'));
-            }
-        }
-        //got to the root path, no config file exists
-    }
     /**
      * 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) => {
@@ -650,14 +804,6 @@ class Util {
             }
         });
     }
-    /**
-     * Given an array, map and then flatten
-     * @param arr
-     * @param cb
-     */
-    flatMap(array, cb) {
-        return Array.prototype.concat.apply([], array.map(cb));
-    }
     /**
      * Determines if the position is greater than the range. This means
      * the position does not touch the range, and has a position greater than the end
@@ -682,56 +828,49 @@ class Util {
         }
     }
     /**
-     * Get a location object back by extracting location information from other objects that contain location
-     */
-    getRange(startObj, endObj) {
-        return exports.util.createRangeFromPositions(startObj.range.start, endObj.range.end);
-    }
-    /**
-     * If the two items both start on the same line
+     * Get a range back from an object that contains (or is) a range
      */
-    sameStartLine(first, second) {
-        if (first && second && first.range.start.line === second.range.start.line) {
-            return true;
+    extractRange(rangeIsh) {
+        var _a;
+        if (!rangeIsh) {
+            return undefined;
+        }
+        else if ('location' in rangeIsh) {
+            return (_a = rangeIsh.location) === null || _a === void 0 ? void 0 : _a.range;
+        }
+        else if ('range' in rangeIsh) {
+            return rangeIsh.range;
+        }
+        else if (vscode_languageserver_1.Range.is(rangeIsh)) {
+            return rangeIsh;
         }
         else {
-            return false;
+            return undefined;
         }
     }
     /**
      * 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 ||
-            first.range.start.line === second.range.end.line ||
-            first.range.end.line === second.range.start.line ||
-            first.range.end.line === second.range.end.line)) {
+        const firstRange = this.extractRange(first);
+        const secondRange = this.extractRange(second);
+        if (firstRange && secondRange && (firstRange.start.line === secondRange.start.line ||
+            firstRange.start.line === secondRange.end.line ||
+            firstRange.end.line === secondRange.start.line ||
+            firstRange.end.line === secondRange.end.line)) {
             return true;
         }
         else {
             return false;
         }
     }
-    /**
-     * Given text with (or without) dots separating text, get the rightmost word.
-     * (i.e. given "A.B.C", returns "C". or "B" returns "B because there's no dot)
-     */
-    getTextAfterFinalDot(name) {
-        if (name) {
-            let parts = name.split('.');
-            if (parts.length > 0) {
-                return parts[parts.length - 1];
-            }
-        }
-    }
     /**
      * Find a script import that the current position touches, or undefined if not found
      */
     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;
@@ -775,11 +914,46 @@ 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');
     }
     /**
-     * Helper for creating `Range` objects. Prefer using this function because vscode-languageserver's `util.createRange()` is significantly slower
+     * Helper for creating `Location` objects. Prefer using this function because vscode-languageserver's `Location.create()` is significantly slower at scale
+     */
+    createLocationFromRange(uri, range) {
+        return {
+            uri: exports.util.pathToUri(uri),
+            range: range
+        };
+    }
+    /**
+     * Helper for creating `Location` objects from a file and range
+     */
+    createLocationFromFileRange(file, range) {
+        return this.createLocationFromRange(this.pathToUri(file === null || file === void 0 ? void 0 : file.srcPath), range);
+    }
+    /**
+     * Helper for creating `Location` objects by passing each range value in directly. Prefer using this function because vscode-languageserver's `Location.create()` is significantly slower at scale
+     */
+    createLocation(startLine, startCharacter, endLine, endCharacter, uri) {
+        return {
+            uri: exports.util.pathToUri(uri),
+            range: {
+                start: {
+                    line: startLine,
+                    character: startCharacter
+                },
+                end: {
+                    line: endLine,
+                    character: endCharacter
+                }
+            }
+        };
+    }
+    /**
+     * Helper for creating `Range` objects. Prefer using this function because vscode-languageserver's `Range.create()` is significantly slower.
      */
     createRange(startLine, startCharacter, endLine, endCharacter) {
         return {
@@ -797,141 +971,708 @@ class Util {
      * 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
-            }
-        };
+        startPosition = startPosition !== null && startPosition !== void 0 ? startPosition : endPosition;
+        endPosition = endPosition !== null && endPosition !== void 0 ? endPosition : startPosition;
+        if (!startPosition && !endPosition) {
+            return undefined;
+        }
+        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.
+     * Clone a range
      */
-    createBoundingRange(...locatables) {
-        let leftmost;
-        let rightmost;
-        for (let i = 0; i < locatables.length; i++) {
-            //set the leftmost non-null-range item
-            const left = locatables[i];
-            if (!leftmost && (left === null || left === void 0 ? void 0 : left.range)) {
-                leftmost = left;
-            }
-            //set the rightmost non-null-range item
-            const right = locatables[locatables.length - 1 - i];
-            if (!rightmost && (right === null || right === void 0 ? void 0 : right.range)) {
-                rightmost = right;
-            }
-            //if we have both sides, quit
-            if (leftmost && rightmost) {
-                break;
-            }
-        }
-        if (leftmost) {
-            return this.createRangeFromPositions(leftmost.range.start, rightmost.range.end);
+    cloneLocation(location) {
+        if (location) {
+            return {
+                uri: location.uri,
+                range: {
+                    start: {
+                        line: location.range.start.line,
+                        character: location.range.start.character
+                    },
+                    end: {
+                        line: location.range.end.line,
+                        character: location.range.end.character
+                    }
+                }
+            };
         }
         else {
-            return undefined;
+            return location;
         }
     }
     /**
-     * Create a `Position` object. Prefer this over `Position.create` for performance reasons
+     * Clone every token
      */
-    createPosition(line, character) {
-        return {
-            line: line,
-            character: character
-        };
-    }
-    /**
-     * Convert a list of tokens into a string, including their leading whitespace
-     */
-    tokensToString(tokens) {
-        let result = '';
-        //skip iterating the final token
-        for (let i = 0; i < tokens.length; i++) {
-            let token = tokens[i];
-            result += token.leadingWhitespace + token.text;
+    cloneToken(token) {
+        if (token) {
+            const result = {
+                kind: token.kind,
+                location: this.cloneLocation(token.location),
+                text: token.text,
+                isReserved: token.isReserved,
+                leadingWhitespace: token.leadingWhitespace,
+                leadingTrivia: token.leadingTrivia ? token.leadingTrivia.map(x => this.cloneToken(x)) : undefined
+            };
+            //handle those tokens that have charCode
+            if ('charCode' in token) {
+                result.charCode = token.charCode;
+            }
+            return result;
+        }
+        else {
+            return token;
         }
-        return result;
     }
     /**
-     * Convert a token into a BscType
+     *  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
      */
-    tokenToBscType(token, allowCustomType = true) {
-        if (!token) {
-            return new DynamicType_1.DynamicType();
-        }
-        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    createBoundingLocation(...locatables) {
+        var _a, _b;
+        let uri;
+        let startPosition;
+        let endPosition;
+        for (let locatable of locatables) {
+            let range;
+            if (!locatable) {
+                continue;
+            }
+            else if ('location' in locatable) {
+                range = (_a = locatable.location) === null || _a === void 0 ? void 0 : _a.range;
+                if (!uri) {
+                    uri = (_b = locatable.location) === null || _b === void 0 ? void 0 : _b.uri;
+                }
+            }
+            else if (vscode_languageserver_1.Location.is(locatable)) {
+                range = locatable.range;
+                if (!uri) {
+                    uri = locatable.uri;
+                }
+            }
+            else if ('range' in locatable) {
+                range = locatable.range;
+            }
+            else {
+                range = locatable;
+            }
+            //skip undefined locations or locations without a range
+            if (!range) {
+                continue;
+            }
+            if (!startPosition) {
+                startPosition = range.start;
+            }
+            else if (this.comparePosition(range.start, startPosition) < 0) {
+                startPosition = range.start;
+            }
+            if (!endPosition) {
+                endPosition = range.end;
+            }
+            else if (this.comparePosition(range.end, endPosition) > 0) {
+                endPosition = range.end;
+            }
+        }
+        if (startPosition && endPosition) {
+            return exports.util.createLocation(startPosition.line, startPosition.character, endPosition.line, endPosition.character, uri);
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     *  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) {
+        var _a;
+        return (_a = this.createBoundingLocation(...locatables)) === null || _a === void 0 ? void 0 : _a.range;
+    }
+    /**
+     * 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
+     */
+    createBoundingLocationFromTokens(tokens) {
+        var _a;
+        let uri;
+        let startPosition;
+        let endPosition;
+        for (let key in tokens) {
+            let token = tokens === null || tokens === void 0 ? void 0 : tokens[key];
+            let locatableRange = (_a = token === null || token === void 0 ? void 0 : token.location) === 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 (!uri) {
+                uri = token.location.uri;
+            }
+        }
+        if (startPosition && endPosition) {
+            return this.createLocation(startPosition.line, startPosition.character, endPosition.line, endPosition.character, uri);
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Create a `Position` object. Prefer this over `Position.create` for performance reasons.
+     */
+    createPosition(line, character) {
+        return {
+            line: line,
+            character: character
+        };
+    }
+    /**
+     * Convert a token into a BscType
+     */
+    tokenToBscType(token) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (token.kind) {
-            case lexer_1.TokenKind.Boolean:
-            case lexer_1.TokenKind.True:
-            case lexer_1.TokenKind.False:
-                return new BooleanType_1.BooleanType();
-            case lexer_1.TokenKind.Double:
-            case lexer_1.TokenKind.DoubleLiteral:
-                return new DoubleType_1.DoubleType();
-            case lexer_1.TokenKind.Dynamic:
-                return new DynamicType_1.DynamicType();
-            case lexer_1.TokenKind.Float:
-            case lexer_1.TokenKind.FloatLiteral:
-                return new FloatType_1.FloatType();
-            case lexer_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());
-            case lexer_1.TokenKind.Integer:
-            case lexer_1.TokenKind.IntegerLiteral:
-                return new IntegerType_1.IntegerType();
-            case lexer_1.TokenKind.Invalid:
-                return new InvalidType_1.InvalidType();
-            case lexer_1.TokenKind.LongInteger:
-            case lexer_1.TokenKind.LongIntegerLiteral:
-                return new LongIntegerType_1.LongIntegerType();
-            case lexer_1.TokenKind.Object:
-                return new ObjectType_1.ObjectType();
-            case lexer_1.TokenKind.String:
-            case lexer_1.TokenKind.StringLiteral:
-            case lexer_1.TokenKind.TemplateStringExpressionBegin:
-            case lexer_1.TokenKind.TemplateStringExpressionEnd:
-            case lexer_1.TokenKind.TemplateStringQuasi:
-                return new StringType_1.StringType();
-            case lexer_1.TokenKind.Void:
-                return new VoidType_1.VoidType();
-            case lexer_1.TokenKind.Identifier:
+            case TokenKind_1.TokenKind.Boolean:
+                return BooleanType_1.BooleanType.instance;
+            case TokenKind_1.TokenKind.True:
+            case TokenKind_1.TokenKind.False:
+                return BooleanType_1.BooleanType.instance;
+            case TokenKind_1.TokenKind.Double:
+                return DoubleType_1.DoubleType.instance;
+            case TokenKind_1.TokenKind.DoubleLiteral:
+                return DoubleType_1.DoubleType.instance;
+            case TokenKind_1.TokenKind.Dynamic:
+                return DynamicType_1.DynamicType.instance;
+            case TokenKind_1.TokenKind.Float:
+                return FloatType_1.FloatType.instance;
+            case TokenKind_1.TokenKind.FloatLiteral:
+                return FloatType_1.FloatType.instance;
+            case TokenKind_1.TokenKind.Function:
+                return FunctionType_1.FunctionType.instance;
+            case TokenKind_1.TokenKind.Integer:
+                return IntegerType_1.IntegerType.instance;
+            case TokenKind_1.TokenKind.IntegerLiteral:
+                return IntegerType_1.IntegerType.instance;
+            case TokenKind_1.TokenKind.Invalid:
+                return InvalidType_1.InvalidType.instance;
+            case TokenKind_1.TokenKind.LongInteger:
+                return LongIntegerType_1.LongIntegerType.instance;
+            case TokenKind_1.TokenKind.LongIntegerLiteral:
+                return LongIntegerType_1.LongIntegerType.instance;
+            case TokenKind_1.TokenKind.Object:
+                return ObjectType_1.ObjectType.instance;
+            case TokenKind_1.TokenKind.String:
+                return StringType_1.StringType.instance;
+            case TokenKind_1.TokenKind.StringLiteral:
+            case TokenKind_1.TokenKind.TemplateStringExpressionBegin:
+            case TokenKind_1.TokenKind.TemplateStringExpressionEnd:
+            case TokenKind_1.TokenKind.TemplateStringQuasi:
+                return StringType_1.StringType.instance;
+            case TokenKind_1.TokenKind.Void:
+                return VoidType_1.VoidType.instance;
+            case TokenKind_1.TokenKind.Identifier:
                 switch (token.text.toLowerCase()) {
                     case 'boolean':
-                        return new BooleanType_1.BooleanType();
+                        return BooleanType_1.BooleanType.instance;
                     case 'double':
-                        return new DoubleType_1.DoubleType();
+                        return DoubleType_1.DoubleType.instance;
+                    case 'dynamic':
+                        return DynamicType_1.DynamicType.instance;
                     case 'float':
-                        return new FloatType_1.FloatType();
+                        return FloatType_1.FloatType.instance;
                     case 'function':
-                        return new FunctionType_1.FunctionType(new DynamicType_1.DynamicType());
+                        return FunctionType_1.FunctionType.instance;
                     case 'integer':
-                        return new IntegerType_1.IntegerType();
+                        return IntegerType_1.IntegerType.instance;
                     case 'invalid':
-                        return new InvalidType_1.InvalidType();
+                        return InvalidType_1.InvalidType.instance;
                     case 'longinteger':
-                        return new LongIntegerType_1.LongIntegerType();
+                        return LongIntegerType_1.LongIntegerType.instance;
                     case 'object':
-                        return new ObjectType_1.ObjectType();
+                        return ObjectType_1.ObjectType.instance;
                     case 'string':
-                        return new StringType_1.StringType();
+                        return StringType_1.StringType.instance;
                     case 'void':
-                        return new VoidType_1.VoidType();
+                        return VoidType_1.VoidType.instance;
+                }
+        }
+    }
+    /**
+     * 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) {
+        let typeDescriptorLower = typeDescriptor.toLowerCase().trim().replace(/\*/g, '');
+        if (typeDescriptorLower.startsWith('as ')) {
+            typeDescriptorLower = typeDescriptorLower.substring(3).trim();
+        }
+        const nodeFilter = (new RegExp(/^\[?(.* node)/, 'i')).exec(typeDescriptorLower);
+        if (nodeFilter === null || nodeFilter === void 0 ? void 0 : nodeFilter[1]) {
+            typeDescriptorLower = nodeFilter[1].trim();
+        }
+        const parensFilter = (new RegExp(/(.*)\(.*\)/, 'gi')).exec(typeDescriptorLower);
+        if (parensFilter === null || parensFilter === void 0 ? void 0 : parensFilter[1]) {
+            typeDescriptorLower = parensFilter[1].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, 1 /* SymbolTypeFlag.runtime */);
+            rect2dType.addMember('width', {}, FloatType_1.FloatType.instance, 1 /* SymbolTypeFlag.runtime */);
+            rect2dType.addMember('x', {}, FloatType_1.FloatType.instance, 1 /* SymbolTypeFlag.runtime */);
+            rect2dType.addMember('y', {}, FloatType_1.FloatType.instance, 1 /* SymbolTypeFlag.runtime */);
+            return rect2dType;
+        }
+        function getColorType() {
+            return (0, UnionType_1.unionTypeFactory)([IntegerType_1.IntegerType.instance, StringType_1.StringType.instance]);
+        }
+        //check for uniontypes
+        const multipleTypes = typeDescriptorLower.split(' or ').map(s => s.trim());
+        if (multipleTypes.length > 1) {
+            const individualTypes = multipleTypes.map(t => this.getNodeFieldType(t, lookupTable));
+            return (0, UnionType_1.unionTypeFactory)(individualTypes);
+        }
+        const typeIsArray = typeDescriptorLower.startsWith('array of ') || typeDescriptorLower.startsWith('roarray of ');
+        if (typeIsArray) {
+            const ofSearch = ' of ';
+            const arrayPrefixLength = typeDescriptorLower.indexOf(ofSearch) + ofSearch.length;
+            let arrayOfTypeName = typeDescriptorLower.substring(arrayPrefixLength); //cut off beginnin, eg. 'array of' or 'roarray 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);
+            }
+            if (arrayOfTypeName === 'rectangle') {
+                arrayOfTypeName = 'rect2d';
+            }
+            let arrayType = this.getNodeFieldType(arrayOfTypeName, lookupTable);
+            return new ArrayType_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 === 'n/a') {
+            return DynamicType_1.DynamicType.instance;
+        }
+        else if (typeDescriptorLower === 'uri') {
+            return StringType_1.StringType.instance;
+        }
+        else if (typeDescriptorLower === 'color') {
+            return getColorType();
+        }
+        else if (typeDescriptorLower === 'vector2d' || typeDescriptorLower === 'floatarray') {
+            return new ArrayType_1.ArrayType(FloatType_1.FloatType.instance);
+        }
+        else if (typeDescriptorLower === 'vector2darray') {
+            return new ArrayType_1.ArrayType(new ArrayType_1.ArrayType(FloatType_1.FloatType.instance));
+        }
+        else if (typeDescriptorLower === 'intarray') {
+            return new ArrayType_1.ArrayType(IntegerType_1.IntegerType.instance);
+        }
+        else if (typeDescriptorLower === 'colorarray') {
+            return new ArrayType_1.ArrayType(getColorType());
+        }
+        else if (typeDescriptorLower === 'boolarray') {
+            return new ArrayType_1.ArrayType(BooleanType_1.BooleanType.instance);
+        }
+        else if (typeDescriptorLower === 'stringarray' || typeDescriptorLower === 'strarray') {
+            return new ArrayType_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' || typeDescriptorLower === 'roarray') {
+            return new ArrayType_1.ArrayType();
+        }
+        else if (typeDescriptorLower === 'assocarray' ||
+            typeDescriptorLower === 'associative array' ||
+            typeDescriptorLower === 'associativearray' ||
+            typeDescriptorLower === 'roassociativearray' ||
+            typeDescriptorLower.startsWith('associative array of') ||
+            typeDescriptorLower.startsWith('associativearray of') ||
+            typeDescriptorLower.startsWith('roassociativearray of')) {
+            return new AssociativeArrayType_1.AssociativeArrayType();
+        }
+        else if (typeDescriptorLower === 'node') {
+            return ComponentType_1.ComponentType.instance;
+        }
+        else if (typeDescriptorLower === 'nodearray') {
+            return new ArrayType_1.ArrayType(ComponentType_1.ComponentType.instance);
+        }
+        else if (typeDescriptorLower === 'rect2d') {
+            return getRect2dType();
+        }
+        else if (typeDescriptorLower === 'rect2darray') {
+            return new ArrayType_1.ArrayType(getRect2dType());
+        }
+        else if (typeDescriptorLower === 'font') {
+            return this.getNodeFieldType('roSGNodeFont', lookupTable);
+        }
+        else if (typeDescriptorLower === 'contentnode') {
+            return this.getNodeFieldType('roSGNodeContentNode', lookupTable);
+        }
+        else if (typeDescriptorLower.endsWith(' node')) {
+            return this.getNodeFieldType('roSgNode' + typeDescriptorLower.substring(0, typeDescriptorLower.length - 5), lookupTable);
+        }
+        else if (lookupTable) {
+            //try doing a lookup
+            return lookupTable.getSymbolType(typeDescriptorLower, {
+                flags: 2 /* SymbolTypeFlag.typetime */,
+                fullName: typeDescriptor,
+                tableProvider: () => lookupTable
+            });
+        }
+        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 ReferenceType_1.BinaryOperatorReferenceType(leftType, operator, rightType, (lhs, op, rhs) => {
+                return this.binaryOperatorResultType(lhs, op, rhs);
+            });
+        }
+        // Try to find a common value of union type
+        leftType = (0, helpers_1.getUniqueType)([leftType], UnionType_1.unionTypeFactory);
+        rightType = (0, helpers_1.getUniqueType)([rightType], UnionType_1.unionTypeFactory);
+        if ((0, reflection_1.isUnionType)(leftType)) {
+            leftType = this.getHighestPriorityType(leftType.types);
+        }
+        if ((0, reflection_1.isUnionType)(rightType)) {
+            rightType = this.getHighestPriorityType(rightType.types);
+        }
+        if ((0, reflection_1.isVoidType)(leftType) || (0, reflection_1.isVoidType)(rightType) || (0, reflection_1.isUninitializedType)(leftType) || (0, reflection_1.isUninitializedType)(rightType)) {
+            return undefined;
+        }
+        if ((0, reflection_1.isEnumMemberType)(leftType)) {
+            leftType = leftType.underlyingType;
+        }
+        if ((0, reflection_1.isEnumMemberType)(rightType)) {
+            rightType = rightType.underlyingType;
+        }
+        // treat object type like dynamic
+        if ((0, reflection_1.isObjectType)(leftType)) {
+            leftType = DynamicType_1.DynamicType.instance;
+        }
+        if ((0, reflection_1.isObjectType)(rightType)) {
+            rightType = DynamicType_1.DynamicType.instance;
+        }
+        let hasDouble = (0, reflection_1.isDoubleTypeLike)(leftType) || (0, reflection_1.isDoubleTypeLike)(rightType);
+        let hasFloat = (0, reflection_1.isFloatTypeLike)(leftType) || (0, reflection_1.isFloatTypeLike)(rightType);
+        let hasLongInteger = (0, reflection_1.isLongIntegerTypeLike)(leftType) || (0, reflection_1.isLongIntegerTypeLike)(rightType);
+        let hasInvalid = (0, reflection_1.isInvalidTypeLike)(leftType) || (0, reflection_1.isInvalidTypeLike)(rightType);
+        let hasDynamic = (0, reflection_1.isDynamicType)(leftType) || (0, reflection_1.isDynamicType)(rightType);
+        let bothDynamic = (0, reflection_1.isDynamicType)(leftType) && (0, reflection_1.isDynamicType)(rightType);
+        let bothNumbers = (0, reflection_1.isNumberTypeLike)(leftType) && (0, reflection_1.isNumberTypeLike)(rightType);
+        let hasNumber = (0, reflection_1.isNumberTypeLike)(leftType) || (0, reflection_1.isNumberTypeLike)(rightType);
+        let bothStrings = (0, reflection_1.isStringTypeLike)(leftType) && (0, reflection_1.isStringTypeLike)(rightType);
+        let hasString = (0, reflection_1.isStringTypeLike)(leftType) || (0, reflection_1.isStringTypeLike)(rightType);
+        let hasBoolean = (0, reflection_1.isBooleanTypeLike)(leftType) || (0, reflection_1.isBooleanTypeLike)(rightType);
+        let eitherBooleanOrNum = ((0, reflection_1.isNumberTypeLike)(leftType) || (0, reflection_1.isBooleanTypeLike)(leftType)) && ((0, reflection_1.isNumberTypeLike)(rightType) || (0, reflection_1.isBooleanTypeLike)(rightType));
+        let leftIsPrimitive = (0, reflection_1.isPrimitiveType)(leftType);
+        let rightIsPrimitive = (0, reflection_1.isPrimitiveType)(rightType);
+        let hasPrimitive = leftIsPrimitive || rightIsPrimitive;
+        let nonDynamicType;
+        if (hasPrimitive) {
+            nonDynamicType = leftIsPrimitive ? leftType : 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;
+                }
+                else if (hasString && hasDynamic) {
+                    // assume dynamicValue is a string
+                    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;
+                }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return nonDynamicType;
+                }
+                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;
+                }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return nonDynamicType;
+                }
+                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;
+                }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    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;
                 }
-                if (allowCustomType) {
-                    return new CustomType_1.CustomType(token.text);
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    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;
+                }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    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;
+                }
+                else if ((hasNumber || hasString) && hasDynamic) {
+                    // assume dynamic is a valid type
+                    return BooleanType_1.BooleanType.instance;
+                }
+                break;
+            // Logical or bitwise operators
+            case TokenKind_1.TokenKind.Or:
+            case TokenKind_1.TokenKind.And:
+                if (bothNumbers) {
+                    // "and"/"or" represent bitwise operators
+                    if (hasLongInteger && !hasDouble && !hasFloat) {
+                        // 2 long ints or long int and int
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    return IntegerType_1.IntegerType.instance;
+                }
+                else if (eitherBooleanOrNum) {
+                    // "and"/"or" represent logical operators
+                    return BooleanType_1.BooleanType.instance;
+                }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a valid type
+                    return IntegerType_1.IntegerType.instance;
+                }
+                else if (hasBoolean && hasDynamic) {
+                    // assume dynamic is a valid type
+                    return BooleanType_1.BooleanType.instance;
+                }
+                break;
         }
+        if (bothDynamic) {
+            return DynamicType_1.DynamicType.instance;
+        }
+        return undefined;
+    }
+    getHighestPriorityType(types, depth = 0) {
+        let result;
+        if (depth > 4) {
+            // shortcut for very complicated types, or self-referencing union types
+            return DynamicType_1.DynamicType.instance;
+        }
+        for (let type of types) {
+            if ((0, reflection_1.isUnionType)(type)) {
+                type = (0, helpers_1.getUniqueType)([type], UnionType_1.unionTypeFactory);
+                if ((0, reflection_1.isUnionType)(type)) {
+                    type = this.getHighestPriorityType(type.types, depth + 1);
+                }
+            }
+            if (!result) {
+                result = type;
+            }
+            else {
+                if (type.binaryOpPriorityLevel < result.binaryOpPriorityLevel) {
+                    result = type;
+                }
+                else if (type.binaryOpPriorityLevel === result.binaryOpPriorityLevel && !result.isEqual(type)) {
+                    // equal priority types, but not equal types, like Boolean and String... just be dynamic at this point
+                    result = DynamicType_1.DynamicType.instance;
+                }
+            }
+            if ((0, reflection_1.isUninitializedType)(type)) {
+                return type;
+            }
+            if ((0, reflection_1.isVoidType)(type)) {
+                return type;
+            }
+            if ((0, reflection_1.isInvalidTypeLike)(type)) {
+                return type;
+            }
+            if ((0, reflection_1.isObjectType)(type) && !(0, reflection_1.isDynamicType)(type)) {
+                result = type;
+            }
+            if ((0, reflection_1.isDynamicType)(type)) {
+                result = type;
+            }
+        }
+        return result !== null && result !== void 0 ? result : DynamicType_1.DynamicType.instance;
+    }
+    /**
+     * Return the type of the result of a unary operator
+     */
+    unaryOperatorResultType(operator, exprType) {
+        if ((0, reflection_1.isUnionType)(exprType)) {
+            exprType = this.getHighestPriorityType(exprType.types);
+        }
+        if ((0, reflection_1.isVoidType)(exprType) || (0, reflection_1.isInvalidTypeLike)(exprType) || (0, reflection_1.isUninitializedType)(exprType)) {
+            return undefined;
+        }
+        if ((0, reflection_1.isDynamicType)(exprType) || (0, reflection_1.isObjectType)(exprType)) {
+            return exprType;
+        }
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (operator.kind) {
+            // Math operators
+            case TokenKind_1.TokenKind.Plus: // (`num = +num` is valid syntax)
+            case TokenKind_1.TokenKind.Minus:
+                if ((0, reflection_1.isNumberTypeLike)(exprType)) {
+                    // a negative number will be the same type, eg, double->double, int->int, etc.
+                    return this.getUnboxedType(exprType);
+                }
+                break;
+            case TokenKind_1.TokenKind.Not:
+                if ((0, reflection_1.isBooleanTypeLike)(exprType)) {
+                    return BooleanType_1.BooleanType.instance;
+                }
+                else if ((0, reflection_1.isNumberTypeLike)(exprType)) {
+                    //numbers can be "notted"
+                    // by default they go to ints, except longints, which stay that way
+                    if ((0, reflection_1.isLongIntegerTypeLike)(exprType)) {
+                        return LongIntegerType_1.LongIntegerType.instance;
+                    }
+                    return IntegerType_1.IntegerType.instance;
+                }
+                break;
+        }
+        return undefined;
+    }
+    getUnboxedType(boxedType) {
+        if ((0, reflection_1.isIntegerTypeLike)(boxedType)) {
+            return IntegerType_1.IntegerType.instance;
+        }
+        else if ((0, reflection_1.isLongIntegerTypeLike)(boxedType)) {
+            return LongIntegerType_1.LongIntegerType.instance;
+        }
+        else if ((0, reflection_1.isFloatTypeLike)(boxedType)) {
+            return FloatType_1.FloatType.instance;
+        }
+        else if ((0, reflection_1.isDoubleTypeLike)(boxedType)) {
+            return DoubleType_1.DoubleType.instance;
+        }
+        else if ((0, reflection_1.isBooleanTypeLike)(boxedType)) {
+            return BooleanType_1.BooleanType.instance;
+        }
+        else if ((0, reflection_1.isStringTypeLike)(boxedType)) {
+            return StringType_1.StringType.instance;
+        }
+        else if ((0, reflection_1.isInvalidTypeLike)(boxedType)) {
+            return InvalidType_1.InvalidType.instance;
+        }
+        return boxedType;
     }
     /**
      * 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();
@@ -939,21 +1680,18 @@ class Util {
             return '.d.bs';
         }
         else {
-            const idx = filePath.lastIndexOf('.');
-            if (idx > -1) {
-                return filePath.substring(idx);
-            }
+            return path.extname(filePath).toLowerCase();
         }
     }
     /**
      * Load and return the list of plugins
      */
     loadPlugins(cwd, pathOrModules, onError) {
-        const logger = new Logger_1.Logger();
+        const logger = (0, logging_1.createLogger)();
         return pathOrModules.reduce((acc, pathOrModule) => {
             if (typeof pathOrModule === 'string') {
                 try {
-                    const loaded = this.resolveRequire(cwd, pathOrModule);
+                    const loaded = requireRelative(pathOrModule, cwd);
                     const theExport = loaded.default ? loaded.default : loaded;
                     let plugin;
                     // legacy plugins returned a plugin object. If we find that, then add a warning
@@ -963,7 +1701,13 @@ class Util {
                         // the official plugin format is a factory function that returns a new instance of a plugin.
                     }
                     else if (typeof theExport === 'function') {
-                        plugin = theExport();
+                        plugin = theExport({
+                            version: this.getBrighterScriptVersion()
+                        });
+                    }
+                    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;
@@ -982,45 +1726,45 @@ class Util {
             return acc;
         }, []);
     }
-    resolveRequire(cwd, pathOrModule) {
-        let target = pathOrModule;
-        if (!path.isAbsolute(pathOrModule)) {
-            const localPath = path.resolve(cwd, pathOrModule);
-            if (fs.existsSync(localPath)) {
-                target = localPath;
-            }
-            else {
-                const modulePath = path.resolve(cwd, 'node_modules', pathOrModule);
-                if (fs.existsSync(modulePath)) {
-                    target = modulePath;
-                }
-            }
-        }
-        // eslint-disable-next-line
-        return require(target);
-    }
     /**
      * Gathers expressions, variables, and unique names from an expression.
      * This is mostly used for the ternary expression
      */
-    getExpressionInfo(expression) {
+    getExpressionInfo(expression, file) {
         const expressions = [expression];
         const variableExpressions = [];
         const uniqueVarNames = new Set();
-        // Collect all expressions. Most of these expressions are fairly small so this should be quick!
-        // This should only be called during transpile time and only when we actually need it.
-        expression === null || expression === void 0 ? void 0 : expression.walk((expression) => {
-            if (astUtils_1.isExpression(expression)) {
+        function expressionWalker(expression) {
+            if ((0, reflection_1.isExpression)(expression)) {
                 expressions.push(expression);
             }
-            if (astUtils_1.isVariableExpression(expression)) {
+            if ((0, reflection_1.isVariableExpression)(expression)) {
                 variableExpressions.push(expression);
-                uniqueVarNames.add(expression.name.text);
+                uniqueVarNames.add(expression.tokens.name.text);
             }
-        }, {
-            walkMode: astUtils_1.WalkMode.visitExpressions
+        }
+        // Collect all expressions. Most of these expressions are fairly small so this should be quick!
+        // This should only be called during transpile time and only when we actually need it.
+        expression === null || expression === void 0 ? void 0 : expression.walk(expressionWalker, {
+            walkMode: visitors_1.WalkMode.visitExpressions
         });
-        return { expressions: expressions, varExpressions: variableExpressions, uniqueVarNames: [...uniqueVarNames] };
+        //handle the expression itself (for situations when expression is a VariableExpression)
+        expressionWalker(expression);
+        const scope = file.program.getFirstScopeForFile(file);
+        let filteredVarNames = [...uniqueVarNames];
+        if (scope) {
+            filteredVarNames = filteredVarNames.filter((varName) => {
+                const varNameLower = varName.toLowerCase();
+                // TODO: include namespaces in this filter
+                return !scope.getEnumMap().has(varNameLower) &&
+                    !scope.getConstMap().has(varNameLower);
+            });
+        }
+        return { expressions: expressions, varExpressions: variableExpressions, uniqueVarNames: filteredVarNames };
+    }
+    concatAnnotationLeadingTrivia(stmt) {
+        var _a, _b;
+        return [...((_b = (_a = stmt.annotations) === null || _a === void 0 ? void 0 : _a.map(anno => { var _a; return (_a = anno.leadingTrivia) !== null && _a !== void 0 ? _a : []; }).flat()) !== null && _b !== void 0 ? _b : []), ...stmt.leadingTrivia];
     }
     /**
      * Create a SourceNode that maps every line to itself. Useful for creating maps for files
@@ -1037,129 +1781,105 @@ 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
+     * Converts a path into a standardized format (drive letter to lower, remove extra slashes, use single slash type, resolve relative parts, etc...)
      */
-    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;
+    standardizePath(thePath) {
+        //if we have the value in cache already, return it
+        if (this.standardizePathCache.has(thePath)) {
+            return this.standardizePathCache.get(thePath);
         }
-    }
-    /**
-     * 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);
+        const originalPath = thePath;
+        if (typeof thePath !== 'string') {
+            return thePath;
         }
-        else {
-            return pkgPath;
+        //handle `virtual:/` paths specially - just normalize slashes, don't use path.normalize which would mangle the `virtual:` prefix
+        if (/^virtual:[\/\\]/i.test(thePath)) {
+            // Strip the `virtual:` prefix, normalize slashes, then re-add the prefix
+            thePath = 'virtual:/' + thePath.slice(8).replace(/^[\/\\]+/, '').replace(/[\/\\]+/g, '/').toLowerCase();
+            this.standardizePathCache.set(originalPath, thePath);
+            return thePath;
         }
-    }
-    standardizePath(thePath) {
-        return exports.util.driveLetterToLower(rokuDeploy.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);
+        //windows path.normalize will convert all slashes to backslashes and remove duplicates
+        if (this.isWindows) {
+            thePath = path.win32.normalize(thePath);
         }
-        for (let i = positions.length - 1; i >= 0; i--) {
-            const position = positions[i];
-            source = source.slice(0, position) + 'bslib_' + source.slice(position);
+        else {
+            //replace all windows or consecutive slashes with path.sep
+            thePath = thePath.replace(/[\/\\]+/g, '/');
+            // only use path.normalize if dots are present since it's expensive
+            if (thePath.includes('./')) {
+                thePath = path.posix.normalize(thePath);
+            }
+        }
+        // Lowercase drive letter on Windows-like paths (e.g., "C:/...")
+        if (thePath.charCodeAt(1) === 58 /* : */) {
+            // eslint-disable-next-line no-var
+            var firstChar = thePath.charCodeAt(0);
+            if (firstChar >= 65 && firstChar <= 90) {
+                thePath = String.fromCharCode(firstChar + 32) + thePath.slice(1);
+            }
         }
-        await fsExtra.writeFile(`${stagingDir}/source/bslib.brs`, source);
+        this.standardizePathCache.set(originalPath, thePath);
+        return thePath;
     }
     /**
-     * Given a Diagnostic or BsDiagnostic, return a copy of the diagnostic
+     * 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) {
-        var _a;
-        return {
+    toDiagnostic(diagnostic, relatedInformationFallbackLocation) {
+        var _a, _b, _c, _d, _e;
+        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.createLocationFromRange('   ', exports.util.createRange(0, 0, 0, 0))
+            });
+        }
+        const range = (_c = (_b = diagnostic.location) === null || _b === void 0 ? void 0 : _b.range) !== null && _c !== void 0 ? _c : diagnostic.range;
+        let result = {
             severity: diagnostic.severity,
-            range: diagnostic.range,
+            range: 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
-                return Object.assign({}, x);
-            }),
-            code: diagnostic.code,
-            source: 'brs'
+                const clone = Object.assign({}, x);
+                if (!clone.location) {
+                    // use the fallback location if available
+                    if (relatedInformationFallbackLocation) {
+                        clone.location = exports.util.createLocationFromRange(relatedInformationFallbackLocation, range);
+                    }
+                    else {
+                        //remove this related information so it doesn't bring crash the language server
+                        return undefined;
+                    }
+                }
+                return clone;
+                //filter out null relatedInformation items
+            }).filter((x) => Boolean(x)),
+            code: diagnostic.code ? diagnostic.code : diagnostic.legacyCode,
+            source: (_d = diagnostic.source) !== null && _d !== void 0 ? _d : '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 };
-    }
-    /**
-     * Finds the array of callables from a container map, taking into account the function from which it was called
-     * If the callable was called in a function in a namespace, functions in that namespace are preferred
-     * @return an array with callable containers - could be empty if nothing was found
-     */
-    getCallableContainersFromContainerMapByFunctionCall(callablesByLowerName, expCall) {
-        let callablesWithThisName = [];
-        const lowerName = expCall.name.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);
+        if (((_e = diagnostic === null || diagnostic === void 0 ? void 0 : diagnostic.tags) === null || _e === void 0 ? void 0 : _e.length) > 0) {
+            result.tags = diagnostic.tags;
         }
-        return callablesWithThisName;
+        return result;
     }
     /**
      * Sort an array of objects that have a Range
      */
     sortByRange(locatables) {
         //sort the tokens by range
-        return locatables.sort((a, b) => {
+        return locatables === null || locatables === void 0 ? void 0 : locatables.sort((a, b) => {
+            //handle undefined tokens to prevent crashes
+            if (!(a === null || a === void 0 ? void 0 : a.range)) {
+                return 1;
+            }
+            if (!(b === null || b === void 0 ? void 0 : b.range)) {
+                return -1;
+            }
             //start line
             if (a.range.start.line < b.range.start.line) {
                 return -1;
@@ -1192,26 +1912,873 @@ class Util {
         });
     }
     /**
-     * Split the given text and return ranges for each chunk.
-     * Only works for single-line strings
-     */
-    splitGetRange(separator, text, range) {
-        const chunks = text.split(separator);
-        const result = [];
-        let offset = 0;
-        for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i];
-            //only keep nonzero chunks
-            if (chunk.length > 0) {
-                result.push({
-                    text: chunk,
-                    range: this.createRange(range.start.line, range.start.character + offset, range.end.line, range.start.character + offset + chunk.length)
+     * Wrap the given code in a markdown code fence (with the language)
+     */
+    mdFence(code, language = '') {
+        return '```' + language + '\n' + code + '\n```';
+    }
+    /**
+     * Gets each part of the dotted get.
+     * @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) {
+        //this is a hot function and has been optimized. Don't rewrite unless necessary
+        const parts = [];
+        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.CallfuncExpression:
+                    parts.push(nextPart === null || nextPart === void 0 ? void 0 : nextPart.tokens.methodName);
+                    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.location));
+                    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, lastSep = '.') {
+        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++) {
+            //some parts can be undefined (e.g. an unfinished `widget@.` callfunc with no method name)
+            const part = parts[i];
+            if (!part) {
+                continue;
+            }
+            result += (i === parts.length - 1 && parseMode === Parser_1.ParseMode.BrighterScript ? lastSep : sep) + part.text;
+        }
+        return result;
+        /* eslint-enable no-var */
+    }
+    /**
+     * Break an expression into each part.
+     */
+    splitExpression(expression) {
+        const parts = [expression];
+        let nextPart = expression;
+        while (nextPart) {
+            if ((0, reflection_1.isDottedGetExpression)(nextPart) || (0, reflection_1.isIndexedGetExpression)(nextPart) || (0, reflection_1.isXmlAttributeGetExpression)(nextPart)) {
+                nextPart = nextPart.obj;
+            }
+            else if ((0, reflection_1.isCallExpression)(nextPart) || (0, reflection_1.isCallfuncExpression)(nextPart)) {
+                nextPart = nextPart.callee;
+            }
+            else if ((0, reflection_1.isTypeExpression)(nextPart)) {
+                nextPart = nextPart.expression;
+            }
+            else {
+                break;
+            }
+            parts.unshift(nextPart);
+        }
+        return parts;
+    }
+    /**
+     * Returns an integer if valid, or undefined. Eliminates checking for NaN
+     */
+    parseInt(value) {
+        const result = parseInt(value);
+        if (!isNaN(result)) {
+            return result;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Converts a range to a string in the format 1:2-3:4
+     */
+    rangeToString(range) {
+        var _a, _b, _c, _d;
+        return `${(_a = range === null || range === void 0 ? void 0 : range.start) === null || _a === void 0 ? void 0 : _a.line}:${(_b = range === null || range === void 0 ? void 0 : range.start) === null || _b === void 0 ? void 0 : _b.character}-${(_c = range === null || range === void 0 ? void 0 : range.end) === null || _c === void 0 ? void 0 : _c.line}:${(_d = range === null || range === void 0 ? void 0 : range.end) === null || _d === void 0 ? void 0 : _d.character}`;
+    }
+    validateTooDeepFile(file) {
+        var _a, _b;
+        //find any files nested too deep
+        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(destPath);
+        if (fileDepth >= 8) {
+            (_b = file.program) === null || _b === void 0 ? void 0 : _b.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.detectedTooDeepFileSource(fileDepth)), { location: exports.util.createLocationFromFileRange(file, this.createRange(0, 0, 0, Number.MAX_VALUE)) }));
+        }
+    }
+    /**
+     * Execute dispose for a series of disposable items
+     * @param disposables a list of functions or disposables
+     */
+    applyDispose(disposables) {
+        var _a;
+        for (const disposable of disposables !== null && disposables !== void 0 ? disposables : []) {
+            if (typeof disposable === 'function') {
+                disposable();
+            }
+            else {
+                (_a = disposable === null || disposable === void 0 ? void 0 : disposable.dispose) === null || _a === void 0 ? void 0 : _a.call(disposable);
+            }
+        }
+    }
+    /**
+     * Race a series of promises, and return the first one that resolves AND matches the matcher function.
+     * If all of the promises reject, then this will emit an AggregatreError with all of the errors.
+     * If at least one promise resolves, then this will log all of the errors to the console
+     * If at least one promise resolves but none of them match the matcher, then this will return undefined.
+     * @param promises all of the promises to race
+     * @param matcher a function that should return true if this value should be kept. Returning any value other than true means `false`
+     * @returns the first resolved value that matches the matcher, or undefined if none of them match
+     */
+    async promiseRaceMatch(promises, matcher) {
+        const workingPromises = [
+            ...promises
+        ];
+        const results = [];
+        let returnValue;
+        while (workingPromises.length > 0) {
+            //race the promises. If any of them resolve, evaluate it against the matcher. If that passes, return the value. otherwise, eliminate this promise and try again
+            const result = await Promise.race(workingPromises.map((promise, i) => {
+                return Promise.resolve(promise)
+                    .then(value => ({ value: value, index: i }))
+                    .catch(error => ({ error: error, index: i }));
+            }));
+            results.push(result);
+            //if we got a value and it matches the matcher, return it
+            if ('value' in result && (matcher === null || matcher === void 0 ? void 0 : matcher(result.value)) === true) {
+                returnValue = result.value;
+                break;
+            }
+            //remove this non-matched (or errored) promise from the list and try again
+            workingPromises.splice(result.index, 1);
+        }
+        const errors = results
+            .filter(x => 'error' in x)
+            .map(x => x.error);
+        //if all of them crashed, then reject
+        if (promises.length > 0 && errors.length === promises.length) {
+            throw new AggregateError(errors, 'All requests failed. First error message: ' + errors[0].message);
+        }
+        else {
+            //log all of the errors
+            for (const error of errors) {
+                console.error(error);
+            }
+        }
+        //return the matched value, or undefined if there wasn't one
+        return returnValue;
+    }
+    /**
+     * Wraps SourceNode's constructor to be compatible with the TranspileResult type
+     */
+    sourceNodeFromTranspileResult(line, column, source, chunks, name) {
+        // we can use a typecast rather than actually transforming the data because SourceNode
+        // accepts a more permissive type than its typedef states
+        return new source_map_1.SourceNode(line, column, source, chunks, name);
+    }
+    /**
+     * 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, _e;
+        let fullChainName = '';
+        let fullErrorName = '';
+        let itemName = '';
+        let previousTypeName = '';
+        let parentTypeName = '';
+        let itemTypeKind = '';
+        let parentTypeKind = '';
+        let astNode;
+        let errorLocation;
+        let containsDynamic = false;
+        let continueResolvingAllItems = true;
+        let crossedCallFunc = 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;
+            if (continueResolvingAllItems) {
+                parentTypeName = previousTypeName;
+                parentTypeKind = itemTypeKind;
+                fullErrorName = previousTypeName ? `${previousTypeName}${dotSep}${chainItem.name}` : chainItem.name;
+                itemTypeKind = (_c = chainItem.type) === null || _c === void 0 ? void 0 : _c.kind;
+                let typeString = (_d = chainItem.type) === null || _d === void 0 ? void 0 : _d.toString();
+                let typeToFindStringFor = chainItem.type;
+                while (typeToFindStringFor) {
+                    if ((0, reflection_1.isCompoundType)(chainItem.type)) {
+                        typeString = `(${typeToFindStringFor.toString()})`;
+                        break;
+                    }
+                    else if ((0, reflection_1.isCallableType)(typeToFindStringFor)) {
+                        if ((0, reflection_1.isTypedFunctionType)(typeToFindStringFor) && i < typeChain.length - 1) {
+                            typeToFindStringFor = typeToFindStringFor.returnType;
+                        }
+                        else {
+                            typeString = 'function';
+                            break;
+                        }
+                        parentTypeName = previousTypeName;
+                    }
+                    else if ((0, reflection_1.isNamespaceType)(typeToFindStringFor) && parentTypeName) {
+                        const chainItemTypeName = typeToFindStringFor.toString();
+                        typeString = parentTypeName + '.' + chainItemTypeName;
+                        if (chainItemTypeName.toLowerCase().startsWith(parentTypeName.toLowerCase())) {
+                            // the following namespace already knows...
+                            typeString = chainItemTypeName;
+                        }
+                        break;
+                    }
+                    else {
+                        typeString = typeToFindStringFor === null || typeToFindStringFor === void 0 ? void 0 : typeToFindStringFor.toString();
+                        break;
+                    }
+                }
+                previousTypeName = typeString !== null && typeString !== void 0 ? typeString : '';
+                itemName = chainItem.name;
+                astNode = chainItem.astNode;
+                containsDynamic = containsDynamic || ((0, reflection_1.isDynamicType)(chainItem.type) && !(0, reflection_1.isAnyReferenceType)(chainItem.type));
+                crossedCallFunc = crossedCallFunc || ((_e = chainItem.data) === null || _e === void 0 ? void 0 : _e.isFromCallFunc);
+                if (!chainItem.isResolved) {
+                    errorLocation = chainItem.location;
+                    continueResolvingAllItems = false;
+                }
+            }
+        }
+        return {
+            itemName: itemName,
+            itemTypeKind: itemTypeKind,
+            itemParentTypeName: parentTypeName,
+            itemParentTypeKind: parentTypeKind,
+            fullNameOfItem: fullErrorName,
+            fullChainName: fullChainName,
+            location: errorLocation,
+            containsDynamic: containsDynamic,
+            astNode: astNode,
+            crossedCallFunc: crossedCallFunc
+        };
+    }
+    getCircularReferenceDiagnosticDetail(circularReferenceInfo, defaultName = '') {
+        if (!circularReferenceInfo || !circularReferenceInfo.referenceChainNames) {
+            if (defaultName) {
+                return [defaultName];
+            }
+            return [];
+        }
+        if (circularReferenceInfo.referenceChainNames[0] === circularReferenceInfo.referenceChainNames[circularReferenceInfo.referenceChainNames.length - 1]) {
+            // last element is same as first it will read okay
+            return circularReferenceInfo.referenceChainNames;
+        }
+        return [...circularReferenceInfo.referenceChainNames, circularReferenceInfo.referenceChainNames[0]];
+    }
+    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 === null || expression === void 0 ? void 0 : expression.parent) ||
+            (0, reflection_1.isTypedArrayExpression)(expression) ||
+            (0, reflection_1.isTypedArrayExpression)(expression === null || expression === void 0 ? void 0 : expression.parent)) {
+            return true;
+        }
+        if ((0, reflection_1.isBinaryExpression)(expression === null || expression === void 0 ? void 0 : expression.parent)) {
+            let currentExpr = expression.parent;
+            while ((0, reflection_1.isBinaryExpression)(currentExpr) && (currentExpr.tokens.operator.kind === TokenKind_1.TokenKind.Or || currentExpr.tokens.operator.kind === TokenKind_1.TokenKind.And)) {
+                currentExpr = currentExpr.parent;
+            }
+            return (0, reflection_1.isTypeExpression)(currentExpr) || (0, reflection_1.isTypedArrayExpression)(currentExpr);
+        }
+        return false;
+    }
+    /**
+     * Parse the `sourceMappingURL` comment from file contents and resolve it to a RawSourceMap.
+     * Handles inline base64 data URIs, absolute paths, relative paths (resolved against srcPath's
+     * directory), and falls back to a co-located `<srcPath>.map` file.
+     * Supports both BrightScript-style comments (`'//# sourceMappingURL=...`) and XML-style
+     * comments (`<!--//# sourceMappingURL=... -->`).
+     * Returns undefined if no map can be found.
+     */
+    async resolveInputSourceMap(fileContents, srcPath) {
+        // Match sourceMappingURL - [^\s]+ stops at whitespace (safe, no backtracking risk).
+        // Strip any trailing XML comment close (either --> or --!>) that may have been captured
+        // when the URL is not followed by a space in an XML comment like <!--//# ...=url-->.
+        const match = /['"]?\/\/# sourceMappingURL=([^\s]+)/m.exec(fileContents);
+        if (match) {
+            const url = match[1].replace(/--!?>$/, '').trim();
+            if (url.startsWith('data:')) {
+                // inline base64: data:application/json;base64,<b64>
+                const b64Match = /base64,([A-Za-z0-9+/=]+)$/.exec(url);
+                if (b64Match) {
+                    return JSON.parse(Buffer.from(b64Match[1], 'base64').toString('utf8'));
+                }
+            }
+            else {
+                const mapPath = path.isAbsolute(url) ? url : path.resolve(path.dirname(srcPath), url);
+                if (await fsExtra.pathExists(mapPath)) {
+                    return JSON.parse(await fsExtra.readFile(mapPath, 'utf8'));
+                }
+            }
+        }
+        // no usable sourceMappingURL; try co-located <srcPath>.map
+        const colocated = `${srcPath}.map`;
+        if (await fsExtra.pathExists(colocated)) {
+            return JSON.parse(await fsExtra.readFile(colocated, 'utf8'));
+        }
+        return undefined;
+    }
+    /**
+     * Apply an input sourcemap to a generated SourceMapGenerator, chaining mappings so the
+     * output traces back through the input map to the original source.
+     */
+    async applySourceMap(generator, inputMap, sourceFile) {
+        await source_map_1.SourceMapConsumer.with(inputMap, null, (consumer) => {
+            generator.applySourceMap(consumer, sourceFile);
+        });
+    }
+    /**
+     * Chain a prebuild input sourcemap (loaded from a co-located `.map` file or a
+     * `sourceMappingURL` comment in the file contents) onto an existing serialized output
+     * sourcemap. Returns the chained sourcemap as a JSON string. If no input map is found,
+     * the original output map JSON is returned unchanged.
+     */
+    async chainInputSourceMap(outputMapJson, file) {
+        var _a;
+        const inputMap = await this.resolveInputSourceMap((_a = file.fileContents) !== null && _a !== void 0 ? _a : '', file.srcPath);
+        if (!inputMap) {
+            return outputMapJson;
+        }
+        const { SourceMapConsumer: Consumer, SourceMapGenerator: Generator } = await Promise.resolve().then(() => require('source-map'));
+        const outputMap = JSON.parse(outputMapJson);
+        return Consumer.with(outputMap, null, async (outputConsumer) => {
+            const generator = Generator.fromSourceMap(outputConsumer);
+            await Consumer.with(inputMap, null, (inputConsumer) => {
+                generator.applySourceMap(inputConsumer, file.srcPath);
+            });
+            return generator.toString();
+        });
+    }
+    isBuiltInType(typeName) {
+        const typeNameLower = typeName.toLowerCase();
+        if (typeNameLower.startsWith('rosgnode')) {
+            // NOTE: this is unsafe and only used to avoid validation errors in backported v1 type syntax
+            return true;
+        }
+        return false;
+    }
+    isGenericNodeType(type) {
+        if ((0, reflection_1.isComponentType)(type)) {
+            const lowerName = type.toString().toLowerCase();
+            if (lowerName === 'rosgnode' || lowerName === 'rosgnodenode') {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasAnyRequiredSymbolChanged(requiredSymbols, changedSymbols) {
+        if (!requiredSymbols || !changedSymbols) {
+            return false;
+        }
+        const runTimeChanges = changedSymbols.get(1 /* SymbolTypeFlag.runtime */);
+        const typeTimeChanges = changedSymbols.get(2 /* SymbolTypeFlag.typetime */);
+        for (const symbol of requiredSymbols) {
+            if (this.setContainsUnresolvedSymbol(runTimeChanges, symbol) || this.setContainsUnresolvedSymbol(typeTimeChanges, symbol)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    setContainsUnresolvedSymbol(symbolLowerNameSet, symbol) {
+        if (!symbolLowerNameSet || symbolLowerNameSet.size === 0) {
+            return false;
+        }
+        for (const possibleNameLower of symbol.lookups) {
+            if (symbolLowerNameSet.has(possibleNameLower)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getCustomTypesInSymbolTree(setToFill, type, filter) {
+        var _a, _b;
+        const subSymbolTypes = (0, reflection_1.isCompoundType)(type)
+            ? type.types
+            : (_b = (_a = type.getMemberTable()) === null || _a === void 0 ? void 0 : _a.getAllSymbols(1 /* SymbolTypeFlag.runtime */).map(sym => sym.type)) !== null && _b !== void 0 ? _b : [];
+        for (const subSymbolType of subSymbolTypes) {
+            if (!(subSymbolType === null || subSymbolType === void 0 ? void 0 : subSymbolType.isBuiltIn) && !setToFill.has(subSymbolType)) {
+                if (filter && !filter(subSymbolType)) {
+                    continue;
+                }
+                // if this is a custom type, and we haven't added it to the types to check to see if can add it to the additional types
+                // add the type, and investigate any members
+                setToFill.add(subSymbolType);
+                this.getCustomTypesInSymbolTree(setToFill, subSymbolType, filter);
+            }
+        }
+    }
+    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, '');
+    }
+    hasLeadingComments(input) {
+        var _a;
+        const leadingTrivia = (0, Token_1.isToken)(input) ? input === null || input === void 0 ? void 0 : input.leadingTrivia : (_a = input === null || input === void 0 ? void 0 : input.leadingTrivia) !== null && _a !== void 0 ? _a : [];
+        return !!(leadingTrivia === null || leadingTrivia === void 0 ? void 0 : leadingTrivia.find(t => (t === null || t === void 0 ? void 0 : t.kind) === TokenKind_1.TokenKind.Comment));
+    }
+    getLeadingComments(input) {
+        var _a;
+        const leadingTrivia = (0, Token_1.isToken)(input) ? input === null || input === void 0 ? void 0 : input.leadingTrivia : (_a = input === null || input === void 0 ? void 0 : input.leadingTrivia) !== null && _a !== void 0 ? _a : [];
+        return leadingTrivia.filter(t => (t === null || t === void 0 ? void 0 : t.kind) === TokenKind_1.TokenKind.Comment);
+    }
+    isLeadingCommentOnSameLine(line, input) {
+        var _a;
+        const leadingCommentRange = (_a = this.getLeadingComments(input)) === null || _a === void 0 ? void 0 : _a[0];
+        if (leadingCommentRange) {
+            return this.linesTouch(line, leadingCommentRange === null || leadingCommentRange === void 0 ? void 0 : leadingCommentRange.location);
+        }
+        return false;
+    }
+    isClassUsedAsFunction(potentialClassType, expression, options) {
+        var _a, _b, _c;
+        // eslint-disable-next-line no-bitwise
+        if (((_a = options === null || options === void 0 ? void 0 : options.flags) !== null && _a !== void 0 ? _a : 0) & 1 /* SymbolTypeFlag.runtime */ &&
+            (0, reflection_1.isClassType)(potentialClassType) &&
+            !options.isExistenceTest &&
+            ((_b = potentialClassType.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === ((_c = this.getAllDottedGetPartsAsString(expression)) === null || _c === void 0 ? void 0 : _c.toLowerCase()) &&
+            !(expression === null || expression === void 0 ? void 0 : expression.findAncestor(reflection_1.isNewExpression))) {
+            return true;
+        }
+        return false;
+    }
+    getSpecialCaseCallExpressionReturnType(callExpr, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+        if ((0, reflection_1.isVariableExpression)(callExpr.callee) && callExpr.callee.tokens.name.text.toLowerCase() === 'createobject') {
+            const componentName = (0, reflection_1.isLiteralString)(callExpr.args[0]) ? (_b = (_a = callExpr.args[0].tokens.value) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.replace(/"/g, '') : '';
+            const nodeType = componentName.toLowerCase() === 'rosgnode' && (0, reflection_1.isLiteralString)(callExpr.args[1]) ? (_d = (_c = callExpr.args[1].tokens.value) === null || _c === void 0 ? void 0 : _c.text) === null || _d === void 0 ? void 0 : _d.replace(/"/g, '') : '';
+            if (componentName === null || componentName === void 0 ? void 0 : componentName.toLowerCase().startsWith('ro')) {
+                let fullName = componentName + nodeType;
+                if (nodeType.includes(':')) {
+                    // This node has a colon in its name, most likely from a component Library
+                    // This componentType is most likely unknown, so return `roSGNode`
+                    fullName = 'roSGNode';
+                }
+                const data = {};
+                const symbolTable = callExpr.getSymbolTable();
+                const foundType = symbolTable.getSymbolType(fullName, {
+                    flags: 2 /* SymbolTypeFlag.typetime */,
+                    data: data,
+                    tableProvider: () => callExpr === null || callExpr === void 0 ? void 0 : callExpr.getSymbolTable(),
+                    fullName: fullName
                 });
+                if (foundType) {
+                    return foundType;
+                }
             }
-            offset += chunk.length + separator.length;
+        }
+        else if ((0, reflection_1.isDottedGetExpression)(callExpr.callee) &&
+            ((_g = (_f = (_e = callExpr.callee.tokens) === null || _e === void 0 ? void 0 : _e.name) === null || _f === void 0 ? void 0 : _f.text) === null || _g === void 0 ? void 0 : _g.toLowerCase()) === 'callfunc' &&
+            (0, reflection_1.isLiteralString)((_h = callExpr.args) === null || _h === void 0 ? void 0 : _h[0])) {
+            return this.getCallFuncType(callExpr, (_k = (_j = callExpr.args) === null || _j === void 0 ? void 0 : _j[0]) === null || _k === void 0 ? void 0 : _k.tokens.value, options);
+        }
+        else if ((0, reflection_1.isDottedGetExpression)(callExpr.callee) &&
+            ((_o = (_m = (_l = callExpr.callee.tokens) === null || _l === void 0 ? void 0 : _l.name) === null || _m === void 0 ? void 0 : _m.text) === null || _o === void 0 ? void 0 : _o.toLowerCase()) === 'createchild' &&
+            (0, reflection_1.isComponentType)((_p = callExpr.callee.obj) === null || _p === void 0 ? void 0 : _p.getType({ flags: 1 /* SymbolTypeFlag.runtime */ })) &&
+            (0, reflection_1.isLiteralString)((_q = callExpr.args) === null || _q === void 0 ? void 0 : _q[0])) {
+            const fullName = `roSGNode${(_u = (_t = (_s = (_r = callExpr.args) === null || _r === void 0 ? void 0 : _r[0].tokens) === null || _s === void 0 ? void 0 : _s.value) === null || _t === void 0 ? void 0 : _t.text) === null || _u === void 0 ? void 0 : _u.replace(/"/g, '')}`;
+            const data = {};
+            const symbolTable = callExpr.getSymbolTable();
+            return symbolTable.getSymbolType(fullName, {
+                flags: 2 /* SymbolTypeFlag.typetime */,
+                data: data,
+                tableProvider: () => callExpr === null || callExpr === void 0 ? void 0 : callExpr.getSymbolTable(),
+                fullName: fullName
+            });
+        }
+    }
+    getCallFuncType(callExpr, methodNameToken, options) {
+        var _a, _b, _c, _d;
+        let result;
+        let methodName = (_a = methodNameToken === null || methodNameToken === void 0 ? void 0 : methodNameToken.text) === null || _a === void 0 ? void 0 : _a.replace(/"/g, ''); // remove quotes if it was the first arg of .callFunc()
+        //bail early when there's no method name (e.g. an unfinished `widget@.` callfunc).
+        //downstream getCallFuncType / ReferenceType paths assume a non-empty member name and
+        //will eventually try `name.toLowerCase()` on undefined and crash.
+        if (!methodName) {
+            return undefined;
+        }
+        // a little hacky here with checking options.ignoreCall because callFuncExpression has the method name
+        // It's nicer for CallExpression, because it's a call on any expression.
+        let calleeType;
+        if ((0, reflection_1.isCallfuncExpression)(callExpr)) {
+            calleeType = callExpr.callee.getType(Object.assign(Object.assign({}, options), { flags: 1 /* SymbolTypeFlag.runtime */, ignoreCall: false }));
+        }
+        else if ((0, reflection_1.isCallExpression)(callExpr) && (0, reflection_1.isDottedGetExpression)(callExpr.callee)) {
+            calleeType = callExpr.callee.obj.getType(Object.assign(Object.assign({}, options), { flags: 1 /* SymbolTypeFlag.runtime */, ignoreCall: false }));
+        }
+        const funcType = (_b = calleeType === null || calleeType === void 0 ? void 0 : calleeType.getCallFuncType) === null || _b === void 0 ? void 0 : _b.call(calleeType, methodName, options);
+        if (funcType) {
+            (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry({
+                name: methodName,
+                type: funcType,
+                data: options.data,
+                location: methodNameToken.location,
+                separatorToken: (0, creators_1.createToken)(TokenKind_1.TokenKind.Callfunc),
+                astNode: callExpr
+            }));
+            if (options.ignoreCall) {
+                result = funcType;
+            }
+            else if ((0, reflection_1.isCallableType)(funcType) && (!(0, reflection_1.isReferenceType)(funcType.returnType) || funcType.returnType.isResolvable())) {
+                result = funcType.returnType;
+            }
+            else if (!(0, reflection_1.isReferenceType)(funcType) && ((_d = funcType === null || funcType === void 0 ? void 0 : funcType.returnType) === null || _d === void 0 ? void 0 : _d.isResolvable())) {
+                result = funcType.returnType;
+            }
+            else if (this.isUnionOfFunctions(funcType)) {
+                result = this.getReturnTypeOfUnionOfFunctions(funcType);
+            }
+            else {
+                result = new ReferenceType_1.TypePropertyReferenceType(funcType, 'returnType');
+            }
+        }
+        if ((0, reflection_1.isVoidType)(result)) {
+            // CallFunc will always return invalid, even if function called is `as void`
+            result = DynamicType_1.DynamicType.instance;
+        }
+        if (options.data && !options.ignoreCall) {
+            options.data.isFromCallFunc = true;
         }
         return result;
     }
+    isUnionOfFunctions(type, allowReferenceTypes = false) {
+        if ((0, reflection_1.isUnionType)(type)) {
+            const callablesInUnion = type.types.filter(t => (0, reflection_1.isCallableType)(t) || (allowReferenceTypes && (0, reflection_1.isReferenceType)(t)));
+            return callablesInUnion.length === type.types.length && callablesInUnion.length > 0;
+        }
+        return false;
+    }
+    isIntersectionOfFunctions(type, allowReferenceTypes = false) {
+        if ((0, reflection_1.isIntersectionType)(type)) {
+            const callablesInUnion = type.types.filter(t => (0, reflection_1.isCallableType)(t) || (allowReferenceTypes && (0, reflection_1.isReferenceType)(t)));
+            return callablesInUnion.length === type.types.length && callablesInUnion.length > 0;
+        }
+        return false;
+    }
+    getFunctionTypeFromUnion(type) {
+        if (this.isUnionOfFunctions(type)) {
+            const typedFuncsInUnion = type.types.filter(reflection_1.isTypedFunctionType);
+            if (typedFuncsInUnion.length < type.types.length) {
+                // has non-typedFuncs in union
+                return FunctionType_1.FunctionType.instance;
+            }
+            const exampleFunc = typedFuncsInUnion[0];
+            const cumulativeFunction = new types_1.TypedFunctionType((0, helpers_1.getUniqueType)(typedFuncsInUnion.map(f => f.returnType), (types) => new UnionType_1.UnionType(types)))
+                .setName(exampleFunc.name)
+                .setSub(exampleFunc.isSub);
+            for (const param of exampleFunc.params) {
+                cumulativeFunction.addParameter(param.name, param.type, param.isOptional);
+            }
+            return cumulativeFunction;
+        }
+        return undefined;
+    }
+    getFunctionTypeFromIntersection(type) {
+        if (this.isIntersectionOfFunctions(type)) {
+            const typedFuncsInUnion = type.types.filter(reflection_1.isTypedFunctionType);
+            if (typedFuncsInUnion.length < type.types.length) {
+                // has non-typedFuncs in union
+                return FunctionType_1.FunctionType.instance;
+            }
+            const exampleFunc = typedFuncsInUnion[0];
+            const cumulativeFunction = new types_1.TypedFunctionType((0, helpers_1.getUniqueType)(typedFuncsInUnion.map(f => f.returnType), (types) => new IntersectionType_1.IntersectionType(types)))
+                .setName(exampleFunc.name)
+                .setSub(exampleFunc.isSub);
+            for (const param of exampleFunc.params) {
+                cumulativeFunction.addParameter(param.name, param.type, param.isOptional);
+            }
+            return cumulativeFunction;
+        }
+        return undefined;
+    }
+    getReturnTypeOfUnionOfFunctions(type) {
+        if (this.isUnionOfFunctions(type, true)) {
+            const typedFuncsInUnion = type.types.filter(t => (0, reflection_1.isTypedFunctionTypeLike)(t) || (0, reflection_1.isReferenceType)(t));
+            if (typedFuncsInUnion.length < type.types.length) {
+                // is non-typedFuncs in union
+                return DynamicType_1.DynamicType.instance;
+            }
+            const funcReturns = typedFuncsInUnion.map(f => f.returnType);
+            return (0, helpers_1.getUniqueType)(funcReturns, (types) => new UnionType_1.UnionType(types));
+        }
+        return InvalidType_1.InvalidType.instance;
+    }
+    getReturnTypeOfIntersectionOfFunctions(type) {
+        if (this.isIntersectionOfFunctions(type, true)) {
+            const typedFuncsInUnion = type.types.filter(t => (0, reflection_1.isTypedFunctionType)(t) || (0, reflection_1.isReferenceType)(t));
+            if (typedFuncsInUnion.length < type.types.length) {
+                // is non-typedFuncs in union
+                return DynamicType_1.DynamicType.instance;
+            }
+            const funcReturns = typedFuncsInUnion.map(f => f.returnType);
+            return new IntersectionType_1.IntersectionType(funcReturns); //getUniqueType(funcReturns, (types) => new UnionType(types));
+        }
+        return InvalidType_1.InvalidType.instance;
+    }
+    symbolComesFromSameNode(symbolName, definingNode, symbolTable) {
+        let nsData = {};
+        let foundType = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getSymbolType(symbolName, { flags: 1 /* SymbolTypeFlag.runtime */, data: nsData });
+        if (foundType && definingNode === (nsData === null || nsData === void 0 ? void 0 : nsData.definingNode)) {
+            return true;
+        }
+        return false;
+    }
+    isCalleeMemberOfNamespace(symbolName, nodeWhereUsed, namespace) {
+        namespace = namespace !== null && namespace !== void 0 ? namespace : nodeWhereUsed.findAncestor(reflection_1.isNamespaceStatement);
+        if (!this.isVariableMemberOfNamespace(symbolName, nodeWhereUsed, namespace)) {
+            return false;
+        }
+        const exprType = nodeWhereUsed.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+        if ((0, reflection_1.isCallableType)(exprType) || (0, reflection_1.isClassType)(exprType)) {
+            return true;
+        }
+        return false;
+    }
+    isVariableMemberOfNamespace(symbolName, nodeWhereUsed, namespace) {
+        namespace = namespace !== null && namespace !== void 0 ? namespace : nodeWhereUsed.findAncestor(reflection_1.isNamespaceStatement);
+        if (!(0, reflection_1.isNamespaceStatement)(namespace)) {
+            return false;
+        }
+        const namespaceParts = namespace.getNameParts();
+        let namespaceType;
+        let symbolTable = namespace.getSymbolTable();
+        for (const part of namespaceParts) {
+            namespaceType = symbolTable.getSymbolType(part.text, { flags: 1 /* SymbolTypeFlag.runtime */ });
+            if (namespaceType) {
+                symbolTable = namespaceType.getMemberTable();
+            }
+            else {
+                return false;
+            }
+        }
+        let varData = {};
+        nodeWhereUsed.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: varData });
+        const isFromSameNodeInMemberTable = this.symbolComesFromSameNode(symbolName, varData === null || varData === void 0 ? void 0 : varData.definingNode, namespaceType === null || namespaceType === void 0 ? void 0 : namespaceType.getMemberTable());
+        return isFromSameNodeInMemberTable;
+    }
+    isVariableShadowingSomething(symbolName, nodeWhereUsed) {
+        let varData = {};
+        let exprType = nodeWhereUsed.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: varData });
+        if ((0, reflection_1.isReferenceType)(exprType)) {
+            exprType = exprType.getTarget();
+        }
+        const namespace = nodeWhereUsed === null || nodeWhereUsed === void 0 ? void 0 : nodeWhereUsed.findAncestor(reflection_1.isNamespaceStatement);
+        if ((0, reflection_1.isNamespaceStatement)(namespace)) {
+            let namespaceHasSymbol = namespace.getSymbolTable().hasSymbol(symbolName, 1 /* SymbolTypeFlag.runtime */);
+            // check if the namespace has a symbol with the same name, but different definiton
+            if (namespaceHasSymbol && !this.symbolComesFromSameNode(symbolName, varData.definingNode, namespace.getSymbolTable())) {
+                return true;
+            }
+        }
+        const bodyTable = nodeWhereUsed.getRoot().getSymbolTable();
+        const hasSymbolAtFileLevel = bodyTable.hasSymbol(symbolName, 1 /* SymbolTypeFlag.runtime */);
+        if (hasSymbolAtFileLevel && !this.symbolComesFromSameNode(symbolName, varData.definingNode, bodyTable)) {
+            return true;
+        }
+        return false;
+    }
+    chooseTypeFromCodeOrDocComment(codeType, docType, options) {
+        let returnType;
+        if (options.preferDocType && docType) {
+            returnType = docType;
+            if (options.data) {
+                options.data.isFromDocComment = true;
+            }
+        }
+        else {
+            returnType = codeType;
+            if (!returnType && docType) {
+                returnType = docType;
+                if (options.data) {
+                    options.data.isFromDocComment = true;
+                }
+            }
+        }
+        return returnType;
+    }
+    /**
+     * Gets the type for a default value (eg. as a function param, class member or typed array)
+     */
+    getDefaultTypeFromValueType(valueType) {
+        var _a;
+        if (!valueType) {
+            return undefined;
+        }
+        let resultType = DynamicType_1.DynamicType.instance;
+        if (Array.isArray(valueType)) {
+            // passed an array opf types, potential from ArrayType.innerTypes
+            if (valueType.length > 0) {
+                //at least one, use it
+                resultType = valueType[0];
+                if ((valueType === null || valueType === void 0 ? void 0 : valueType.length) > 1) {
+                    // more than 1, find union
+                    resultType = (0, helpers_1.getUniqueType)(valueType, UnionType_1.unionTypeFactory);
+                }
+            }
+        }
+        else {
+            resultType = valueType;
+        }
+        if (!resultType.isResolvable()) {
+            if ((0, reflection_1.isUnionType)(resultType)) {
+                resultType = DynamicType_1.DynamicType.instance;
+            }
+            else if ((0, reflection_1.isParamTypeFromValueReferenceType)(resultType)) {
+                //already wrapped — wrapping again would build a recursive proxy chain whose
+                //get handlers loop forever via Reflect.get
+            }
+            else {
+                resultType = new ReferenceType_1.ParamTypeFromValueReferenceType(resultType);
+            }
+        }
+        else if ((0, reflection_1.isEnumMemberType)(resultType)) {
+            // the type was an enum member... Try to get the parent enum type
+            resultType = (_a = resultType.parentEnumType) !== null && _a !== void 0 ? _a : resultType;
+        }
+        else if ((0, reflection_1.isUnionType)(resultType)) {
+            // it was a union -- I wonder if they're resolvable now?
+            const moddedTypes = resultType.types.map(t => {
+                var _a;
+                if ((0, reflection_1.isEnumMemberType)(t)) {
+                    // the type was an enum member... Try to get the parent enum type
+                    return (_a = t.parentEnumType) !== null && _a !== void 0 ? _a : resultType;
+                }
+                return t;
+            });
+            resultType = (0, helpers_1.getUniqueType)(moddedTypes, UnionType_1.unionTypeFactory);
+        }
+        return resultType;
+    }
+    /**
+     * Get the default type for an iterator of the given type
+     * Used for `for each` loops
+     */
+    getIteratorDefaultType(iteratorType) {
+        if ((0, reflection_1.isArrayType)(iteratorType)) {
+            return iteratorType.defaultType;
+        }
+        else if ((0, reflection_1.isAssociativeArrayTypeLike)(iteratorType)) {
+            return StringType_1.StringType.instance;
+        }
+        else if ((0, reflection_1.isBuiltInType)(iteratorType, 'roByteArray')) {
+            return IntegerType_1.IntegerType.instance;
+        }
+        else if ((0, reflection_1.isUnionType)(iteratorType)) {
+            const iteratorDefaultTypes = iteratorType.types.map(t => this.getIteratorDefaultType(t));
+            return (0, helpers_1.getUniqueType)(iteratorDefaultTypes, UnionType_1.unionTypeFactory);
+        }
+        return DynamicType_1.DynamicType.instance;
+    }
+    /**
+     * Get a short name that can be used to reference the project in logs. (typically something like `prj1`, `prj8`, etc...)
+     */
+    getProjectLogName(config) {
+        //if we have a project number, use it
+        if ((config === null || config === void 0 ? void 0 : config.projectNumber) !== undefined) {
+            return `prj${config.projectNumber}`;
+        }
+        //just return empty string so log functions don't crash with undefined project numbers
+        return '';
+    }
 }
 exports.Util = Util;
 /**
@@ -1220,7 +2787,7 @@ exports.Util = Util;
  */
 function standardizePath(stringParts, ...expressions) {
     let result = [];
-    for (let i = 0; i < stringParts.length; i++) {
+    for (let i = 0; i < (stringParts === null || stringParts === void 0 ? void 0 : stringParts.length); i++) {
         result.push(stringParts[i], expressions[i]);
     }
     return exports.util.standardizePath(result.join(''));