brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/util.d.ts

@@ -1,33 +1,52 @@
-import * as rokuDeploy from 'roku-deploy';
-import type { Diagnostic, Position, Range } from 'vscode-languageserver';
-import type { BsConfig } from './BsConfig';
-import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPlugin, ExpressionInfo, FunctionCall, CallableParam, TranspileResult } from './interfaces';
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Diagnostic, Position } from 'vscode-languageserver';
+import { Range, Location } from 'vscode-languageserver';
+import type { BsConfig, FinalizedBsConfig } from './BsConfig';
+import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, Plugin, ExpressionInfo, TranspileResult, MaybePromise, DisposableLike, GetTypeOptions, TypeChainProcessResult, TypeCircularReferenceInfo } from './interfaces';
+import { TypeChainEntry } from './interfaces';
 import { BooleanType } from './types/BooleanType';
 import { DoubleType } from './types/DoubleType';
 import { DynamicType } from './types/DynamicType';
 import { FloatType } from './types/FloatType';
-import { FunctionType } from './types/FunctionType';
 import { IntegerType } from './types/IntegerType';
-import { InvalidType } from './types/InvalidType';
 import { LongIntegerType } from './types/LongIntegerType';
 import { ObjectType } from './types/ObjectType';
 import { StringType } from './types/StringType';
 import { VoidType } from './types/VoidType';
-import type { DottedGetExpression, Expression, VariableExpression } from './parser/Expression';
-import type { Locatable, Token } from './lexer';
-import { CustomType } from './types/CustomType';
+import { ParseMode } from './parser/Parser';
+import type { CallExpression, CallfuncExpression, DottedGetExpression, VariableExpression } from './parser/Expression';
+import { type Identifier, type Token } from './lexer/Token';
 import { SourceNode } from 'source-map';
