brighterscript 0.66.0-alpha.1 → 0.66.0-alpha.11

package/dist/Scope.d.ts

@@ -1,14 +1,15 @@
-import type { CompletionItem, Position, Range, Location } from 'vscode-languageserver';
-import type { CallableContainer, BsDiagnostic, BscFile, CallableContainerMap, FileLink, Callable } 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, FunctionStatement, ClassStatement, EnumStatement, InterfaceStatement, EnumMemberStatement, ConstStatement } from './parser/Statement';
-import type { 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 } from './files/BrsFile';
 import type { DependencyGraph, DependencyChangedEvent } from './DependencyGraph';
 import { SymbolTable } from './SymbolTable';
-import type { Statement } from './parser/AstNode';
+import type { File } from './files/File';
+import { type AstNode, type Statement } from './parser/AstNode';
+import type { Token } from './lexer/Token';
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -34,6 +35,10 @@ export declare class Scope {
      * 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
@@ -82,6 +87,7 @@ export declare class Scope {
      * @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>[];
     /**
      * 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:
@@ -129,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
@@ -154,26 +160,25 @@ export declare class Scope {
     attachDependencyGraph(dependencyGraph: DependencyGraph): void;
     /**
      * Get the file from this scope with the given path.
-     * @param filePath can be a srcPath or pkgPath
+     * @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<TFile extends BscFile>(filePath: string, normalizePath?: boolean): TFile;
+    getFile<TFile extends File>(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
      */
-    getOwnFiles(): BscFile[];
+    getOwnFiles(): File[];
     /**
      * Get the list of files referenced by this scope that are actually loaded in the program.
      * Includes files from this scope and all ancestor scopes
      */
-    getAllFiles(): BscFile[];
+    getAllFiles(): File[];
     /**
-     * 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)
      */
@@ -191,7 +196,7 @@ export declare class Scope {
     /**
      * Call a function for each file directly included in this scope (excluding files found only in parent scopes).
      */
-    enumerateOwnFiles(callback: (file: BscFile) => void): void;
+    enumerateOwnFiles(callback: (file: File) => void): void;
     /**
      * Get the list of callables explicitly defined in files in this scope.
      * This excludes ancestor callables
@@ -200,21 +205,45 @@ 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(force?: boolean): void;
+    validate(validationOptions?: ScopeValidationOptions): void;
     protected _validate(callableContainerMap: CallableContainerMap): void;
+    clearAstSegmentDiagnostics(astSegment: AstNode): void;
+    clearAstSegmentDiagnosticsByFile(file: File): void;
+    clearScopeLevelDiagnostics(): void;
     /**
      * Mark this scope as invalid, which means its `validate()` function needs to be called again before use.
      */
     invalidate(): void;
     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;
@@ -223,12 +252,10 @@ export declare class Scope {
      * Find various function collisions
      */
     private diagnosticDetectFunctionCollisions;
+    private detectNameCollisions;
+    validateNameCollision(file: BrsFile, node: AstNode, nameIdentifier: Token): void;
     getNewExpressions(): AugmentedNewExpression[];
     private validateClasses;
-    /**
-     * Detect calls to functions with the incorrect number of parameters
-     */
-    private diagnosticDetectFunctionCallsWithWrongParamCount;
     /**
      * Detect local variables (function scope) that have the same name as scope calls
      */
@@ -248,26 +275,15 @@ export declare class Scope {
     /**
      * Find the file with the specified relative path
      */
-    protected getFileByRelativePath(relativePath: string): BscFile;
+    protected getFileByRelativePath(relativePath: string): File;
     /**
      * Determine if this file is included in this scope (excluding parent scopes)
      */
-    hasFile(file: BscFile): boolean;
-    /**
-     * Get all callables as completionItems
-     */
-    getCallablesAsCompletions(parseMode: ParseMode): CompletionItem[];
-    createCompletionFromCallable(callableContainer: CallableContainer): CompletionItem;
-    createCompletionFromFunctionStatement(statement: FunctionStatement): CompletionItem;
+    hasFile(file: File): boolean;
     /**
      * 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>;
+    getDefinition(file: File, position: Position): Location[];
     /**
      * @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).
@@ -275,20 +291,7 @@ export declare class Scope {
      */
     getClassHierarchy(className: string, callsiteNamespace?: string): FileLink<ClassStatement>[];
 }
-interface NamespaceContainer {
-    file: BscFile;
-    fullName: string;
-    nameRange: Range;
-    lastPartName: string;
-    statements: Statement[];
-    classStatements: Record<string, ClassStatement>;
-    functionStatements: Record<string, FunctionStatement>;
-    enumStatements: Map<string, EnumStatement>;
-    constStatements: Map<string, ConstStatement>;
-    namespaces: Map<string, NamespaceContainer>;
-    symbolTable: SymbolTable;
-}
 interface AugmentedNewExpression extends NewExpression {
-    file: BscFile;
+    file: File;
 }
 export {};