brighterscript 1.0.0-alpha.26 → 1.0.0-alpha.27

package/dist/interfaces.d.ts

@@ -3,13 +3,12 @@ import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenMo
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
-import type { FunctionScope } from './FunctionScope';
 import type { TypedFunctionType } from './types/TypedFunctionType';
 import type { ParseMode } from './parser/Parser';
 import type { Program } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
 import type { ClassStatement, ConstStatement, EnumStatement, FunctionStatement, NamespaceStatement } from './parser/Statement';
-import type { AstNode, Expression, Statement } from './parser/AstNode';
+import type { AstNode, AstNodeKind, Expression, Statement } from './parser/AstNode';
 import type { TranspileState } from './parser/TranspileState';
 import type { SourceNode } from 'source-map';
 import type { BscType } from './types/BscType';
@@ -18,8 +17,8 @@ import type { Identifier, Token } from './lexer/Token';
 import type { BscFile } from './files/BscFile';
 import type { FileFactory } from './files/Factory';
 import type { LazyFileData } from './files/LazyFileData';
-import type { SymbolTable, SymbolTypeFlag } from './SymbolTable';
-import type { CallExpression } from './parser/Expression';
+import type { SymbolTable } from './SymbolTable';
+import type { SymbolTypeFlag } from './SymbolTableFlag';
 export interface BsDiagnostic extends Diagnostic {
     file: BscFile;
     /**
@@ -73,28 +72,6 @@ export interface Callable {
      */
     functionStatement: FunctionStatement;
 }