-import { SGAttribute } from './parser/SGTypes';
+import type { BrsFile } from './files/BrsFile';
+import type { XmlFile } from './files/XmlFile';
+import type { AstNode, Expression, Statement } from './parser/AstNode';
+import type { UnresolvedSymbol } from './AstValidationSegmenter';
+import type { GetSymbolTypeOptions, SymbolTable } from './SymbolTable';
+import { SymbolTypeFlag } from './SymbolTypeFlag';
+import type { BscType } from './types/BscType';
+import { UnionType } from './types/UnionType';
+import { FunctionType } from './types/FunctionType';
+import type { NamespaceStatement } from './parser/Statement';
+import type { BscFile } from './files/BscFile';
+import { InvalidType } from './types/InvalidType';
+import { IntersectionType } from './types/IntersectionType';
 export declare class Util {
     clearConsole(): void;
+    /**
+     * Get the version of brighterscript
+     */
+    getBrighterScriptVersion(): any;
+    /**
+     * Returns the number of parent directories in the filPath
+     */
+    getParentDirectoryCount(filePath: string | undefined): number;
     /**
      * Determine if the file exists
-     * @param filePath
      */
     pathExists(filePath: string | undefined): Promise<boolean>;
     /**
      * Determine if the file exists
-     * @param filePath
      */
     pathExistsSync(filePath: string | undefined): boolean;
     /**
@@ -35,170 +54,157 @@ export declare class Util {
      */
     isDirectorySync(dirPath: string | undefined): boolean;
     /**
-     * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
-     */
-    sanitizePkgPath(pkgPath: string): string;
-    /**
-     * 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: string): boolean;
+    readFileSync(filePath: string): Buffer | 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: string, separator?: string): string;
+    sanitizePkgPath(pkgPath: string): string;
     /**
      * 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?: string): string;
     getRangeFromOffsetLength(text: string, offset: number, length: number): Range;
     /**
      * 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: string, parentProjectPaths?: string[], cwd?: string): BsConfig;
+    loadConfigFile(configFilePath: string | undefined, parentProjectPaths?: string[], cwd?: string): BsConfig | undefined;
     /**
-     * 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: BsConfig, configFilePath: string): void;
-    /**
-     * Do work within the scope of a changed current working directory
-     * @param targetCwd
-     * @param callback
-     */
-    cwdWork<T>(targetCwd: string | null | undefined, callback: () => T): T;
+    resolvePathsRelativeTo(collection: any, key: string, relativeDir: string): void;
     /**
      * 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: BsConfig): BsConfig;
+    normalizeAndResolveConfig(config: BsConfig | undefined): FinalizedBsConfig;
     /**
      * Set defaults for any missing items
-     * @param config
+     * @param config a bsconfig object to use as the baseline for the resulting config
      */
-    normalizeConfig(config: BsConfig): BsConfig;
+    normalizeConfig(config: BsConfig | undefined): FinalizedBsConfig;
     /**
      * 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: BsConfig): string;
-    /**
-     * Format a string with placeholders replaced by argument indexes
-     * @param subject
-     * @param params
-     */
-    stringFormat(subject: string, ...args: any[]): string;
     /**
      * Given a list of callables as a dictionary indexed by their full name (namespace included, transpiled to underscore-separated.
-     * @param callables
      */
     getCallableContainersByLowerName(callables: CallableContainer[]): CallableContainerMap;
     /**
-     * Split a file by newline characters (LF or CRLF)
-     * @param text
-     */
-    getLines(text: string): string[];
-    /**
-     * Compute the pkg path for the target relative to the source file's location
-     * @param sourcePkgPath The pkgPath of the file that contains the target path
-     * @param targetPath a full pkgPath, or a path relative to the containing file
+     * Given an absolute path to a source file, and a target path,
+     * compute the pkg path for the target relative to the source file's location
      */
-    getPkgPathFromTarget(sourcePkgPath: string, targetPath: string): string;
+    getPkgPathFromTarget(containingFilePathAbsolute: string, targetPath: string): string;
     /**
      * 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: string, pkgTargetPathAbsolute: string): string;
+    getRelativePath(pkgSrcPath: string, pkgTargetPath: string): string;
+    getImportPackagePath(srcPath: string, pkgTargetPath: string): string;
     /**
      * Walks left in a DottedGetExpression and returns a VariableExpression if found, or undefined if not found
      */
     findBeginningVariableExpression(dottedGet: DottedGetExpression): VariableExpression | undefined;
     /**
-     * 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: Range | undefined, b: Range | undefined): boolean;
+    /**
+     * 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     |
+     * ```
      */
-    rangesIntersect(a: Range, b: Range): boolean;
+    rangesIntersectOrTouch(a: Range | undefined, b: Range | undefined): boolean;
     /**
      * 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: Range, position: Position): boolean;
-    comparePositionToRange(position: Position, range: Range): 1 | -1 | 0;
+    rangeContains(range: Range | undefined, position: Position | undefined): boolean;
+    comparePositionToRange(position: Position | undefined, range: Range | undefined): 1 | -1 | 0;
+    comparePosition(a: Position | undefined, b: Position): 1 | -1 | 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: string): Promise<any>;
-    propertyCount(object: Record<string, unknown>): number;
-    padLeft(subject: string, totalLength: number, char: string): string;
+    isRangeInRange(inner: Range, outer: Range): boolean;
     /**
-     * Given a URI, convert that to a regular fs path
-     * @param uri
+     * 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
      */
-    uriToPath(uri: string): string;
+    getNodeDocumentation(node: AstNode, options?: {
+        prettyPrint?: boolean;
+        commentTokens?: Token[];
+    }): string;
+    /**
+     * Prefixes a component name so it can be used as type in the symbol table, without polluting available symbols
+     *
+     * @param sgNodeName the Name of the component
+     * @returns the node name, prefixed with `roSGNode`
+     */
+    getSgNodeTypeName(sgNodeName: string): string;
     /**
      * Force the drive letter to lower case
-     * @param fullPath
      */
     driveLetterToLower(fullPath: string): string;
     /**
-     * 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`
+     */
+    replaceCaseInsensitive(subject: string, search: string, replacement: string): string;
+    /**
+     * Does the string appear to be a uri (i.e. does it start with `file:`)
      */
-    areArraysEqual(arr1: any[], arr2: any[]): boolean;
+    isUriLike(filePath: string): boolean;
     /**
      * Given a file path, convert it to a URI string
-     * @param srcPath The absolute path to the source file on disk
      */
-    pathToUri(srcPath: string): string;
+    pathToUri(filePath: string): string;
     /**
-     * Get the outDir from options, taking into account cwd and absolute outFile paths
-     * @param options
+     * Given a URI, convert that to a regular fs path
      */
-    getOutDir(options: BsConfig): string;
+    uriToPath(uri: string): string;
     /**
      * Get paths to all files on disc that match this project's source list
      */
-    getFilePaths(options: BsConfig): Promise<rokuDeploy.StandardizedFileEntry[]>;
+    getFilePaths(options: FinalizedBsConfig): Promise<import("roku-deploy").StandardizedFileEntry[]>;
     /**
      * 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: string): string;
-    /**
-     * Determine whether this diagnostic should be supressed or not, based on brs comment-flags
-     * @param diagnostic
-     */
-    diagnosticIsSuppressed(diagnostic: BsDiagnostic): boolean;
-    /**
-     * Walks up the chain
-     * @param currentPath
-     */
-    findClosestConfigFile(currentPath: string): Promise<string>;
     /**
      * 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: number): Promise<unknown>;
-    /**
-     * Given an array, map and then flatten
-     * @param arr
-     * @param cb
-     */
-    flatMap<T, R>(array: T[], cb: (arg: T) => R): R;
     /**
      * 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
@@ -207,40 +213,17 @@ export declare class Util {
      */
     positionIsGreaterThanRange(position: Position, range: Range): boolean;
     /**
-     * Get a location object back by extracting location information from other objects that contain location
-     */
-    getRange(startObj: {
-        range: Range;
-    }, endObj: {
-        range: Range;
-    }): Range;
-    /**
-     * 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: {
-        range: Range;
-    }, second: {
-        range: Range;
-    }): boolean;
+    extractRange(rangeIsh: RangeLike): Range | undefined;
     /**
      * If the two items have lines that touch
-     * @param first
-     * @param second
      */
-    linesTouch(first: {
-        range: Range;
-    }, second: {
-        range: Range;
-    }): boolean;
-    /**
-     * 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: string): string;
+    linesTouch(first: RangeLike, second: RangeLike): boolean;
     /**
      * Find a script import that the current position touches, or undefined if not found
      */
-    getScriptImportAtPosition(scriptImports: FileReference[], position: Position): FileReference;
+    getScriptImportAtPosition(scriptImports: FileReference[], position: Position): FileReference | undefined;
     /**
      * Given the class name text, return a namespace-prefixed name.
      * If the name already has a period in it, or the namespaceName was not provided, return the class name as is.
@@ -251,117 +234,235 @@ export declare class Util {
     splitIntoLines(string: string): string[];
     getTextForRange(string: string | string[], range: Range): string;
     /**
-     * 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: string, range: Range): Location;
+    /**
+     * Helper for creating `Location` objects from a file and range
+     */
+    createLocationFromFileRange(file: BscFile, range: Range): Location;
+    /**
+     * 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: number, startCharacter: number, endLine: number, endCharacter: number, uri?: string): Location;
+    /**
+     * Helper for creating `Range` objects. Prefer using this function because vscode-languageserver's `Range.create()` is significantly slower.
      */
     createRange(startLine: number, startCharacter: number, endLine: number, endCharacter: number): Range;
     /**
      * Create a `Range` from two `Position`s
      */
-    createRangeFromPositions(startPosition: Position, endPosition: Position): Range;
+    createRangeFromPositions(startPosition: Position, endPosition: Position): Range | undefined;
     /**
-     * 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: Array<{
+    cloneLocation(location: Location): Location;
+    /**
+     * Clone every token
+     */
+    cloneToken<T extends Token>(token: T): T;
+    /**
+     *  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
+     */
+    createBoundingLocation(...locatables: Array<{
+        location?: Location;
+    } | Location | {
         range?: Range;
-    }>): Range;
+    } | Range | undefined>): Location | 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: Array<RangeLike>): Range | undefined;
+    /**
+     * Gets the bounding range of an object that contains a bunch of tokens
+     * @param tokens Object with tokens in it
+     * @returns Range containing all the tokens
+     */
+    createBoundingLocationFromTokens(tokens: Record<string, {
+        location?: Location;
+    }>): Location | undefined;
     /**
-     * Create a `Position` object. Prefer this over `Position.create` for performance reasons
+     * Create a `Position` object. Prefer this over `Position.create` for performance reasons.
      */
     createPosition(line: number, character: number): {
         line: number;
         character: number;
     };
     /**
-     * Convert a list of tokens into a string, including their leading whitespace
+     * Convert a token into a BscType
      */
