brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/interfaces.d.ts

@@ -2,15 +2,15 @@ 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 { FunctionType } from './types/FunctionType';
 import type { ParseMode } from './parser/Parser';
-import type { Program, SourceObj, TranspileObj } from './Program';
+import type { Program } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
-import type { Expression, FunctionStatement } from './parser';
+import type { Expression, FunctionStatement, FunctionExpression } from './parser';
 import type { TranspileState } from './parser/TranspileState';
 import type { SourceNode } from 'source-map';
 import type { BscType } from './types/BscType';
+import type { Token } from './lexer/Token';
 export interface BsDiagnostic extends Diagnostic {
     file: BscFile;
     /**
@@ -60,11 +60,12 @@ export interface FunctionCall {
      * The full range of this function call (from the start of the function name to its closing paren)
      */
     range: Range;
-    functionScope: FunctionScope;
-    file: File;
-    name: string;
+    functionExpression: FunctionExpression;
+    file: BscFile;
+    name: Token;
     args: CallableArg[];
     nameRange: Range;
+    isDottedInvocation: boolean;
 }
 /**
  * An argument for an expression call.
@@ -108,14 +109,6 @@ export interface FileReference {
      */
     filePathRange?: Range;
 }
-export interface File {
-    /**
-     * The absolute path to the file, relative to the pkg
-     */
-    pkgPath: string;
-    pathAbsolute: string;
-    getDiagnostics(): BsDiagnostic[];
-}
 export interface VariableDeclaration {
     name: string;
     type: BscType;
@@ -160,36 +153,77 @@ export interface CommentFlag {
     affectedRange: Range;
     codes: DiagnosticCode[] | null;
 }
-declare type ValidateHandler = (scope: Scope, files: BscFile[], callables: CallableContainerMap) => void;
 export declare type CompilerPluginFactory = () => CompilerPlugin;
 export interface CompilerPlugin {
     name: string;
-    beforeProgramCreate?: (builder: ProgramBuilder) => void;
-    beforePrepublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
-    afterPrepublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
-    beforePublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
-    afterPublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
-    afterProgramCreate?: (program: Program) => void;
-    beforeProgramValidate?: (program: Program) => void;
-    afterProgramValidate?: (program: Program) => void;
-    beforeProgramTranspile?: (program: Program, entries: TranspileObj[]) => void;
-    afterProgramTranspile?: (program: Program, entries: TranspileObj[]) => void;
+    beforeProgramCreate?: PluginHandler<BeforeProgramCreateEvent>;
+    afterProgramCreate?: PluginHandler<AfterProgramCreateEvent>;
+    beforePrepublish?: PluginHandler<BeforePrepublishEvent>;
+    afterPrepublish?: PluginHandler<AfterPrepublishEvent>;
+    beforePublish?: PluginHandler<BeforePublishEvent>;
+    afterPublish?: PluginHandler<AfterPublishEvent>;
+    beforeProgramValidate?: PluginHandler<BeforeProgramValidateEvent>;
+    afterProgramValidate?: PluginHandler<AfterProgramValidateEvent>;
+    beforeProgramTranspile?: PluginHandler<BeforeProgramTranspileEvent>;
+    afterProgramTranspile?: PluginHandler<AfterProgramTranspileEvent>;
     onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
     onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
-    afterScopeCreate?: (scope: Scope) => void;
-    beforeScopeDispose?: (scope: Scope) => void;
-    afterScopeDispose?: (scope: Scope) => void;
-    beforeScopeValidate?: ValidateHandler;
-    afterScopeValidate?: ValidateHandler;
-    beforeFileParse?: (source: SourceObj) => void;
-    afterFileParse?: (file: BscFile) => void;
-    afterFileValidate?: (file: BscFile) => void;
-    beforeFileTranspile?: (entry: TranspileObj) => void;
-    afterFileTranspile?: (entry: TranspileObj) => void;
-    beforeFileDispose?: (file: BscFile) => void;
-    afterFileDispose?: (file: BscFile) => void;
+    afterScopeCreate?: PluginHandler<AfterScopeCreateEvent>;
+    beforeScopeDispose?: PluginHandler<BeforeScopeDisposeEvent>;
+    afterScopeDispose?: PluginHandler<AfterScopeDisposeEvent>;
+    beforeScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
+    afterScopeValidate?: PluginHandler<AfterScopeValidateEvent>;
+    beforeFileParse?: PluginHandler<BeforeFileParseEvent>;
+    afterFileParse?: PluginHandler<AfterFileParseEvent>;
+    beforeFileValidate?: PluginHandler<BeforeFileValidateEvent>;
+    afterFileValidate?: PluginHandler<AfterFileValidateEvent>;
+    beforeFileTranspile?: PluginHandler<BeforeFileTranspileEvent>;
+    afterFileTranspile?: PluginHandler<AfterFileTranspileEvent>;
+    beforeFileDispose?: PluginHandler<BeforeFileDisposeEvent>;
+    afterFileDispose?: PluginHandler<AfterFileDisposeEvent>;
 }
 export declare type PluginHandler<T> = (event: T) => void;
+export interface BeforeProgramCreateEvent {
+    builder: ProgramBuilder;
+}
+export interface BeforePrepublishEvent {
+    builder: ProgramBuilder;
+    program: Program;
+    files: FileObj[];
+}
+export interface AfterPrepublishEvent {
+    builder: ProgramBuilder;
+    program: Program;
+    files: FileObj[];
+}
+export interface BeforePublishEvent {
+    builder: ProgramBuilder;
+    program: Program;
+    files: FileObj[];
+}
+export interface AfterPublishEvent {
+    builder: ProgramBuilder;
+    program: Program;
+    files: FileObj[];
+}
+export interface AfterProgramCreateEvent {
+    builder: ProgramBuilder;
+    program: Program;
+}
+export interface BeforeProgramValidateEvent {
+    program: Program;
+}
+export interface AfterProgramValidateEvent {
+    program: Program;
+}
+export interface BeforeProgramTranspileEvent {
+    program: Program;
+    entries: TranspileEntry[];
+}
+export interface AfterProgramTranspileEvent {
+    program: Program;
+    entries: TranspileEntry[];
+}
 export interface OnGetCodeActionsEvent {
     program: Program;
     file: BscFile;
@@ -198,6 +232,86 @@ export interface OnGetCodeActionsEvent {
     diagnostics: BsDiagnostic[];
     codeActions: CodeAction[];
 }
+export interface AfterScopeCreateEvent {
+    program: Program;
+    scope: Scope;
+}
+export interface BeforeScopeDisposeEvent {
+    program: Program;
+    scope: Scope;
+}
+export interface AfterScopeDisposeEvent {
+    program: Program;
+    scope: Scope;
+}
+export interface BeforeScopeValidateEvent {
+    program: Program;
+    scope: Scope;
+}
+export interface AfterScopeValidateEvent {
+    program: Program;
+    scope: Scope;
+}
+export interface OnScopeGetCodeActionsEvent {
+    program: Program;
+    scope: Scope;
+    file: BscFile;
+    range: Range;
+    /**
+     * A filtered list of diagnostics whose lines touch the lines of the given range
+     */
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
+}
+export interface BeforeFileParseEvent {
+    program: Program;
+    srcPath: string;
+    source: string;
+}
+export interface AfterFileParseEvent {
+    program: Program;
+    file: BscFile;
+}
+export interface BeforeFileValidateEvent {
+    program: Program;
+    file: BscFile;
+}
+export interface AfterFileValidateEvent {
+    program: Program;
+    file: BscFile;
+}
+export interface BeforeFileTranspileEvent {
+    program: Program;
+    file: BscFile;
+    outputPath: string;
+}
+export interface AfterFileTranspileEvent {
+    program: Program;
+    file: BscFile;
+    outputPath: string;
+}
+export interface BeforeFileDisposeEvent {
+    program: Program;
+    file: BscFile;
+}
+export interface AfterFileDisposeEvent {
+    program: Program;
+    file: BscFile;
+}
+export interface OnFileGetCodeActionsEvent {
+    program: Program;
+    file: BscFile;
+    range: Range;
+    /**
+     * A filtered list of diagnostics whose lines touch the lines of the given range
+     */
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
+}
+export interface TranspileEntry {
+    file: BscFile;
+    outputPath: string;
+}
 export interface OnGetSemanticTokensEvent {
     program: Program;
     file: BscFile;
@@ -216,11 +330,13 @@ export interface TypedefProvider {
     getTypedef(state: TranspileState): Array<SourceNode | string>;
 }
 export declare type TranspileResult = Array<(string | SourceNode)>;
-export declare type FileResolver = (pathAbsolute: string) => string | undefined | Thenable<string | undefined> | void;
+/**
+ * @param srcPath The absolute path to the source file on disk
+ */
+export declare type FileResolver = (srcPath: string) => string | undefined | Thenable<string | undefined> | void;
 export interface ExpressionInfo {
     expressions: Expression[];
     varExpressions: Expression[];
     uniqueVarNames: string[];
 }
 export declare type DiagnosticCode = number | string;
-export {};

package/dist/parser/BrsTranspileState.d.ts

@@ -1,5 +1,7 @@
 import type { Range } from 'vscode-languageserver';
 import type { BrsFile } from '../files/BrsFile';
+import type { Scope } from '../Scope';
+import type { TypeContext } from '../types/BscType';
 import type { ClassStatement } from './Statement';
 import { TranspileState } from './TranspileState';
 export declare class BrsTranspileState extends TranspileState {
@@ -20,4 +22,9 @@ export declare class BrsTranspileState extends TranspileState {
      * Used by ClassMethodStatements to determine information about their enclosing class
      */
     classStatement?: ClassStatement;
+    /**
+     * Transpilation of LazyTypes needs access to the scope - just pick the first
+     */
+    get scope(): Scope;
+    get typeContext(): TypeContext;
 }

package/dist/parser/BrsTranspileState.js

@@ -4,7 +4,7 @@ exports.BrsTranspileState = void 0;
 const TranspileState_1 = require("./TranspileState");
 class BrsTranspileState extends TranspileState_1.TranspileState {
     constructor(file) {
-        super(file.pathAbsolute, file.program.options);
+        super(file.srcPath, file.program.options);
         this.file = file;
         /**
          * the tree of parents, with the first index being direct parent, and the last index being the furthest removed ancestor.
@@ -13,6 +13,15 @@ class BrsTranspileState extends TranspileState_1.TranspileState {
         this.lineage = [];
         this.bslibPrefix = this.file.program.bslibPrefix;
     }
+    /**
+     * Transpilation of LazyTypes needs access to the scope - just pick the first
+     */
+    get scope() {
+        return this.file.program.getScopesForFile(this.file)[0];
+    }
+    get typeContext() {
+        return { file: this.file, scope: this.scope };
+    }
 }
 exports.BrsTranspileState = BrsTranspileState;
 //# sourceMappingURL=BrsTranspileState.js.map

package/dist/parser/BrsTranspileState.js.map

@@ -1 +1 @@
-{"version":3,"file":"BrsTranspileState.js","sourceRoot":"","sources":["../../src/parser/BrsTranspileState.ts"],"names":[],"mappings":";;;AAGA,qDAAkD;AAElD,MAAa,iBAAkB,SAAQ,+BAAc;IACjD,YACW,IAAa;QAEpB,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAFxC,SAAI,GAAJ,IAAI,CAAS;QAWxB;;;WAGG;QACH,YAAO,GAAG,EAER,CAAC;QAdC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IACrD,CAAC;CAmBJ;AAzBD,8CAyBC"}
+{"version":3,"file":"BrsTranspileState.js","sourceRoot":"","sources":["../../src/parser/BrsTranspileState.ts"],"names":[],"mappings":";;;AAKA,qDAAkD;AAElD,MAAa,iBAAkB,SAAQ,+BAAc;IACjD,YACW,IAAa;QAEpB,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAFnC,SAAI,GAAJ,IAAI,CAAS;QAWxB;;;WAGG;QACH,YAAO,GAAG,EAER,CAAC;QAdC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IACrD,CAAC;IAoBD;;OAEG;IACH,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,IAAW,WAAW;QAClB,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IAClD,CAAC;CACJ;AApCD,8CAoCC"}

package/dist/parser/Expression.d.ts

@@ -1,12 +1,13 @@
 import type { Token, Identifier } from '../lexer';
-import type { Block, CommentStatement, FunctionStatement } from './Statement';
+import type { Block, CommentStatement, FunctionStatement, LabelStatement } from './Statement';
 import type { Range } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
 import { ParseMode } from './Parser';
 import type { WalkOptions, WalkVisitor } from '../astUtils/visitors';
 import { InternalWalkMode } from '../astUtils/visitors';
 import type { TranspileResult, TypedefProvider } from '../interfaces';
-import type { BscType } from '../types/BscType';
+import type { BscType, SymbolContainer } from '../types/BscType';
+import { SymbolTable } from '../SymbolTable';
 import { FunctionType } from '../types/FunctionType';
 export declare type ExpressionVisitor = (expression: Expression, parent: Expression) => void;
 /** A BrightScript expression */
@@ -64,11 +65,14 @@ export declare class FunctionExpression extends Expression implements TypedefPro
      */
     readonly parentFunction?: FunctionExpression;
     readonly namespaceName?: NamespacedVariableNameExpression;
+    readonly parentSymbolTable?: SymbolTable;
     constructor(parameters: FunctionParameterExpression[], body: Block, functionType: Token | null, end: Token, leftParen: Token, rightParen: Token, asToken?: Token, returnTypeToken?: Token, 
     /**
      * If this function is enclosed within another function, this will reference that parent function
      */
-    parentFunction?: FunctionExpression, namespaceName?: NamespacedVariableNameExpression);
+    parentFunction?: FunctionExpression, namespaceName?: NamespacedVariableNameExpression, parentSymbolTable?: SymbolTable);
+    readonly symbolTable: SymbolTable;
+    labelStatements: LabelStatement[];
     /**
      * The type this function returns
      */
@@ -98,15 +102,17 @@ export declare class FunctionExpression extends Expression implements TypedefPro
 }
 export declare class FunctionParameterExpression extends Expression {
     name: Identifier;
-    typeToken?: Token;
+    type: BscType;
+    equalsToken?: Token;
     defaultValue?: Expression;
     asToken?: Token;
+    typeToken?: Token;
     readonly namespaceName?: NamespacedVariableNameExpression;
-    constructor(name: Identifier, typeToken?: Token, defaultValue?: Expression, asToken?: Token, namespaceName?: NamespacedVariableNameExpression);
-    type: BscType;
+    constructor(name: Identifier, type: BscType, equalsToken?: Token, defaultValue?: Expression, asToken?: Token, typeToken?: Token, namespaceName?: NamespacedVariableNameExpression);
     get range(): Range;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
+    get isOptional(): boolean;
 }
 export declare class NamespacedVariableNameExpression extends Expression {
     readonly expression: DottedGetExpression | VariableExpression;
@@ -114,7 +120,7 @@ export declare class NamespacedVariableNameExpression extends Expression {
     range: Range;
     transpile(state: BrsTranspileState): import("source-map").SourceNode[];
     getNameParts(): string[];
-    getName(parseMode: ParseMode): string;
+    getName(parseMode?: ParseMode): string;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class DottedGetExpression extends Expression {
@@ -200,20 +206,25 @@ export declare class AAMemberExpression extends Expression {
     colonToken: Token;
     /** The expression evaluated to determine the member's initial value. */
     value: Expression;
+    type: BscType;
     constructor(keyToken: Token, colonToken: Token, 
     /** The expression evaluated to determine the member's initial value. */
-    value: Expression);
+    value: Expression, type: BscType);
     range: Range;
     commaToken?: Token;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
-export declare class AALiteralExpression extends Expression {
+export declare class AALiteralExpression extends Expression implements SymbolContainer {
     readonly elements: Array<AAMemberExpression | CommentStatement>;
     readonly open: Token;
     readonly close: Token;
-    constructor(elements: Array<AAMemberExpression | CommentStatement>, open: Token, close: Token);
+    readonly functionExpression: FunctionExpression;
+    constructor(elements: Array<AAMemberExpression | CommentStatement>, open: Token, close: Token, functionExpression: FunctionExpression);
+    readonly symbolTable: SymbolTable;
+    readonly memberTable: SymbolTable;
     readonly range: Range;
+    buildSymbolTable(): void;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -226,8 +237,8 @@ export declare class UnaryExpression extends Expression {
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class VariableExpression extends Expression {
-    readonly name: Identifier;
-    readonly namespaceName: NamespacedVariableNameExpression;
+    name: Identifier;
+    namespaceName: NamespacedVariableNameExpression;
     constructor(name: Identifier, namespaceName: NamespacedVariableNameExpression);
     readonly range: Range;
     isCalled: boolean;

package/dist/parser/Expression.js

@@ -9,7 +9,9 @@ const visitors_1 = require("../astUtils/visitors");
 const reflection_1 = require("../astUtils/reflection");
 const VoidType_1 = require("../types/VoidType");
 const DynamicType_1 = require("../types/DynamicType");
+const SymbolTable_1 = require("../SymbolTable");
 const FunctionType_1 = require("../types/FunctionType");
+const ObjectType_1 = require("../types/ObjectType");
 /** A BrightScript expression */
 class Expression {
     constructor() {
@@ -90,13 +92,13 @@ class CallExpression extends Expression {
     }
 }
 exports.CallExpression = CallExpression;
-CallExpression.MaximumArguments = 32;
+CallExpression.MaximumArguments = util_1.MAX_PARAM_COUNT;
 class FunctionExpression extends Expression {
     constructor(parameters, body, functionType, end, leftParen, rightParen, asToken, returnTypeToken, 
     /**
      * If this function is enclosed within another function, this will reference that parent function
      */
-    parentFunction, namespaceName) {
+    parentFunction, namespaceName, parentSymbolTable) {
         super();
         this.parameters = parameters;
         this.body = body;
@@ -108,6 +110,8 @@ class FunctionExpression extends Expression {
         this.returnTypeToken = returnTypeToken;
         this.parentFunction = parentFunction;
         this.namespaceName = namespaceName;
+        this.parentSymbolTable = parentSymbolTable;
+        this.labelStatements = [];
         /**
          * The list of function calls that are declared within this function scope. This excludes CallExpressions
          * declared in child functions
@@ -118,7 +122,7 @@ class FunctionExpression extends Expression {
          */
         this.childFunctionExpressions = [];
         if (this.returnTypeToken) {
-            this.returnType = util_1.default.tokenToBscType(this.returnTypeToken);
+            this.returnType = util_1.default.tokenToBscType(this.returnTypeToken, true, namespaceName);
         }
         else if (this.functionType.text.toLowerCase() === 'sub') {
             this.returnType = new VoidType_1.VoidType();
@@ -126,6 +130,10 @@ class FunctionExpression extends Expression {
         else {
             this.returnType = new DynamicType_1.DynamicType();
         }
+        this.symbolTable = new SymbolTable_1.SymbolTable(parentSymbolTable);
+        for (let param of parameters) {
+            this.symbolTable.addSymbol(param.name.text, param.name.range, param.type);
+        }
     }
     /**
      * The range of the function, starting at the 'f' in function or 's' in sub (or the open paren if the keyword is missing),
@@ -163,7 +171,7 @@ class FunctionExpression extends Expression {
             //as
             state.transpileToken(this.asToken), ' ', 
             //return type
-            state.sourceNode(this.returnTypeToken, this.returnType.toTypeString()));
+            state.sourceNode(this.returnTypeToken, this.returnType.toTypeString(state.typeContext)));
         }
         if (includeBody) {
             state.lineage.unshift(this);
@@ -194,26 +202,22 @@ class FunctionExpression extends Expression {
         let functionType = new FunctionType_1.FunctionType(this.returnType);
         functionType.isSub = this.functionType.text === 'sub';
         for (let param of this.parameters) {
-            functionType.addParameter(param.name.text, param.type, !!param.typeToken);
+            functionType.addParameter(param.name.text, param.type, param.isOptional);
         }
         return functionType;
     }
 }
 exports.FunctionExpression = FunctionExpression;
 class FunctionParameterExpression extends Expression {
-    constructor(name, typeToken, defaultValue, asToken, namespaceName) {
+    constructor(name, type, equalsToken, defaultValue, asToken, typeToken, namespaceName) {
         super();
         this.name = name;
-        this.typeToken = typeToken;
+        this.type = type;
+        this.equalsToken = equalsToken;
         this.defaultValue = defaultValue;
         this.asToken = asToken;
+        this.typeToken = typeToken;
         this.namespaceName = namespaceName;
-        if (typeToken) {
-            this.type = util_1.default.tokenToBscType(typeToken);
-        }
-        else {
-            this.type = new DynamicType_1.DynamicType();
-        }
     }
     get range() {
         return {
@@ -236,7 +240,7 @@ class FunctionParameterExpression extends Expression {
             result.push(' ');
             result.push(state.transpileToken(this.asToken));
             result.push(' ');
-            result.push(state.sourceNode(this.typeToken, this.type.toTypeString()));
+            result.push(state.sourceNode(this.typeToken, this.type.toTypeString(state.typeContext)));
         }
         return result;
     }
@@ -246,6 +250,9 @@ class FunctionParameterExpression extends Expression {
             (0, visitors_1.walk)(this, 'defaultValue', visitor, options);
         }
     }
+    get isOptional() {
+        return !!this.defaultValue;
+    }
 }
 exports.FunctionParameterExpression = FunctionParameterExpression;
 class NamespacedVariableNameExpression extends Expression {
@@ -276,7 +283,7 @@ class NamespacedVariableNameExpression extends Expression {
         }
         return parts;
     }
-    getName(parseMode) {
+    getName(parseMode = Parser_1.ParseMode.BrighterScript) {
         if (parseMode === Parser_1.ParseMode.BrighterScript) {
             return this.getNameParts().join('.');
         }
@@ -505,11 +512,12 @@ exports.ArrayLiteralExpression = ArrayLiteralExpression;
 class AAMemberExpression extends Expression {
     constructor(keyToken, colonToken, 
     /** The expression evaluated to determine the member's initial value. */
-    value) {
+    value, type) {
         super();
         this.keyToken = keyToken;
         this.colonToken = colonToken;
         this.value = value;
+        this.type = type;
         this.range = util_1.default.createRangeFromPositions(keyToken.range.start, this.value.range.end);
     }
     transpile(state) {
@@ -522,12 +530,25 @@ class AAMemberExpression extends Expression {
 }
 exports.AAMemberExpression = AAMemberExpression;
 class AALiteralExpression extends Expression {
-    constructor(elements, open, close) {
+    constructor(elements, open, close, functionExpression) {
         super();
         this.elements = elements;
         this.open = open;
         this.close = close;
+        this.functionExpression = functionExpression;
+        this.symbolTable = new SymbolTable_1.SymbolTable();
+        this.memberTable = new SymbolTable_1.SymbolTable();
         this.range = util_1.default.createRangeFromPositions(this.open.range.start, this.close.range.end);
+        this.buildSymbolTable();
+    }
+    buildSymbolTable() {
+        this.symbolTable.clear();
+        this.symbolTable.addSymbol('m', { start: this.open.range.start, end: this.close.range.end }, new ObjectType_1.ObjectType(this.memberTable));
+        for (const element of this.elements) {
+            if ((0, reflection_1.isAAMemberExpression)(element)) {
+                this.memberTable.addSymbol(element.keyToken.text, element.keyToken.range, (0, Parser_1.getBscTypeFromExpression)(element.value, this.functionExpression));
+            }
+        }
     }
     transpile(state) {
         let result = [];
@@ -667,15 +688,15 @@ class SourceLiteralExpression extends Expression {
         this.range = token.range;
     }
     getFunctionName(state, parseMode) {
-        let func = state.file.getFunctionScopeAtPosition(this.token.range.start).func;
+        let functionExpression = state.file.getFunctionExpressionAtPosition(this.token.range.start);
         let nameParts = [];
-        while (func.parentFunction) {
-            let index = func.parentFunction.childFunctionExpressions.indexOf(func);
+        while (functionExpression.parentFunction) {
+            let index = functionExpression.parentFunction.childFunctionExpressions.indexOf(functionExpression);
             nameParts.unshift(`anon${index}`);
-            func = func.parentFunction;
+            functionExpression = functionExpression.parentFunction;
         }
         //get the index of this function in its parent
-        nameParts.unshift(func.functionStatement.getName(parseMode));
+        nameParts.unshift(functionExpression.functionStatement.getName(parseMode));
         return nameParts.join('$');
     }
     transpile(state) {
@@ -699,16 +720,10 @@ class SourceLiteralExpression extends Expression {
                 text = `"${locationUrl.substring(0, 4)}" + "${locationUrl.substring(4)}:${this.token.range.start.line + 1}"`;
                 break;
             case lexer_1.TokenKind.PkgPathLiteral:
-                let pkgPath1 = `pkg:/${state.file.pkgPath}`
-                    .replace(/\\/g, '/')
-                    .replace(/\.bs$/i, '.brs');
-                text = `"${pkgPath1}"`;
+                text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}"`;
                 break;
             case lexer_1.TokenKind.PkgLocationLiteral:
-                let pkgPath2 = `pkg:/${state.file.pkgPath}`
-                    .replace(/\\/g, '/')
-                    .replace(/\.bs$/i, '.brs');
-                text = `"${pkgPath2}:" + str(LINE_NUM)`;
+                text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}:" + str(LINE_NUM)`;
                 break;
             case lexer_1.TokenKind.LineNumLiteral:
             default: