brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/Scope.d.ts

@@ -1,15 +1,15 @@
-import type { CompletionItem, Position, Range, Location } from 'vscode-languageserver';
-import type { CallableContainer, BsDiagnostic, BscFile, CallableContainerMap, FileLink, InheritableStatement, InheritableType, NamedTypeStatement } from './interfaces';
+import type { Position, Location } from 'vscode-languageserver';
+import { type CallableContainer, type BsDiagnosticWithOrigin, type CallableContainerMap, type FileLink, type Callable, type NamespaceContainer, type ScopeValidationOptions, type BsDiagnostic } from './interfaces';
 import type { Program } from './Program';
-import type { NamespaceStatement, Statement, FunctionStatement, ClassStatement, EnumStatement, InterfaceStatement, EnumMemberStatement, ConstStatement } from './parser/Statement';
-import type { FunctionExpression, NewExpression } from './parser/Expression';
-import { ParseMode } from './parser/Parser';
+import type { NamespaceStatement, ClassStatement, EnumStatement, InterfaceStatement, EnumMemberStatement, ConstStatement } from './parser/Statement';
+import { type NewExpression } from './parser/Expression';
 import { Cache } from './Cache';
-import type { BrsFile, TokenSymbolLookup } from './files/BrsFile';
+import type { BrsFile } from './files/BrsFile';
 import type { DependencyGraph, DependencyChangedEvent } from './DependencyGraph';
 import { SymbolTable } from './SymbolTable';
+import type { BscFile } from './files/BscFile';
+import { type AstNode, type Statement } from './parser/AstNode';
 import type { Token } from './lexer/Token';