-    tokensToString(tokens: Token[]): string;
+    tokenToBscType(token: Token): DynamicType | ObjectType | VoidType | InvalidType | BooleanType | DoubleType | FloatType | FunctionType | IntegerType | LongIntegerType | StringType;
     /**
-     * Convert a token into a BscType
+     * 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: string, lookupTable?: SymbolTable): BscType;
+    /**
+     * Return the type of the result of a binary operator
+     * Note: compound assignments (eg. +=) internally use a binary expression, so that's why TokenKind.PlusEqual, etc. are here too
+     */
+    binaryOperatorResultType(leftType: BscType, operator: Token, rightType: BscType): BscType;
+    getHighestPriorityType(types: BscType[], depth?: number): BscType;
+    /**
+     * Return the type of the result of a unary operator
      */
-    tokenToBscType(token: Token, allowCustomType?: boolean): DynamicType | ObjectType | CustomType | BooleanType | DoubleType | FloatType | FunctionType | IntegerType | InvalidType | LongIntegerType | StringType | VoidType;
+    unaryOperatorResultType(operator: Token, exprType: BscType): BscType;
+    getUnboxedType(boxedType: BscType): BscType;
     /**
      * Get the extension for the given file path. Basically the part after the final dot, except for
      * `d.bs` which is treated as single extension
+     * @returns the file extension (i.e. ".d.bs", ".bs", ".brs", ".xml", ".jpg", etc...)
      */
     getExtension(filePath: string): string;
     /**
      * Load and return the list of plugins
      */