-export interface FunctionCall {
-    /**
-     * The full range of this function call (from the start of the function name to its closing paren)
-     */
-    range: Range;
-    expression: CallExpression;
-    functionScope: FunctionScope;
-    file: BscFile;
-    name: string;
-    args: CallableArg[];
-    nameRange: Range;
-}
-/**
- * An argument for an expression call.
- */
-export interface CallableArg {
-    text: string;
-    type: BscType;
-    typeToken: Token;
-    range: Range;
-    expression: Expression;
-}
 export interface CallableParam {
     name: string;
     type: BscType;
@@ -182,71 +159,71 @@ export interface CompilerPlugin {
     /**
      * Called before a new program is created
      */
-    beforeProgramCreate?: PluginHandler<BeforeProgramCreateEvent>;
+    beforeProgramCreate?(event: BeforeProgramCreateEvent): any;
     /**
      * Called after a new program is created
      */
-    afterProgramCreate?: PluginHandler<AfterProgramCreateEvent>;
+    afterProgramCreate?(event: AfterProgramCreateEvent): any;
     /**
      * Called before the program gets prepared for building
      */
-    beforePrepareProgram?: PluginHandler<BeforePrepareProgramEvent>;
+    beforePrepareProgram?(event: BeforePrepareProgramEvent): any;
     /**
      * Called when the program gets prepared for building
      */
-    prepareProgram?: PluginHandler<PrepareProgramEvent>;
+    prepareProgram?(event: PrepareProgramEvent): any;
     /**
      * Called after the program gets prepared for building
      */
-    afterPrepareProgram?: PluginHandler<AfterPrepareProgramEvent>;
+    afterPrepareProgram?(event: AfterPrepareProgramEvent): any;
     /**
      * Called before the entire program is validated
      */
-    beforeProgramValidate?: PluginHandler<BeforeProgramValidateEvent>;
+    beforeProgramValidate?(event: BeforeProgramValidateEvent): any;
     /**
      * Called before the entire program is validated
      */
-    onProgramValidate?: PluginHandler<OnProgramValidateEvent>;
+    onProgramValidate?(event: OnProgramValidateEvent): any;
     /**
      * Called after the program has been validated
      */
-    afterProgramValidate?: PluginHandler<AfterProgramValidateEvent>;
+    afterProgramValidate?(event: AfterProgramValidateEvent): any;
     /**
      * Called right before the program is disposed/destroyed
      */
-    beforeProgramDispose?: PluginHandler<BeforeProgramDisposeEvent>;
+    beforeProgramDispose?(event: BeforeProgramDisposeEvent): any;
     /**
      * Emitted before the program starts collecting completions
      */
-    beforeProvideCompletions?: PluginHandler<BeforeProvideCompletionsEvent>;
+    beforeProvideCompletions?(event: BeforeProvideCompletionsEvent): any;
     /**
      * Use this event to contribute completions
      */
-    provideCompletions?: PluginHandler<ProvideCompletionsEvent>;
+    provideCompletions?(event: ProvideCompletionsEvent): any;
     /**
      * Emitted after the program has finished collecting completions, but before they are sent to the client
      */
-    afterProvideCompletions?: PluginHandler<AfterProvideCompletionsEvent>;
+    afterProvideCompletions?(event: AfterProvideCompletionsEvent): any;
     /**
      * Called before the `provideHover` hook. Use this if you need to prepare any of the in-memory objects before the `provideHover` gets called
      */
-    beforeProvideHover?: PluginHandler<BeforeProvideHoverEvent>;
+    beforeProvideHover?(event: BeforeProvideHoverEvent): any;
     /**
      * Called when bsc looks for hover information. Use this if your plugin wants to contribute hover information.
      */
-    provideHover?: PluginHandler<ProvideHoverEvent>;
+    provideHover?(event: ProvideHoverEvent): any;
     /**
      * Called after the `provideHover` hook. Use this if you want to intercept or sanitize the hover data (even from other plugins) before it gets sent to the client.
      */
-    afterProvideHover?: PluginHandler<AfterProvideHoverEvent>;
+    afterProvideHover?(event: AfterProvideHoverEvent): any;
     /**
      * Called after a scope was created
      */
-    afterScopeCreate?: PluginHandler<AfterScopeCreateEvent>;
-    beforeScopeDispose?: PluginHandler<BeforeScopeDisposeEvent>;
-    onScopeDispose?: PluginHandler<OnScopeDisposeEvent>;
-    afterScopeDispose?: PluginHandler<AfterScopeDisposeEvent>;
-    beforeScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
+    afterScopeCreate?(event: AfterScopeCreateEvent): any;
+    beforeScopeDispose?(event: BeforeScopeDisposeEvent): any;
+    onScopeDispose?(event: OnScopeDisposeEvent): any;
+    afterScopeDispose?(event: AfterScopeDisposeEvent): any;
+    beforeScopeValidate?(event: BeforeScopeValidateEvent): any;
     /**
      * Called before the `provideDefinition` hook
      */
@@ -261,120 +238,119 @@ export interface CompilerPlugin {
      * @param event
      */
     afterProvideDefinition?(event: AfterProvideDefinitionEvent): any;
-    onScopeValidate?: PluginHandler<OnScopeValidateEvent>;
-    afterScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
-    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
-    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
+    onScopeValidate?(event: OnScopeValidateEvent): any;
+    afterScopeValidate?(event: BeforeScopeValidateEvent): any;
+    onGetCodeActions?(event: OnGetCodeActionsEvent): any;
+    onGetSemanticTokens?(event: OnGetSemanticTokensEvent): any;
     /**
      * Called before plugins are asked to provide files to the program. (excludes virtual files produced by `provideFile` events).
      * Call the `setFileData()` method to override the file contents.
      */
-    beforeProvideFile?: PluginHandler<BeforeProvideFileEvent>;
+    beforeProvideFile?(event: BeforeProvideFileEvent): any;
     /**
      * Give plugins the opportunity to handle processing a file. (excludes virtual files produced by `provideFile` events)
      */
-    provideFile?: PluginHandler<ProvideFileEvent>;
+    provideFile?(event: ProvideFileEvent): any;
     /**
      * Called after a file was added to the program. (excludes virtual files produced by `provideFile` events)
      */
-    afterProvideFile?: PluginHandler<AfterProvideFileEvent>;
+    afterProvideFile?(event: AfterProvideFileEvent): any;
     /**
      * Called before a file is added to the program.
      * Includes physical files as well as any virtual files produced by `provideFile` events
      */
-    beforeFileAdd?: PluginHandler<BeforeFileAddEvent>;
+    beforeFileAdd?(event: BeforeFileAddEvent): any;
     /**
      * Called after a file has been added to the program.
      * Includes physical files as well as any virtual files produced by `provideFile` events
      */
-    afterFileAdd?: PluginHandler<AfterFileAddEvent>;
+    afterFileAdd?(event: AfterFileAddEvent): any;
     /**
      * Called before a file is removed from the program. This includes physical and virtual files
      */
-    beforeFileRemove?: PluginHandler<BeforeFileRemoveEvent>;
+    beforeFileRemove?(event: BeforeFileRemoveEvent): any;
     /**
      * Called after a file has been removed from the program. This includes physical and virtual files
      */
-    afterFileRemove?: PluginHandler<AfterFileRemoveEvent>;
+    afterFileRemove?(event: AfterFileRemoveEvent): any;
     /**
      * Called before each file is validated
      */
-    beforeFileValidate?: PluginHandler<BeforeFileValidateEvent>;
+    beforeFileValidate?(event: BeforeFileValidateEvent): any;
     /**
      * Called during the file validation process. If your plugin contributes file validations, this is a good place to contribute them.
      */
-    onFileValidate?: PluginHandler<OnFileValidateEvent>;
+    onFileValidate?(event: OnFileValidateEvent): any;
     /**
      * Called after each file is validated
      */
-    afterFileValidate?: PluginHandler<AfterFileValidateEvent>;
+    afterFileValidate?(event: AfterFileValidateEvent): any;
     /**
      * Called right before the program builds (i.e. generates the code and puts it in the stagingDir
      */
-    beforeBuildProgram?: PluginHandler<BeforeBuildProgramEvent>;
+    beforeBuildProgram?(event: BeforeBuildProgramEvent): any;
     /**
      * Called right after the program builds (i.e. generates the code and puts it in the stagingDir
      */
-    afterBuildProgram?: PluginHandler<AfterBuildProgramEvent>;
+    afterBuildProgram?(event: AfterBuildProgramEvent): any;
     /**
      * Before preparing the file for building
      */
-    beforePrepareFile?: PluginHandler<BeforePrepareFileEvent>;
+    beforePrepareFile?(event: BeforePrepareFileEvent): any;
     /**
      * Prepare the file for building
      */
-    prepareFile?: PluginHandler<PrepareFileEvent>;
+    prepareFile?(event: PrepareFileEvent): any;
     /**
      * After preparing the file for building
      */
-    afterPrepareFile?: PluginHandler<AfterPrepareFileEvent>;
+    afterPrepareFile?(event: AfterPrepareFileEvent): any;
     /**
      * Before the program turns all file objects into their final buffers
      */
-    beforeSerializeProgram?: PluginHandler<BeforeSerializeProgramEvent>;
+    beforeSerializeProgram?(event: BeforeSerializeProgramEvent): any;
     /**
      * Emitted right at the start of the program turning all file objects into their final buffers
      */
-    onSerializeProgram?: PluginHandler<OnSerializeProgramEvent>;
+    onSerializeProgram?(event: OnSerializeProgramEvent): any;
     /**
      * After the program turns all file objects into their final buffers
      */
-    afterSerializeProgram?: PluginHandler<AfterSerializeProgramEvent>;
+    afterSerializeProgram?(event: AfterSerializeProgramEvent): any;
     /**
      * Before turning the file into its final contents
      */
-    beforeSerializeFile?: PluginHandler<BeforeSerializeFileEvent>;
+    beforeSerializeFile?(event: BeforeSerializeFileEvent): any;
     /**
      * Turn the file into its final contents (i.e. transpile a bs file, compress a jpeg, etc)
      */
-    serializeFile?: PluginHandler<SerializeFileEvent>;
+    serializeFile?(event: SerializeFileEvent): any;
     /**
      * After turning the file into its final contents
      */
-    afterSerializeFile?: PluginHandler<AfterSerializeFileEvent>;
+    afterSerializeFile?(event: AfterSerializeFileEvent): any;
     /**
      * Called before any files are written
      */
-    beforeWriteProgram?: PluginHandler<BeforeWriteProgramEvent>;
+    beforeWriteProgram?(event: BeforeWriteProgramEvent): any;
     /**
      * Called after all files are written
      */
-    afterWriteProgram?: PluginHandler<AfterWriteProgramEvent>;
+    afterWriteProgram?(event: AfterWriteProgramEvent): any;
     /**
      * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
      */
-    beforeWriteFile?: PluginHandler<BeforeWriteFileEvent>;
+    beforeWriteFile?(event: BeforeWriteFileEvent): any;
     /**
      * Called when a file should be persisted (usually writing to storage). These are raw files that contain the final output. One `File` may produce several of these.
      * When a plugin has handled a file, it should be pushed to the `handledFiles` set so future plugins don't write the file multiple times
      */
-    writeFile?: PluginHandler<WriteFileEvent>;
+    writeFile?(event: WriteFileEvent): any;
     /**
      * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
      */
-    afterWriteFile?: PluginHandler<AfterWriteFileEvent>;
+    afterWriteFile?(event: AfterWriteFileEvent): any;
 }
-export declare type PluginHandler<T, R = void> = (event: T) => R;
 export interface OnGetCodeActionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
     file: TFile;
@@ -726,13 +702,21 @@ export interface GetTypeOptions {
     ignoreCacheForRetrieval?: boolean;
 }
 export declare class TypeChainEntry {
-    name: string;
-    type: BscType;
-    range: Range;
-    separatorToken: Token;
-    data: ExtraSymbolData;
-    constructor(name: string, type: BscType, data: ExtraSymbolData, range: Range, separatorToken?: Token);
+    constructor(options: {
+        name: string;
+        type: BscType;
+        data: ExtraSymbolData;
+        range: Range;
+        separatorToken?: Token;
+        kind?: AstNodeKind;
+    });
     get isResolved(): boolean;
+    readonly name: string;
+    readonly type: BscType;
+    readonly data: ExtraSymbolData;
+    readonly range: Range;
+    readonly separatorToken: Token;
+    kind: AstNodeKind;
 }
 export interface TypeChainProcessResult {
     itemName: string;
@@ -773,3 +757,13 @@ export interface NamespaceContainer {
     namespaces?: Map<string, NamespaceContainer>;
     symbolTable: SymbolTable;
 }
+/**
+ * Use Writable<T> to remove readonly flag from properties in T
+ * Be careful!
+ */
+export declare type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export declare type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};

package/dist/interfaces.js

@@ -11,15 +11,15 @@ var DiagnosticOrigin;
     DiagnosticOrigin["ASTSegment"] = "AstSegment";
 })(DiagnosticOrigin = exports.DiagnosticOrigin || (exports.DiagnosticOrigin = {}));
 class TypeChainEntry {
-    constructor(name, type, data, range, separatorToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dot)) {
-        this.name = name;
-        this.type = type;
-        this.range = range;
-        this.separatorToken = separatorToken;
-        if (data) {
-            // make a copy of this data
-            this.data = Object.assign({}, data);
-        }
+    constructor(options) {
+        var _a;
+        this.name = options.name;
+        // make a copy of this data
+        this.data = Object.assign({}, options.data);
+        this.type = options.type;
+        this.range = options.range;
+        this.separatorToken = (_a = options.separatorToken) !== null && _a !== void 0 ? _a : (0, creators_1.createToken)(TokenKind_1.TokenKind.Dot);
+        this.kind = options.kind;
     }
     get isResolved() {
         var _a;

package/dist/interfaces.js.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AAqBA,kDAAkD;AAClD,iDAA8C;AAU9C,IAAY,gBAKX;AALD,WAAY,gBAAgB;IACxB,uCAAmB,CAAA;IACnB,mCAAe,CAAA;IACf,iCAAa,CAAA;IACb,6CAAyB,CAAA;AAC7B,CAAC,EALW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAK3B;AAixBD,MAAa,cAAc;IAEvB,YAAmB,IAAY,EAAS,IAAa,EAAE,IAAqB,EAAS,KAAY,EAAS,iBAAwB,IAAA,sBAAW,EAAC,qBAAS,CAAC,GAAG,CAAC;QAAzI,SAAI,GAAJ,IAAI,CAAQ;QAAS,SAAI,GAAJ,IAAI,CAAS;QAAgC,UAAK,GAAL,KAAK,CAAO;QAAS,mBAAc,GAAd,cAAc,CAAoC;QACxJ,IAAI,IAAI,EAAE;YACN,2BAA2B;YAC3B,IAAI,CAAC,IAAI,qBAAQ,IAAI,CAAE,CAAC;SAC3B;IACL,CAAC;IACD,IAAI,UAAU;;QACV,OAAO,MAAA,IAAI,CAAC,IAAI,0CAAE,YAAY,EAAE,CAAC;IACrC,CAAC;CACJ;AAXD,wCAWC"}
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AAoBA,kDAAkD;AAClD,iDAA8C;AAU9C,IAAY,gBAKX;AALD,WAAY,gBAAgB;IACxB,uCAAmB,CAAA;IACnB,mCAAe,CAAA;IACf,iCAAa,CAAA;IACb,6CAAyB,CAAA;AAC7B,CAAC,EALW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAK3B;AAwvBD,MAAa,cAAc;IACvB,YAAY,OAOX;;QACG,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,2BAA2B;QAC3B,IAAI,CAAC,IAAI,qBAAQ,OAAO,CAAC,IAAI,CAAE,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,MAAA,OAAO,CAAC,cAAc,mCAAI,IAAA,sBAAW,EAAC,qBAAS,CAAC,GAAG,CAAC,CAAC;QAC3E,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC7B,CAAC;IACD,IAAI,UAAU;;QACV,OAAO,MAAA,IAAI,CAAC,IAAI,0CAAE,YAAY,EAAE,CAAC;IACrC,CAAC;CAQJ;AA3BD,wCA2BC"}