-import type { BscType, TypeContext } from './types/BscType';
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -22,7 +22,7 @@ export declare class Scope {
      * Indicates whether this scope needs to be validated.
      * Will be true when first constructed, or anytime one of its dependencies changes
      */
-    isValidated: boolean;
+    readonly isValidated: boolean;
     protected cache: Cache<any, any>;
     get dependencyGraphKey(): string;
     /**
@@ -31,6 +31,14 @@ export declare class Scope {
      * "namea", "namea.nameb", "namea.nameb.namec"
      */
     get namespaceLookup(): Map<string, NamespaceContainer>;
+    /**
+     * Get a NamespaceContainer by its name, looking for a fully qualified version first, then global version next if not found
+     */
+    getNamespace(name: string, containingNamespace?: string): NamespaceContainer;
+    /**
+     * Get a NamespaceContainer by its name, looking for a fully qualified version first, then global version next if not found
+     */
+    getNamespacesWithRoot(rootName: string, containingNamespace?: string): NamespaceContainer[];
     /**
      * Get the class with the specified name.
      * @param className - The class name, including the namespace of the class if possible
@@ -43,18 +51,6 @@ export declare class Scope {
      * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
      */
     getInterface(ifaceName: string, containingNamespace?: string): InterfaceStatement;
-    /**
-     * Get either the class or interface, etc. with a given name
-     * @param name - The name, including the namespace of the interface if possible
-     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find the interface or class)
-     */
-    getNamedTypeStatement(name: string, containingNamespace?: string): NamedTypeStatement;
-    /**
-     * A cache of a map of tokens -> TokenSymbolLookups, which are the result of getSymbolTypeFromToken()
-     * Sometimes the lookup of symbols may take a while if there are lazyTypes or multiple tokens in a chain
-     * By caching the result of this lookup, subsequent lookups of the same tokens are quicker
-     */
-    get symbolCache(): Map<Token, TokenSymbolLookup>;
     /**
      * Get the enum with the specified name.
      * @param enumName - The enum name, including the namespace if possible
@@ -68,10 +64,10 @@ export declare class Scope {
      */
     getClassFileLink(className: string, containingNamespace?: string): FileLink<ClassStatement>;
     /**
-   * Get an interface and its containing file by the interface name
-   * @param ifaceName - The interface name, including the namespace of the interface if possible
-   * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
-   */
+     * Get an interface and its containing file by the interface name
+     * @param ifaceName - The interface name, including the namespace of the interface if possible
+     * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
+     */
     getInterfaceFileLink(ifaceName: string, containingNamespace?: string): FileLink<InterfaceStatement>;
     /**
      * Get an Enum and its containing file by the Enum name
@@ -80,75 +76,52 @@ export declare class Scope {
      */
     getEnumFileLink(enumName: string, containingNamespace?: string): FileLink<EnumStatement>;
     /**
-     * Get a Named Type (e.g. Class, Interface, Enum) and its containing file by the name
-     * @param name - The name of the type, including the namespace of the class/interface/enum, etc. if possible
-     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
-     */
-    getNamedTypeFileLink(name: string, containingNamespace?: string): FileLink<NamedTypeStatement>;
-    /**
-     * Get a InheritableStatement and its containing file by the name of the interface or class
-     * @param name - The name of the interface or class, including the namespace of the class if possible
-     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
-     */
-    getInheritableFileLink(name: string, containingNamespace?: string): FileLink<InheritableStatement>;
-    /**
-     * Gets the parent class of the given class
-     * @param klass - The class to get the parent of, if possible
+     * Get an Enum and its containing file by the Enum name
+     * @param enumMemberName - The Enum name, including the namespace of the enum if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find a enum)
      */
-    getParentClass(klass: ClassStatement): ClassStatement;
+    getEnumMemberFileLink(enumMemberName: string, containingNamespace?: string): FileLink<EnumMemberStatement>;
     /**
      * Get a constant and its containing file by the constant name
      * @param constName - The constant name, including the namespace of the constant if possible
      * @param containingNamespace - The namespace used to resolve relative constant names. (i.e. the namespace around the current statement trying to find a constant)
      */
     getConstFileLink(constName: string, containingNamespace?: string): FileLink<ConstStatement>;
+    getAllFileLinks(name: string, containingNamespace?: string): FileLink<Statement>[];
     /**
-     * Gets the parent interface of the given interface
-     * @param iface - The interface to get the parent of, if possible
+     * Get a map of all enums by their member name.
+     * The keys are lower-case fully-qualified paths to the enum and its member. For example:
+     * namespace.enum.value
      */
-    getParentInterface(iface: InterfaceStatement): InterfaceStatement;
-    /**
-    * Gets the parent of an Interface or Class
-    * @param stmt - The class or interface to get the parent of, if possible
-    */
-    getParentStatement(stmt: InheritableStatement): InheritableStatement;
     getEnumMemberMap(): Map<string, EnumMemberStatement>;
     /**
-    * Tests if a class exists with the specified name
-    * @param className - the all-lower-case namespace-included class name
-    * @param namespaceName - the current namespace name
-    */
+     * Tests if a class exists with the specified name
+     * @param className - the all-lower-case namespace-included class name
+     * @param namespaceName - The namespace used to resolve relative class names. (i.e. the namespace around the current statement trying to find a class)
+     */
     hasClass(className: string, namespaceName?: string): boolean;
     /**
-    * Tests if an interface exists with the specified name
-    * @param ifaceName - the all-lower-case namespace-included interface name
-    * @param namespaceName - the current namespace name
-    */
+     * Tests if an interface exists with the specified name
+     * @param ifaceName - the all-lower-case namespace-included interface name
+     * @param namespaceName - the current namespace name
+     */
     hasInterface(ifaceName: string, namespaceName?: string): boolean;
     /**
-    * Tests if an enum exists with the specified name
-    * @param enumName - the all-lower-case namespace-included enum name
-    * @param namespaceName - the current namespace name
-    */
-    hasEnum(enumName: string, namespaceName?: string): boolean;
-    /**
-     * Tests if a class OR an interface, etc. exists with the specified name
-     * @param name - the all-lower-case namespace-included class or interface name
+     * Tests if an enum exists with the specified name
+     * @param enumName - the all-lower-case namespace-included enum name
      * @param namespaceName - the current namespace name
      */
-    hasNamedType(name: string, namespaceName?: string): boolean;
+    hasEnum(enumName: string, namespaceName?: string): boolean;
     /**
      * A dictionary of all classes in this scope. This includes namespaced classes always with their full name.
      * The key is stored in lower case
      */
     getClassMap(): Map<string, FileLink<ClassStatement>>;
-    getAncestorTypeListByContext(thisType: BscType, context?: TypeContext): InheritableType[];
     /**
-    * A dictionary of all Interfaces in this scope. This includes namespaced Interfaces always with their full name.
-    * The key is stored in lower case
-    */
+     * A dictionary of all Interfaces in this scope. This includes namespaced Interfaces always with their full name.
+     * The key is stored in lower case
+     */
     getInterfaceMap(): Map<string, FileLink<InterfaceStatement>>;
-    getAncestorTypeList(className: string, functionExpression?: FunctionExpression): InheritableType[];
     /**
      * A dictionary of all enums in this scope. This includes namespaced enums always with their full name.
      * The key is stored in lower case
@@ -162,7 +135,7 @@ export declare class Scope {
     /**
      * The list of diagnostics found specifically for this scope. Individual file diagnostics are stored on the files themselves.
      */
-    protected diagnostics: BsDiagnostic[];
+    protected diagnostics: BsDiagnosticWithOrigin[];
     protected onDependenciesChanged(event: DependencyChangedEvent): void;
     /**
      * Clean up all event handles
@@ -178,7 +151,7 @@ export declare class Scope {
      * XmlScope overrides this to return the parent xml scope if available.
      * For globalScope this will return null.
      */
-    getParentScope(): Scope;
+    getParentScope(): Scope | null;
     private dependencyGraph;
     /**
      * An unsubscribe function for the dependencyGraph subscription
@@ -186,11 +159,11 @@ export declare class Scope {
     private unsubscribeFromDependencyGraph;
     attachDependencyGraph(dependencyGraph: DependencyGraph): void;
     /**
-     * Get the file with the specified pkgPath
-     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * Get the file from this scope with the given path.
+     * @param filePath can be a srcPath or destPath
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
-    getFile(srcPath: string, normalizePath?: boolean): BscFile;
+    getFile<TFile extends BscFile>(filePath: string, normalizePath?: boolean): TFile;
     /**
      * Get the list of files referenced by this scope that are actually loaded in the program.
      * Excludes files from ancestor scopes
@@ -202,11 +175,10 @@ export declare class Scope {
      */
     getAllFiles(): BscFile[];
     /**
-     * Get the list of errors for this scope. It's calculated on the fly, so
-     * call this sparingly.
+     * Get the list of errors for this scope. It's calculated on the fly, so call this sparingly.
      */
     getDiagnostics(): BsDiagnostic[];
-    addDiagnostics(diagnostics: BsDiagnostic[]): void;
+    addDiagnostics(diagnostics: BsDiagnosticWithOrigin[]): void;
     /**
      * Get the list of callables available in this scope (either declared in this scope or in a parent scope)
      */
@@ -214,15 +186,9 @@ export declare class Scope {
     /**
      * Get the callable with the specified name.
      * If there are overridden callables with the same name, the closest callable to this scope is returned
-     * @param name
-     */
-    getCallableByName(name: string): import("./interfaces").Callable;
-    /**
-     * Get the global callable with the specified name.
-     * If there are overridden callables with the same name, the closest callable to this scope is returned
-     * @param name
      */
-    getGlobalCallableByName(name: string): import("./interfaces").Callable;
+    getCallableByName(name: string): Callable;
+    getCallableMap(): Map<string, Callable>;
     /**
      * Iterate over Brs files not shadowed by typedefs
      */
@@ -239,26 +205,46 @@ export declare class Scope {
     /**
      * Builds a tree of namespace objects
      */
-    buildNamespaceLookup(): Map<string, NamespaceContainer>;
+    buildNamespaceLookup(options?: {
+        okToCache?: boolean;
+    }): Map<string, NamespaceContainer>;
     getAllNamespaceStatements(): NamespaceStatement[];
     protected logDebug(...args: any[]): void;
     private _debugLogComponentName;
-    validate(): void;
-    getCallableContainerMap(): CallableContainerMap;
+    validate(validationOptions?: ScopeValidationOptions): void;
     protected _validate(callableContainerMap: CallableContainerMap): void;
+    clearAstSegmentDiagnostics(astSegment: AstNode): void;
+    clearAstSegmentDiagnosticsByFile(file: BscFile): void;
+    clearScopeLevelDiagnostics(): void;
     /**
      * Mark this scope as invalid, which means its `validate()` function needs to be called again before use.
      */
     invalidate(): void;
-    get symbolTable(): any;
-    protected _memberTable: SymbolTable;
-    get memberTable(): SymbolTable;
-    protected clearSymbolTable(): void;
-    /**
-    * Builds the current symbol table for the scope, by merging the tables for all the files in this scope.
-    * Also links all file symbols tables to this new table
-    * This will only rebuilt if the symbol table has not been built before
-    */
+    get symbolTable(): SymbolTable;
+    /**
+     * A list of functions that will be called whenever `unlinkSymbolTable` is called
+     */
+    private linkSymbolTableDisposables;
+    private symbolsAddedDuringLinking;
+    /**
+     * Builds the current symbol table for the scope, by merging the tables for all the files in this scope.
+     * Also links all file symbols tables to this new table
+     * This will only rebuilt if the symbol table has not been built before
+     *
+     *  Tree of symbol tables:
+     *  ```
+     *  Global Scope Symbol Table
+     *      -  Source Scope Symbol Table :: Aggregate Namespaces Symbol Table (Siblings)
+     *          - File 1 Symbol Table
+     *          - File 2 Symbol Table
+     *      -  Component A Scope Symbol Table :: Aggregate Namespaces Symbol Table (Siblings)
+     *          - File 1 Symbol Table
+     *          - File 2 Symbol Table
+     *      -  Component B Scope Symbol Table :: Aggregate Namespaces Symbol Table (Siblings)
+     *          - File 1 Symbol Table
+     *          - File 2 Symbol Table
+     * ```
+     */
     linkSymbolTable(): void;
     unlinkSymbolTable(): void;
     private detectVariableNamespaceCollisions;
@@ -266,21 +252,16 @@ export declare class Scope {
      * Find various function collisions
      */
     private diagnosticDetectFunctionCollisions;
-    /**
-    * Find function parameters and function return types that are neither built-in types or known Class references
-    */
-    private diagnosticDetectInvalidFunctionExpressionTypes;
+    private detectNameCollisions;
+    validateNameCollision(file: BrsFile, node: AstNode, nameIdentifier: Token): void;
     getNewExpressions(): AugmentedNewExpression[];
     private validateClasses;
     /**
-     * Detect local variables (vars declared within a function expression) that have the same name as scope calls
-     * @param file
-     * @param callableContainerMap
+     * Detect local variables (function scope) that have the same name as scope calls
      */
     private diagnosticDetectShadowedLocalVars;
     /**
      * Create diagnostics for any duplicate function declarations
-     * @param callablesByLowerName
      */
     private diagnosticFindDuplicateFunctionDeclarations;
     /**
@@ -293,50 +274,23 @@ export declare class Scope {
     private diagnosticValidateScriptImportPaths;
     /**
      * Find the file with the specified relative path
-     * @param relativePath
      */
     protected getFileByRelativePath(relativePath: string): BscFile;
     /**
      * Determine if this file is included in this scope (excluding parent scopes)
-     * @param file
      */
     hasFile(file: BscFile): boolean;
-    /**
-     * Get all callables as completionItems
-     */
-    getCallablesAsCompletions(parseMode: ParseMode): CompletionItem[];
-    createCompletionFromCallable(callableContainer: CallableContainer): CompletionItem;
-    createCompletionFromFunctionStatement(statement: FunctionStatement): CompletionItem;
     /**
      * Get the definition (where was this thing first defined) of the symbol under the position
      */
     getDefinition(file: BscFile, position: Position): Location[];
-    /**
-     * Scan all files for property names, and return them as completions
-     */
-    getPropertyNameCompletions(): CompletionItem[];
-    getAllClassMemberCompletions(): Map<string, CompletionItem>;
     /**
      * @param className - The name of the class (including namespace if possible)
      * @param callsiteNamespace - the name of the namespace where the call site resides (this is NOT the known namespace of the class).
-     *                            This is used to help resolve non-namespaced class names that reside in the same namespace as the call site.
+     *                            This is used to help resolve non-namespaced class names that reside in the same namespac as the call site.
      */
     getClassHierarchy(className: string, callsiteNamespace?: string): FileLink<ClassStatement>[];
 }
-export interface NamespaceContainer {
-    file: BscFile;
-    fullName: string;
-    nameRange: Range;
-    lastPartName: string;
-    statements: Statement[];
-    classStatements: Record<string, ClassStatement>;
-    interfaceStatements: Record<string, InterfaceStatement>;
-    functionStatements: Record<string, FunctionStatement>;
-    enumStatements: Map<string, EnumStatement>;
-    constStatements: Map<string, ConstStatement>;
-    namespaces: Map<string, NamespaceContainer>;
-    symbolTable: SymbolTable;
-}
 interface AugmentedNewExpression extends NewExpression {
     file: BscFile;
 }