-    loadPlugins(cwd: string, pathOrModules: string[], onError?: (pathOrModule: string, err: Error) => void): CompilerPlugin[];
-    resolveRequire(cwd: string, pathOrModule: string): any;
+    loadPlugins(cwd: string, pathOrModules: string[], onError?: (pathOrModule: string, err: Error) => void): Plugin[];
     /**
      * Gathers expressions, variables, and unique names from an expression.
      * This is mostly used for the ternary expression
      */
-    getExpressionInfo(expression: Expression): ExpressionInfo;
+    getExpressionInfo(expression: Expression, file: BrsFile): ExpressionInfo;
+    concatAnnotationLeadingTrivia(stmt: Statement): Token[];
     /**
      * Create a SourceNode that maps every line to itself. Useful for creating maps for files
      * that haven't changed at all, but we still need the map
      */
     simpleMap(source: string, src: string): SourceNode;
+    private isWindows;
+    private standardizePathCache;
     /**
-     * Creates a new SGAttribute object, but keeps the existing Range references (since those should be immutable)
+     * Converts a path into a standardized format (drive letter to lower, remove extra slashes, use single slash type, resolve relative parts, etc...)
      */
-    cloneSGAttribute(attr: SGAttribute, value: string): SGAttribute;
+    standardizePath(thePath: string): string;
     /**
-     * Shorthand for creating a new source node
+     * 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
      */
-    sourceNode(source: string, locatable: {
-        range: Range;
-    }, code: string | SourceNode | TranspileResult): SourceNode | undefined;
+    toDiagnostic(diagnostic: Diagnostic | BsDiagnostic, relatedInformationFallbackLocation: string): Diagnostic;
     /**
-     * Remove leading simple protocols from a path (if present)
+     * Sort an array of objects that have a Range
      */
-    removeProtocol(pkgPath: string): string;
-    standardizePath(thePath: string): string;
-    copyBslibToStaging(stagingDir: string): Promise<void>;
-    /**
-     * Given a Diagnostic or BsDiagnostic, return a copy of the diagnostic
-     */
-    toDiagnostic(diagnostic: Diagnostic | BsDiagnostic): {
-        severity: import("vscode-languageserver-types").DiagnosticSeverity;
-        range: Range;
-        message: string;
-        relatedInformation: {
-            location: import("vscode-languageserver-types").Location;
-            message: string;
-        }[];
-        code: string | number;
-        source: string;
-    };
+    sortByRange<T extends {
+        range: Range | undefined;
+    }>(locatables: T[]): T[];
     /**
-     * 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
+     * Wrap the given code in a markdown code fence (with the language)
      */
-    getMinMaxParamCount(params: CallableParam[]): {
-        min: number;
-        max: number;
-    };
+    mdFence(code: string, language?: string): string;
     /**
-     * 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
+     * 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
      */
-    getCallableContainersFromContainerMapByFunctionCall(callablesByLowerName: CallableContainerMap, expCall: FunctionCall): CallableContainer[];
+    getAllDottedGetParts(node: AstNode): Identifier[] | undefined;
     /**
-     * Sort an array of objects that have a Range
+     * Given an expression, return all the DottedGet name parts as a string.
+     * Mostly used to convert namespaced item full names to a strings
+     */
+    getAllDottedGetPartsAsString(node: Expression | Statement, parseMode?: ParseMode, lastSep?: string): string;
+    /**
+     * Break an expression into each part.
+     */
+    splitExpression(expression: Expression): Expression[];
+    /**
+     * Returns an integer if valid, or undefined. Eliminates checking for NaN
+     */
+    parseInt(value: any): number;
+    /**
+     * Converts a range to a string in the format 1:2-3:4
+     */
+    rangeToString(range: Range): string;
+    validateTooDeepFile(file: (BrsFile | XmlFile)): void;
+    /**
+     * Execute dispose for a series of disposable items
+     * @param disposables a list of functions or disposables
+     */
+    applyDispose(disposables: DisposableLike[]): void;
+    /**
+     * 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
      */
