brighterscript 0.66.0-alpha.6 → 0.66.0-alpha.8

package/dist/util.d.ts

@@ -1,4 +1,4 @@
-import type { Diagnostic, Position, Range, Location } from 'vscode-languageserver';
+import { type Diagnostic, type Position, type Range, type Location } from 'vscode-languageserver';
 import type { BsConfig } from './BsConfig';
 import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPlugin, ExpressionInfo, TypeChainEntry, TypeChainProcessResult } from './interfaces';
 import { BooleanType } from './types/BooleanType';
@@ -21,6 +21,7 @@ import { type Expression, type Statement } from './parser/AstNode';
 import type { BscType } from './types/BscType';
 import { FunctionType } from './types/FunctionType';
 import type { SymbolTable } from './SymbolTable';
+import type { UnresolvedSymbol } from './AstValidationSegmenter';
 export declare class Util {
     clearConsole(): void;
     /**
@@ -49,6 +50,7 @@ export declare class Util {
     startsWithProtocol(path: string): boolean;
     /**
      * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
+     * @deprecated use `sanitizePkgPath instead. Will be removed in v1
      */
     getRokuPkgPath(pkgPath: string): string;
     /**
@@ -276,6 +278,11 @@ export declare class Util {
      * Helper for creating `Location` objects. Prefer using this function because vscode-languageserver's `Location.create()` is significantly slower at scale
      */
     createLocation(uri: string, range: Range): Location;
+    /**
+     * A cache of `Range` objects. The key is a 52bit integer created from the 4 range integers and leveraging bitshifting.
+     * The whole point of this cache is to reduce garbage collection churn, so we didn't want to use string concatenation for the key
+     */
+    private rangeCache;
     /**
      * Helper for creating `Range` objects. Prefer using this function because vscode-languageserver's `Range.create()` is significantly slower
      */
@@ -291,13 +298,15 @@ export declare class Util {
     createBoundingRange(...locatables: Array<{
         range?: Range;
     }>): Range;
+    /**
+     * A cache of `Position` objects. The key is a 26bit integer created from line and character and leveraging bitshifting
+     * The whole point of this cache is to reduce garbage collection churn, so we didn't want to use string concatenation for the key
+     */
+    private positionCache;
     /**
      * Create a `Position` object. Prefer this over `Position.create` for performance reasons
      */
-    createPosition(line: number, character: number): {
-        line: number;
-        character: number;
-    };
+    createPosition(line: number, character: number): Position;
     /**
      * Convert a list of tokens into a string, including their leading whitespace
      */
@@ -325,6 +334,7 @@ export declare class Util {
     /**
      * 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: string): string;
     /**
@@ -346,10 +356,6 @@ export declare class Util {
      * Converts a path into a standardized format (drive letter to lower, remove extra slashes, use single slash type, resolve relative parts, etc...)
      */
     standardizePath(thePath: string): string;
-    /**
-     * Copy the version of bslib from local node_modules to the staging folder
-     */
-    copyBslibToStaging(stagingDir: string): Promise<void>;
     /**
      * Given a Diagnostic or BsDiagnostic, return a deep clone of the diagnostic.
      * @param diagnostic the diagnostic to clone
@@ -422,6 +428,16 @@ export declare class Util {
      */
     findLastIndex<T>(array: T[], matcher: (T: any) => boolean): number;
     processTypeChain(typeChain: TypeChainEntry[]): TypeChainProcessResult;
+    isInTypeExpression(expression: AstNode): boolean;
+    setContainsUnresolvedSymbol(symbolLowerNameSet: Set<string>, symbol: UnresolvedSymbol): boolean;
+    truncate<T>(options: {
+        leadingText: string;
+        items: T[];
+        trailingText?: string;
+        maxLength: number;
+        itemSeparator?: string;
+        partBuilder?: (item: T) => string;
+    }): string;
 }
 /**
  * A tagged template literal function for standardizing the path. This has to be defined as standalone function since it's a tagged template literal function,

package/dist/util.js

@@ -28,11 +28,25 @@ const requireRelative = require("require-relative");
 const AstNode_1 = require("./parser/AstNode");
 const creators_1 = require("./astUtils/creators");
 const FunctionType_1 = require("./types/FunctionType");
-const types_1 = require("./types");
+const ArrayType_1 = require("./types/ArrayType");
 const SymbolTable_1 = require("./SymbolTable");
 const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
 const ComponentType_1 = require("./types/ComponentType");
+const diagnosticUtils_1 = require("./diagnosticUtils");
+const ReferenceType_1 = require("./types/ReferenceType");
 class Util {
+    constructor() {
+        /**
+         * A cache of `Range` objects. The key is a 52bit integer created from the 4 range integers and leveraging bitshifting.
+         * The whole point of this cache is to reduce garbage collection churn, so we didn't want to use string concatenation for the key
+         */
+        this.rangeCache = new Map();
+        /**
+         * A cache of `Position` objects. The key is a 26bit integer created from line and character and leveraging bitshifting
+         * The whole point of this cache is to reduce garbage collection churn, so we didn't want to use string concatenation for the key
+         */
+        this.positionCache = new Map();
+    }
     clearConsole() {
         // process.stdout.write('\x1Bc');
     }
@@ -79,12 +93,10 @@ class Util {
      * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
      */
     sanitizePkgPath(pkgPath) {
-        pkgPath = pkgPath.replace(/\\/g, '/');
-        //if there's no protocol, assume it's supposed to start with `pkg:/`
-        if (!this.startsWithProtocol(pkgPath)) {
-            pkgPath = 'pkg:/' + pkgPath;
-        }
-        return pkgPath;
+        //convert all slashes to forwardslash
+        pkgPath = pkgPath.replace(/[\/\\]+/g, '/');
+        //ensure every path has the leading pkg:/
+        return 'pkg:/' + pkgPath.replace(/^pkg:\//i, '');
     }
     /**
      * Determine if the given path starts with a protocol
@@ -94,10 +106,10 @@ class Util {
     }
     /**
      * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
+     * @deprecated use `sanitizePkgPath instead. Will be removed in v1
      */
     getRokuPkgPath(pkgPath) {
-        pkgPath = pkgPath.replace(/\\/g, '/');
-        return 'pkg:/' + pkgPath;
+        return this.sanitizePkgPath(pkgPath);
     }
     /**
      * Given a path to a file/directory, replace all path separators with the current system's version.
@@ -273,6 +285,9 @@ class Util {
      */
     normalizeAndResolveConfig(config) {
         let result = this.normalizeConfig({});
+        if (config === null || config === void 0 ? void 0 : config.noProject) {
+            return result;
+        }
         //if no options were provided, try to find a bsconfig.json file
         if (!config || !config.project) {
             result.project = this.getConfigFilePath(config === null || config === void 0 ? void 0 : config.cwd);
@@ -294,7 +309,7 @@ class Util {
      * @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, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         config = config || {};
         config.cwd = (_a = config.cwd) !== null && _a !== void 0 ? _a : process.cwd();
         config.deploy = config.deploy === true ? true : false;
@@ -323,6 +338,11 @@ class Util {
             config.logLevel = Logger_1.LogLevel[config.logLevel.toLowerCase()];
         }
         config.logLevel = (_k = config.logLevel) !== null && _k !== void 0 ? _k : Logger_1.LogLevel.log;
+        config.bslibDestinationDir = (_l = config.bslibDestinationDir) !== null && _l !== void 0 ? _l : 'source';
+        if (config.bslibDestinationDir !== 'source') {
+            // strip leading and trailing slashes
+            config.bslibDestinationDir = config.bslibDestinationDir.replace(/^(\/*)(.*?)(\/*)$/, '$2');
+        }
         return config;
     }
     /**
@@ -730,6 +750,7 @@ class Util {
                 }
             }
         }
+        return false;
     }
     /**
      * Walks up the chain to find the closest bsconfig.json file
@@ -910,31 +931,23 @@ class Util {
      * Helper for creating `Range` objects. Prefer using this function because vscode-languageserver's `Range.create()` is significantly slower
      */
     createRange(startLine, startCharacter, endLine, endCharacter) {
-        return {
-            start: {
-                line: startLine,
-                character: startCharacter
-            },
-            end: {
-                line: endLine,
-                character: endCharacter
-            }
-        };
+        // eslint-disable-next-line no-bitwise
+        const key = (startLine << 39) + (startCharacter << 26) + (endLine << 13) + endCharacter;
+        let range = this.rangeCache.get(key);
+        if (!range) {
+            range = {
+                start: this.createPosition(startLine, startCharacter),
+                end: this.createPosition(endLine, endCharacter)
+            };
+            this.rangeCache.set(key, range);
+        }
+        return range;
     }
     /**
      * Create a `Range` from two `Position`s
      */
     createRangeFromPositions(startPosition, endPosition) {
-        return {
-            start: {
-                line: startPosition.line,
-                character: startPosition.character
-            },
-            end: {
-                line: endPosition.line,
-                character: endPosition.character
-            }
-        };
+        return this.createRange(startPosition.line, startPosition.character, endPosition.line, endPosition.character);
     }
     /**
      * Given a list of ranges, create a range that starts with the first non-null lefthand range, and ends with the first non-null
@@ -974,10 +987,17 @@ class Util {
      * Create a `Position` object. Prefer this over `Position.create` for performance reasons
      */
     createPosition(line, character) {
-        return {
-            line: line,
-            character: character
-        };
+        // eslint-disable-next-line no-bitwise
+        const key = (line << 13) + character;
+        let position = this.positionCache.get(key);
+        if (!position) {
+            position = {
+                line: line,
+                character: character
+            };
+            this.positionCache.set(key, position);
+        }
+        return position;
     }
     /**
      * Convert a list of tokens into a string, including their leading whitespace
@@ -1084,7 +1104,7 @@ class Util {
                 arrayOfTypeName = arrayOfTypeName.substring(0, arrayOfTypeName.length - 1);
             }
             let arrayType = this.getNodeFieldType(arrayOfTypeName, lookupTable);
-            return new types_1.ArrayType(arrayType);
+            return new ArrayType_1.ArrayType(arrayType);
         }
         else if (typeDescriptorLower.startsWith('option ')) {
             const actualTypeName = typeDescriptorLower.substring('option '.length); //cut off beginning 'option '
@@ -1098,16 +1118,16 @@ class Util {
             return StringType_1.StringType.instance;
         }
         else if (typeDescriptorLower === 'vector2d' || typeDescriptorLower === 'floatarray') {
-            return new types_1.ArrayType(FloatType_1.FloatType.instance);
+            return new ArrayType_1.ArrayType(FloatType_1.FloatType.instance);
         }
         else if (typeDescriptorLower === 'intarray') {
-            return new types_1.ArrayType(IntegerType_1.IntegerType.instance);
+            return new ArrayType_1.ArrayType(IntegerType_1.IntegerType.instance);
         }
         else if (typeDescriptorLower === 'boolarray') {
-            return new types_1.ArrayType(BooleanType_1.BooleanType.instance);
+            return new ArrayType_1.ArrayType(BooleanType_1.BooleanType.instance);
         }
         else if (typeDescriptorLower === 'stringarray' || typeDescriptorLower === 'strarray') {
-            return new types_1.ArrayType(StringType_1.StringType.instance);
+            return new ArrayType_1.ArrayType(StringType_1.StringType.instance);
         }
         else if (typeDescriptorLower === 'int') {
             return IntegerType_1.IntegerType.instance;
@@ -1128,7 +1148,7 @@ class Util {
             return ComponentType_1.ComponentType.instance;
         }
         else if (typeDescriptorLower === 'nodearray') {
-            return new types_1.ArrayType(ComponentType_1.ComponentType.instance);
+            return new ArrayType_1.ArrayType(ComponentType_1.ComponentType.instance);
         }
         else if (lookupTable) {
             //try doing a lookup
@@ -1144,7 +1164,7 @@ class Util {
     binaryOperatorResultType(leftType, operator, rightType) {
         if (((0, reflection_1.isAnyReferenceType)(leftType) && !leftType.isResolvable()) ||
             ((0, reflection_1.isAnyReferenceType)(rightType) && !rightType.isResolvable())) {
-            return new types_1.BinaryOperatorReferenceType(leftType, operator, rightType, (lhs, op, rhs) => {
+            return new ReferenceType_1.BinaryOperatorReferenceType(leftType, operator, rightType, (lhs, op, rhs) => {
                 return this.binaryOperatorResultType(lhs, op, rhs);
             });
         }
@@ -1298,6 +1318,7 @@ class Util {
     /**
      * 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();
@@ -1305,10 +1326,7 @@ class Util {
             return '.d.bs';
         }
         else {
-            const idx = filePath.lastIndexOf('.');
-            if (idx > -1) {
-                return filePath.substring(idx);
-            }
+            return path.extname(filePath).toLowerCase();
         }
     }
     /**
@@ -1398,29 +1416,6 @@ class Util {
     standardizePath(thePath) {
         return exports.util.driveLetterToLower((0, roku_deploy_1.standardizePath)(thePath));
     }
-    /**
-     * Copy the version of bslib from local node_modules to the staging folder
-     */
-    async copyBslibToStaging(stagingDir) {
-        //copy bslib to the output directory
-        await fsExtra.ensureDir(standardizePath(`${stagingDir}/source`));
-        // eslint-disable-next-line
-        const bslib = require('@rokucommunity/bslib');
-        let source = bslib.source;
-        //apply the `bslib_` prefix to the functions
-        let match;
-        const positions = [];
-        const regexp = /^(\s*(?:function|sub)\s+)([a-z0-9_]+)/mg;
-        // eslint-disable-next-line no-cond-assign
-        while (match = regexp.exec(source)) {
-            positions.push(match.index + match[1].length);
-        }
-        for (let i = positions.length - 1; i >= 0; i--) {
-            const position = positions[i];
-            source = source.slice(0, position) + 'bslib_' + source.slice(position);
-        }
-        await fsExtra.writeFile(`${stagingDir}/source/bslib.brs`, source);
-    }
     /**
      * Given a Diagnostic or BsDiagnostic, return a deep clone of the diagnostic.
      * @param diagnostic the diagnostic to clone
@@ -1428,11 +1423,20 @@ class Util {
      */
     toDiagnostic(diagnostic, relatedInformationFallbackLocation) {
         var _a;
+        let relatedInformation = (_a = diagnostic.relatedInformation) !== null && _a !== void 0 ? _a : [];
+        if (relatedInformation.length > diagnosticUtils_1.MAX_RELATED_INFOS_COUNT) {
+            const relatedInfoLength = relatedInformation.length;
+            relatedInformation = relatedInformation.slice(0, diagnosticUtils_1.MAX_RELATED_INFOS_COUNT);
+            relatedInformation.push({
+                message: `...and ${relatedInfoLength - diagnosticUtils_1.MAX_RELATED_INFOS_COUNT} more`,
+                location: exports.util.createLocation('   ', exports.util.createRange(0, 0, 0, 0))
+            });
+        }
         return {
             severity: diagnostic.severity,
             range: diagnostic.range,
             message: diagnostic.message,
-            relatedInformation: (_a = diagnostic.relatedInformation) === null || _a === void 0 ? void 0 : _a.map(x => {
+            relatedInformation: relatedInformation.map(x => {
                 //clone related information just in case a plugin added circular ref info here
                 const clone = Object.assign({}, x);
                 if (!clone.location) {
@@ -1681,15 +1685,15 @@ class Util {
     validateTooDeepFile(file) {
         var _a;
         //find any files nested too deep
-        let pkgPath = (_a = file.pkgPath) !== null && _a !== void 0 ? _a : file.pkgPath.toString();
-        let rootFolder = pkgPath.replace(/^pkg:/, '').split(/[\\\/]/)[0].toLowerCase();
+        let destPath = (_a = file === null || file === void 0 ? void 0 : file.destPath) === null || _a === void 0 ? void 0 : _a.toString();
+        let rootFolder = destPath === null || destPath === void 0 ? void 0 : destPath.replace(/^pkg:/, '').split(/[\\\/]/)[0].toLowerCase();
         if ((0, reflection_1.isBrsFile)(file) && rootFolder !== 'source') {
             return;
         }
         if ((0, reflection_1.isXmlFile)(file) && rootFolder !== 'components') {
             return;
         }
-        let fileDepth = this.getParentDirectoryCount(pkgPath);
+        let fileDepth = this.getParentDirectoryCount(destPath);
         if (fileDepth >= 8) {
             file.addDiagnostics([Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.detectedTooDeepFileSource(fileDepth)), { file: file, range: this.createRange(0, 0, 0, Number.MAX_VALUE) })]);
         }
@@ -1739,6 +1743,95 @@ class Util {
             containsDynamic: containsDynamic
         };
     }
+    isInTypeExpression(expression) {
+        //TODO: this is much faster than node.findAncestor(), but may need to be updated for "complicated" type expressions
+        if ((0, reflection_1.isTypeExpression)(expression) ||
+            (0, reflection_1.isTypeExpression)(expression.parent) ||
+            (0, reflection_1.isTypedArrayExpression)(expression) ||
+            (0, reflection_1.isTypedArrayExpression)(expression.parent)) {
+            return true;
+        }
+        if ((0, reflection_1.isBinaryExpression)(expression.parent)) {
+            let currentExpr = expression.parent;
+            while ((0, reflection_1.isBinaryExpression)(currentExpr) && currentExpr.operator.kind === TokenKind_1.TokenKind.Or) {
+                currentExpr = currentExpr.parent;
+            }
+            return (0, reflection_1.isTypeExpression)(currentExpr) || (0, reflection_1.isTypedArrayExpression)(currentExpr);
+        }
+        return false;
+    }
+    setContainsUnresolvedSymbol(symbolLowerNameSet, symbol) {
+        var _a, _b;
+        const possibleOriginalSymbolNamesLower = [];
+        let nameSoFar = '';
+        for (const tce of symbol.typeChain) {
+            if (nameSoFar.length > 0) {
+                nameSoFar += '.';
+            }
+            nameSoFar += tce.name.toLowerCase();
+            possibleOriginalSymbolNamesLower.push(nameSoFar);
+        }
+        const possibleNamespace = (_b = (_a = symbol.containingNamespaces) === null || _a === void 0 ? void 0 : _a.join('.')) !== null && _b !== void 0 ? _b : '';
+        for (const possibleNameLower of possibleOriginalSymbolNamesLower) {
+            if (symbolLowerNameSet.has(possibleNameLower)) {
+                return true;
+            }
+            if (possibleNamespace) {
+                const fullName = possibleNamespace + '.' + possibleNameLower;
+                if (symbolLowerNameSet.has(fullName.toLowerCase())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    truncate(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        let leadingText = options.leadingText;
+        let items = (_a = options === null || options === void 0 ? void 0 : options.items) !== null && _a !== void 0 ? _a : [];
+        let trailingText = (_b = options === null || options === void 0 ? void 0 : options.trailingText) !== null && _b !== void 0 ? _b : '';
+        let maxLength = (_c = options === null || options === void 0 ? void 0 : options.maxLength) !== null && _c !== void 0 ? _c : 160;
+        let itemSeparator = (_d = options === null || options === void 0 ? void 0 : options.itemSeparator) !== null && _d !== void 0 ? _d : ', ';
+        let partBuilder = (_e = options === null || options === void 0 ? void 0 : options.partBuilder) !== null && _e !== void 0 ? _e : ((x) => x.toString());
+        let parts = [];
+        let length = leadingText.length + ((_f = trailingText === null || trailingText === void 0 ? void 0 : trailingText.length) !== null && _f !== void 0 ? _f : 0);
+        //calculate the max number of items we could fit in the given space
+        for (let i = 0; i < items.length; i++) {
+            let part = partBuilder(items[i]);
+            if (i > 0) {
+                part = itemSeparator + part;
+            }
+            parts.push(part);
+            length += part.length;
+            //exit the loop if we've maxed out our length
+            if (length >= maxLength) {
+                break;
+            }
+        }
+        let message;
+        //we have enough space to include all the parts
+        if (parts.length >= items.length) {
+            message = leadingText + parts.join('') + trailingText;
+            //we require truncation
+        }
+        else {
+            //account for truncation message length including max possible "more" items digits, trailing text length, and the separator between last item and trailing text
+            length = leadingText.length + `...and ${items.length} more`.length + itemSeparator.length + ((_g = trailingText === null || trailingText === void 0 ? void 0 : trailingText.length) !== null && _g !== void 0 ? _g : 0);
+            message = leadingText;
+            for (let i = 0; i < parts.length; i++) {
+                //always include at least 2 items. if this part would overflow the max, then skip it and finalize the message
+                if (i > 1 && length + parts[i].length > maxLength) {
+                    message += itemSeparator + `...and ${items.length - i} more` + trailingText;
+                    return message;
+                }
+                else {
+                    message += parts[i];
+                    length += parts[i].length;
+                }
+            }
+        }
+        return message;
+    }
 }
 exports.Util = Util;
 /**