-    sortByRange(locatables: Locatable[]): Locatable[];
+    promiseRaceMatch<T>(promises: MaybePromise<T>[], matcher: (value: T) => boolean): Promise<T>;
     /**
-     * Split the given text and return ranges for each chunk.
-     * Only works for single-line strings
+     * Wraps SourceNode's constructor to be compatible with the TranspileResult type
      */
-    splitGetRange(separator: string, text: string, range: Range): {
-        text: string;
-        range: Range;
-    }[];
+    sourceNodeFromTranspileResult(line: number | null, column: number | null, source: string | null, chunks?: string | SourceNode | TranspileResult, name?: string): SourceNode;
+    /**
+     * Find the index of the last item in the array that matches.
+     */
+    findLastIndex<T>(array: T[], matcher: (T: any) => boolean): number;
+    processTypeChain(typeChain: TypeChainEntry[]): TypeChainProcessResult;
+    getCircularReferenceDiagnosticDetail(circularReferenceInfo: TypeCircularReferenceInfo, defaultName?: string): string[];
+    isInTypeExpression(expression: AstNode): boolean;
+    isGenericNodeType(type: BscType): boolean;
+    hasAnyRequiredSymbolChanged(requiredSymbols: UnresolvedSymbol[], changedSymbols: Map<SymbolTypeFlag, Set<string>>): boolean;
+    setContainsUnresolvedSymbol(symbolLowerNameSet: Set<string>, symbol: UnresolvedSymbol): boolean;
+    getCustomTypesInSymbolTree(setToFill: Set<BscType>, type: BscType, filter?: (t: BscType) => boolean): void;
+    truncate<T>(options: {
+        leadingText: string;
+        items: T[];
+        trailingText?: string;
+        maxLength: number;
+        itemSeparator?: string;
+        partBuilder?: (item: T) => string;
+    }): string;
+    getAstNodeFriendlyName(node: AstNode): string;
+    hasLeadingComments(input: Token | AstNode): boolean;
+    getLeadingComments(input: Token | AstNode): Token[];
+    isLeadingCommentOnSameLine(line: RangeLike, input: Token | AstNode): boolean;
+    isClassUsedAsFunction(potentialClassType: BscType, expression: Expression, options: GetTypeOptions): boolean;
+    getSpecialCaseCallExpressionReturnType(callExpr: CallExpression, options: GetSymbolTypeOptions): BscType;
+    getCallFuncType(callExpr: CallExpression | CallfuncExpression, methodNameToken: Token | Identifier, options: GetSymbolTypeOptions): BscType;
+    isUnionOfFunctions(type: BscType, allowReferenceTypes?: boolean): type is UnionType;
+    isIntersectionOfFunctions(type: BscType, allowReferenceTypes?: boolean): type is IntersectionType;
+    getFunctionTypeFromUnion(type: BscType): BscType;
+    getFunctionTypeFromIntersection(type: BscType): BscType;
+    getReturnTypeOfUnionOfFunctions(type: UnionType): BscType;
+    getReturnTypeOfIntersectionOfFunctions(type: IntersectionType): BscType;
+    symbolComesFromSameNode(symbolName: string, definingNode: AstNode, symbolTable: SymbolTable): boolean;
+    isCalleeMemberOfNamespace(symbolName: string, nodeWhereUsed: AstNode, namespace?: NamespaceStatement): boolean;
+    isVariableMemberOfNamespace(symbolName: string, nodeWhereUsed: AstNode, namespace?: NamespaceStatement): boolean;
+    isVariableShadowingSomething(symbolName: string, nodeWhereUsed: AstNode): boolean;
+    chooseTypeFromCodeOrDocComment(codeType: BscType, docType: BscType, options: GetTypeOptions): BscType;
+    /**
+     * Gets the type for a default value (eg. as a function param, class member or typed array)
+     */
+    getDefaultTypeFromValueType(valueType: (BscType | BscType[])): BscType;
+    /**
+     * Get the default type for an iterator of the given type
+     * Used for `for each` loops
+     */
+    getIteratorDefaultType(iteratorType: BscType): BscType;
+    /**
+     * Get a short name that can be used to reference the project in logs. (typically something like `prj1`, `prj8`, etc...)
+     */
+    getProjectLogName(config: {
+        projectNumber: number;
+    }): 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,
  * we can't use `object.tag` syntax.
  */
 export declare function standardizePath(stringParts: any, ...expressions: any[]): string;
+/**
+ * An item that can be coerced into a `Range`
+ */
+export declare type RangeLike = {
+    location?: Location;
+} | Location | {
+    range?: Range;
+} | Range | undefined;
 export declare let util: Util;
 export default util;