brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/SymbolTable.js

@@ -1,130 +1,641 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SymbolTable = void 0;
-const DynamicType_1 = require("./types/DynamicType");
-const UninitializedType_1 = require("./types/UninitializedType");
+const CacheVerifier_1 = require("./CacheVerifier");
+const helpers_1 = require("./types/helpers");
+const reflection_1 = require("./astUtils/reflection");
 /**
  * Stores the types associated with variables and functions in the Brighterscript code
  * Can be part of a hierarchy, so lookups can reference parent scopes
  */
 class SymbolTable {
-    constructor(parent) {
-        this.parent = parent;
+    constructor(name, parentProvider) {
+        this.name = name;
         /**
          * The map of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
          * Indexed by lower symbol name
          */
         this.symbolMap = new Map();
+        this.parentProviders = [];
+        this.siblings = new Set();
+        /**
+         * Does the order of symbols in this symbol table matter?
+         * Normally, this would only be for symbol tables referencing symbols declared within a function
+         */
+        this.isOrdered = false;
+        this.pocketTables = new Array();
+        this.isPocketTable = false;
+        this.complementsTables = new Set();
+        this.cachedCircularReferenceCheck = null;
+        this.resetTypeCache();
+        if (parentProvider) {
+            this.pushParentProvider(parentProvider);
+        }
     }
     /**
-     * Get list of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
+     * Push a function that will provide a parent SymbolTable when requested
      */
-    get ownSymbols() {
-        return [].concat(...this.symbolMap.values());
+    pushParentProvider(provider) {
+        this.cachedCircularReferenceCheck = null;
+        this.parentProviders.push(provider);
+        return () => {
+            this.popParentProvider();
+        };
     }
     /**
-     * Sets the parent table for lookups
-     *
-     * @param [parent]
+     * Pop the current parentProvider
+     */
+    popParentProvider() {
+        this.cachedCircularReferenceCheck = null;
+        this.parentProviders.pop();
+    }
+    /**
+     * The parent SymbolTable (if there is one)
+     */
+    get parent() {
+        var _a, _b;
+        return (_b = (_a = this.parentProviders)[this.parentProviders.length - 1]) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Add a sibling symbol table (which will be inspected first before walking upward to the parent
+     */
+    addSibling(sibling) {
+        this.siblings.add(sibling);
+        return () => {
+            this.siblings.delete(sibling);
+        };
+    }
+    /**
+     * Remove a sibling symbol table
+     */
+    removeSibling(sibling) {
+        this.siblings.delete(sibling);
+    }
+    addPocketTable(pocketTable) {
+        pocketTable.table.isPocketTable = true;
+        this.pocketTables.push(pocketTable);
+        return () => {
+            const index = this.pocketTables.findIndex(pt => pt === pocketTable);
+            if (index >= 0) {
+                this.pocketTables.splice(index, 1);
+            }
+        };
+    }
+    getCurrentPocketTableDepth() {
+        let depth = 0;
+        let currentTable = this;
+        while (currentTable.isPocketTable) {
+            depth++;
+            currentTable = currentTable.parent;
+        }
+        return depth;
+    }
+    getStatementIndexOfPocketTable(symbolTable) {
+        var _a, _b;
+        return (_b = (_a = this.pocketTables.find(pt => pt.table === symbolTable)) === null || _a === void 0 ? void 0 : _a.index) !== null && _b !== void 0 ? _b : -1;
+    }
+    /**
+     * This table complements this other table
+     * Eg. This is an else branch, it complements a then branch
      */
-    setParent(parent) {
-        this.parent = parent;
+    complementOtherTable(otherTable) {
+        this.complementsTables.add(otherTable);
+    }
+    clearSymbols() {
+        this.symbolMap.clear();
     }
     /**
      * Checks if the symbol table contains the given symbol by name
      * If the identifier is not in this table, it will check the parent
      *
      * @param name the name to lookup
-     * @param searchParent should we look to our parent if we don't have the symbol?
+     * @param bitFlags flags to match (See SymbolTypeFlags)
      * @returns true if this symbol is in the symbol table
      */
-    hasSymbol(name, searchParent = true) {
-        var _a;
-        const key = name.toLowerCase();
-        let result = this.symbolMap.has(key);
-        if (!result && searchParent) {
-            result = !!((_a = this.parent) === null || _a === void 0 ? void 0 : _a.hasSymbol(key));
-        }
-        return result;
+    hasSymbol(name, bitFlags) {
+        let currentTable = this;
+        const key = name === null || name === void 0 ? void 0 : name.toLowerCase();
+        let result;
+        do {
+            // look in our map first
+            if ((result = currentTable.symbolMap.get(key))) {
+                // eslint-disable-next-line no-bitwise
+                if (result.find(symbol => symbol.flags & bitFlags)) {
+                    return true;
+                }
+            }
+            //look in pocket tables
+            for (let pocket of this.pocketTables) {
+                if ((result = pocket.table.symbolMap.get(key))) {
+                    // eslint-disable-next-line no-bitwise
+                    if (result.find(symbol => symbol.flags & bitFlags)) {
+                        return true;
+                    }
+                }
+            }
+            if ((result = currentTable.symbolMap.get(key))) {
+                // eslint-disable-next-line no-bitwise
+                if (result.find(symbol => symbol.flags & bitFlags)) {
+                    return true;
+                }
+            }
+            //look through any sibling maps next
+            for (let sibling of currentTable.siblings) {
+                if ((result = sibling.symbolMap.get(key))) {
+                    // eslint-disable-next-line no-bitwise
+                    if (result.find(symbol => symbol.flags & bitFlags)) {
+                        return true;
+                    }
+                }
+            }
+            currentTable = currentTable.parent;
+        } while (currentTable);
+        return false;
     }
     /**
      * Gets the name/type pair for a given named variable or function name
      * If the identifier is not in this table, it will check the parent
      *
      * @param  name the name to lookup
-     * @param searchParent should we look to our parent if we don't have the symbol?
+     * @param bitFlags flags to match
      * @returns An array of BscSymbols - one for each time this symbol had a type implicitly defined
      */
-    getSymbol(name, searchParent = true) {
+    getSymbol(name, bitFlags, additionalOptions = {}) {
+        var _a, _b, _c, _d;
+        let currentTable = this;
+        let previousTable;
+        const key = name === null || name === void 0 ? void 0 : name.toLowerCase();
+        let result;
+        let memberOfAncestor = false;
+        //only clone the symbol when we actually need to attach the `memberOfAncestor` flag
+        //(i.e., we walked up to a parent table). Returning the original reference for own-table
+        //hits keeps identity stable, which downstream consumers (and one symbol-table spec)
+        //rely on.
+        const addAncestorInfo = (symbol) => (memberOfAncestor
+            ? Object.assign(Object.assign({}, symbol), { data: Object.assign(Object.assign({}, symbol.data), { memberOfAncestor: true }) }) : symbol);
+        let maxStatementIndex = Number.isInteger(additionalOptions === null || additionalOptions === void 0 ? void 0 : additionalOptions.maxStatementIndex) ? additionalOptions.maxStatementIndex : Number.MAX_SAFE_INTEGER;
+        do {
+            if (previousTable) {
+                maxStatementIndex = currentTable.isOrdered ? currentTable.getStatementIndexOfPocketTable(previousTable) : Number.MAX_SAFE_INTEGER;
+            }
+            // look in our map first
+            let currentResults = currentTable.symbolMap.get(key);
+            if (currentResults) {
+                // eslint-disable-next-line no-bitwise
+                currentResults = currentResults.filter(symbol => symbol.flags & bitFlags)
+                    .filter(this.getSymbolLookupFilter(currentTable, maxStatementIndex, memberOfAncestor));
+            }
+            let precedingAssignmentIndex = -1;
+            if ((currentResults === null || currentResults === void 0 ? void 0 : currentResults.length) > 0 && currentTable.isOrdered && maxStatementIndex >= 0) {
+                this.sortSymbolsByAssignmentOrderInPlace(currentResults);
+                const lastResult = currentResults[currentResults.length - 1];
+                currentResults = [lastResult];
+                precedingAssignmentIndex = (_c = (_b = (_a = lastResult.data) === null || _a === void 0 ? void 0 : _a.definingNode) === null || _b === void 0 ? void 0 : _b.statementIndex) !== null && _c !== void 0 ? _c : -1;
+            }
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0) {
+                // we already have results from a deeper pocketTable
+                if ((currentResults === null || currentResults === void 0 ? void 0 : currentResults.length) > 0) {
+                    result.push(...currentResults);
+                }
+            }
+            else if ((currentResults === null || currentResults === void 0 ? void 0 : currentResults.length) > 0) {
+                result = currentResults;
+            }
+            let depth = (_d = additionalOptions === null || additionalOptions === void 0 ? void 0 : additionalOptions.depth) !== null && _d !== void 0 ? _d : currentTable.getCurrentPocketTableDepth();
+            const augmentationResult = currentTable.augmentSymbolResultsWithPocketTableResults(name, bitFlags, result, Object.assign(Object.assign({}, additionalOptions), { depth: depth, maxStatementIndex: maxStatementIndex, precedingAssignmentIndex: precedingAssignmentIndex }));
+            result = augmentationResult.symbols;
+            const needCheckParent = (!augmentationResult.exhaustive && depth > 0);
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && !needCheckParent) {
+                result = result.map(addAncestorInfo);
+                break;
+            }
+            if (additionalOptions === null || additionalOptions === void 0 ? void 0 : additionalOptions.ignoreParentsAndSiblings) {
+                break;
+            }
+            //look through any sibling maps next
+            for (let sibling of currentTable.siblings) {
+                result = sibling.getSymbol(key, bitFlags);
+                if ((result === null || result === void 0 ? void 0 : result.length) > 0) {
+                    return result.map(addAncestorInfo);
+                }
+            }
+            previousTable = currentTable;
+            currentTable = currentTable.parent;
+            memberOfAncestor = true;
+        } while (currentTable);
+        return result;
+    }
+    augmentSymbolResultsWithPocketTableResults(name, bitFlags, result, additionalOptions = {}) {
+        var _a, _b;
+        let pocketTableResults = [];
+        let pocketTablesWeFoundSomethingIn = this.getSymbolDataFromPocketTables(name, bitFlags, additionalOptions);
+        let pocketTablesAreExhaustive = false;
+        const depth = (_a = additionalOptions.depth) !== null && _a !== void 0 ? _a : 0;
+        for (let i = 0; i < pocketTablesWeFoundSomethingIn.length; i++) {
+            let tableData = pocketTablesWeFoundSomethingIn[i];
+            let pocketTable = tableData.pocketTable;
+            pocketTableResults.push(...tableData.results);
+            if (pocketTable.willAlwaysBeExecuted) {
+                // remove all results before this
+                pocketTableResults = [...tableData.results];
+                pocketTablesAreExhaustive = true;
+            }
+            if (i === 0) {
+                continue;
+            }
+            if (((_b = pocketTable.table.complementsTables) === null || _b === void 0 ? void 0 : _b.size) > 0) {
+                let tableSatisfied = true;
+                let allPossibleSatisfiedResults = [];
+                // need to check if all tables this complements are satisfied
+                for (const otherTable of pocketTable.table.complementsTables) {
+                    const foundTableData = pocketTablesWeFoundSomethingIn.find((ptd => {
+                        return otherTable === ptd.pocketTable.table;
+                    }));
+                    if (foundTableData) {
+                        allPossibleSatisfiedResults.push(...foundTableData.results);
+                    }
+                    else {
+                        tableSatisfied = false;
+                        break;
+                    }
+                }
+                if (tableSatisfied) {
+                    // remove all results before this
+                    pocketTableResults = [...allPossibleSatisfiedResults, ...tableData.results];
+                    pocketTablesAreExhaustive = true;
+                }
+            }
+        }
+        if (pocketTablesAreExhaustive) {
+            result = pocketTableResults;
+        }
+        else {
+            // we need to take into account the types before the pocket tables
+            if (!result) {
+                // there was no result before the pocket tables
+                if (pocketTableResults.length > 0) {
+                    if (depth === 0) {
+                        // we got pocket tables results, and this is the top recursion
+                        // add uninitialized
+                        result = [{ name: name, type: SymbolTable.uninitializedTypeFactory(), data: {}, flags: bitFlags }, ...pocketTableResults];
+                    }
+                    else {
+                        //just return pocket table results:
+                        result = pocketTableResults;
+                    }
+                }
+                else {
+                    // result should be undefined
+                }
+            }
+            else {
+                // just add any pocket table results....
+                result.push(...pocketTableResults);
+            }
+        }
+        // Do the results cover all possible execution paths?
+        const areResultsExhaustive = pocketTablesAreExhaustive || pocketTablesWeFoundSomethingIn.length === 0;
+        return { symbols: result, exhaustive: areResultsExhaustive };
+    }
+    getSymbolDataFromPocketTables(name, bitFlags, additionalOptions = {}) {
         var _a;
-        const key = name.toLowerCase();
-        let result = this.symbolMap.get(key);
-        if (!result && searchParent) {
-            result = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbol(key);
+        const possiblePocketTables = this.getPossiblePocketTables({ statementIndex: additionalOptions.maxStatementIndex }, additionalOptions.precedingAssignmentIndex);
+        const depth = (_a = additionalOptions.depth) !== null && _a !== void 0 ? _a : 0;
+        const pocketTablesWeFoundSomethingIn = new Array();
+        for (const pocketTable of possiblePocketTables) {
+            const pocketTableTypes = pocketTable.table.getSymbol(name, bitFlags, {
+                ignoreParentsAndSiblings: true,
+                maxStatementIndex: Number.MAX_SAFE_INTEGER,
+                depth: depth + 1
+            });
+            if ((pocketTableTypes === null || pocketTableTypes === void 0 ? void 0 : pocketTableTypes.length) > 0) {
+                if (pocketTable.table.isOrdered) {
+                    const lastResult = pocketTableTypes[pocketTableTypes.length - 1];
+                    pocketTablesWeFoundSomethingIn.push({ pocketTable: pocketTable, results: [lastResult] });
+                }
+                else {
+                    pocketTablesWeFoundSomethingIn.push({ pocketTable: pocketTable, results: pocketTableTypes });
+                }
+            }
         }
-        return result;
+        return pocketTablesWeFoundSomethingIn;
     }
     /**
      * Adds a new symbol to the table
-     * @param name
-     * @param  type
      */
-    addSymbol(name, range, type) {
-        const key = name.toLowerCase();
+    addSymbol(name, data, type, bitFlags) {
+        var _a;
+        if (!name) {
+            return;
+        }
+        const key = name === null || name === void 0 ? void 0 : name.toLowerCase();
         if (!this.symbolMap.has(key)) {
             this.symbolMap.set(key, []);
         }
-        this.symbolMap.get(key).push({
+        (_a = this.symbolMap.get(key)) === null || _a === void 0 ? void 0 : _a.push({
             name: name,
-            range: range,
-            type: type
+            data: data,
+            type: type,
+            flags: bitFlags
         });
     }
     /**
-     * Gets the type for a symbol
-     * @param name the name of the symbol to get the type for
-     * @param searchParent should we look to our parent if we don't have the symbol?
-     * @returns The type, if found. If the type has ever changed, return DynamicType. If not found, returns UninitializedType
+     * Removes a new symbol from the table
      */
-    getSymbolType(name, searchParent = true) {
-        var _a, _b;
+    removeSymbol(name) {
         const key = name.toLowerCase();
-        const symbols = this.symbolMap.get(key);
-        if ((symbols === null || symbols === void 0 ? void 0 : symbols.length) > 1) {
-            //Check if each time it was set, it was set to the same type
-            // TODO handle union types
-            let sameImpliedType = true;
-            let impliedType = symbols[0].type;
-            for (const symbol of symbols) {
-                sameImpliedType = (impliedType.equals(symbol.type));
-                if (!sameImpliedType) {
-                    break;
+        if (!this.symbolMap.has(key)) {
+            this.symbolMap.set(key, []);
+        }
+        this.symbolMap.delete(key);
+    }
+    getSymbolTypes(name, options, sortByStatementIndex = false) {
+        const symbolArray = this.getSymbol(name, options.flags, {
+            ignoreParentsAndSiblings: options.ignoreParentTables,
+            maxStatementIndex: Number.isInteger(options.statementIndex) ? options.statementIndex : -1
+        });
+        if (!symbolArray) {
+            return undefined;
+        }
+        let symbols = symbolArray === null || symbolArray === void 0 ? void 0 : symbolArray.map(symbol => ({ type: symbol.type, data: symbol.data, flags: symbol.flags }));
+        if (sortByStatementIndex) {
+            this.sortSymbolsByAssignmentOrderInPlace(symbols);
+        }
+        return symbols;
+    }
+    getSymbolType(name, options) {
+        var _a, _b, _c;
+        const cacheEntry = options.ignoreCacheForRetrieval ? undefined : this.getCachedType(name, options);
+        let resolvedType = cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.type;
+        let doSetCache = !resolvedType;
+        const originalIsReferenceType = (0, reflection_1.isAnyReferenceType)(resolvedType);
+        let data = (cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.data) || {};
+        let foundFlags = cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.flags;
+        if (!resolvedType || originalIsReferenceType) {
+            let symbolTypes;
+            symbolTypes = this.getSymbolTypes(name, Object.assign(Object.assign({}, options), { statementIndex: options.statementIndex }));
+            data = (_a = symbolTypes === null || symbolTypes === void 0 ? void 0 : symbolTypes[0]) === null || _a === void 0 ? void 0 : _a.data;
+            foundFlags = (_b = symbolTypes === null || symbolTypes === void 0 ? void 0 : symbolTypes[0]) === null || _b === void 0 ? void 0 : _b.flags;
+            resolvedType = (0, helpers_1.getUniqueType)(symbolTypes === null || symbolTypes === void 0 ? void 0 : symbolTypes.map(symbol => symbol.type), SymbolTable.unionTypeFactory);
+        }
+        if (!resolvedType && options.fullName && options.tableProvider) {
+            resolvedType = SymbolTable.referenceTypeFactory(name, options.fullName, options.flags, options.tableProvider);
+        }
+        const resolvedTypeIsReference = (0, reflection_1.isAnyReferenceType)(resolvedType);
+        const newNonReferenceType = originalIsReferenceType && !(0, reflection_1.isAnyReferenceType)(resolvedType) && resolvedType;
+        doSetCache = doSetCache && (options.onlyCacheResolvedTypes ? !resolvedTypeIsReference : true);
+        if (doSetCache || newNonReferenceType) {
+            this.setCachedType(name, { type: resolvedType, data: data, flags: foundFlags }, options);
+        }
+        (_c = options.data) !== null && _c !== void 0 ? _c : (options.data = {});
+        if (options.data) {
+            options.data.definingNode = data === null || data === void 0 ? void 0 : data.definingNode;
+            options.data.description = data === null || data === void 0 ? void 0 : data.description;
+            options.data.flags = foundFlags !== null && foundFlags !== void 0 ? foundFlags : options.flags;
+            options.data.memberOfAncestor = data === null || data === void 0 ? void 0 : data.memberOfAncestor;
+            options.data.doNotMerge = data === null || data === void 0 ? void 0 : data.doNotMerge;
+            options.data.isAlias = data === null || data === void 0 ? void 0 : data.isAlias;
+            options.data.isInstance = data === null || data === void 0 ? void 0 : data.isInstance;
+            options.data.isFromDocComment = data === null || data === void 0 ? void 0 : data.isFromDocComment;
+            options.data.isBuiltIn = data === null || data === void 0 ? void 0 : data.isBuiltIn;
+            options.data.isFromCallFunc = data === null || data === void 0 ? void 0 : data.isFromCallFunc;
+            options.data.isFromTypeStatement = data === null || data === void 0 ? void 0 : data.isFromTypeStatement;
+        }
+        return resolvedType;
+    }
+    isSymbolTypeInstance(name) {
+        const data = {};
+        this.getSymbolType(name, { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+        return data === null || data === void 0 ? void 0 : data.isInstance;
+    }
+    /**
+     * Adds all the symbols from another table to this one.
+     * Source symbols are shared by reference (not cloned) since BscSymbol is treated as immutable.
+     * The destination still owns its own array per key, so subsequent addSymbol calls on either
+     * table do not leak across.
+     */
+    mergeSymbolTable(symbolTable) {
+        for (const [key, sourceSymbols] of symbolTable.symbolMap) {
+            //skip symbols flagged `doNotMerge` (e.g. typecast/alias bindings) so they stay
+            //local to their declaring block instead of bleeding into sibling tables that
+            //share the same merge target (e.g. the per-namespace aggregate symbol table).
+            const symbolsToMerge = sourceSymbols.filter(symbol => { var _a; return !((_a = symbol.data) === null || _a === void 0 ? void 0 : _a.doNotMerge); });
+            if (symbolsToMerge.length === 0) {
+                continue;
+            }
+            let destSymbols = this.symbolMap.get(key);
+            if (!destSymbols) {
+                destSymbols = [];
+                this.symbolMap.set(key, destSymbols);
+            }
+            destSymbols.push(...symbolsToMerge);
+        }
+        for (let pocketTable of symbolTable.pocketTables) {
+            this.mergeSymbolTable(pocketTable.table);
+        }
+    }
+    mergeNamespaceSymbolTables(symbolTable) {
+        var _a;
+        const disposables = [];
+        for (let [_name, value] of symbolTable.symbolMap) {
+            const symbol = value[0];
+            if (symbol) {
+                if ((_a = symbol.data) === null || _a === void 0 ? void 0 : _a.doNotMerge) {
+                    continue;
+                }
+                const existingRuntimeType = this.getSymbolType(symbol.name, { flags: symbol.flags });
+                if ((0, reflection_1.isNamespaceType)(existingRuntimeType) && (0, reflection_1.isNamespaceType)(symbol.type)) {
+                    disposables.push(...existingRuntimeType.memberTable.mergeNamespaceSymbolTables(symbol.type.memberTable));
+                }
+                else {
+                    this.addSymbol(symbol.name, symbol.data, symbol.type, symbol.flags);
+                    disposables.push(() => this.removeSymbol(symbol.name));
                 }
             }
-            return sameImpliedType ? impliedType : new DynamicType_1.DynamicType();
         }
-        else if ((symbols === null || symbols === void 0 ? void 0 : symbols.length) === 1) {
-            return symbols[0].type;
+        for (let siblingTable of symbolTable.siblings) {
+            disposables.push(...this.mergeNamespaceSymbolTables(siblingTable));
+        }
+        return disposables;
+    }
+    /**
+     * Get list of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
+     */
+    getOwnSymbols(bitFlags) {
+        let symbols = [].concat(...this.symbolMap.values());
+        // eslint-disable-next-line no-bitwise
+        symbols = symbols.filter(symbol => symbol.flags & bitFlags);
+        return symbols;
+    }
+    hasCircularReferenceWithAncestor() {
+        if (this.cachedCircularReferenceCheck === false || this.cachedCircularReferenceCheck === true) {
+            return this.cachedCircularReferenceCheck;
         }
-        if (searchParent) {
-            return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolType(name)) !== null && _b !== void 0 ? _b : new UninitializedType_1.UninitializedType();
+        let foundCircReference = false;
+        let p = this.parent;
+        while (!foundCircReference && p) {
+            foundCircReference = p === this;
+            p = p.parent;
+        }
+        this.cachedCircularReferenceCheck = foundCircReference;
+        return foundCircReference;
+    }
+    /**
+     * Get list of all symbols declared in this SymbolTable (includes parent SymbolTable).
+     */
+    getAllSymbols(bitFlags) {
+        let symbols = [].concat(...this.symbolMap.values());
+        //look through any sibling maps next
+        for (let sibling of this.siblings) {
+            symbols = symbols.concat(sibling.getAllSymbols(bitFlags));
+        }
+        if (this.parent && !this.hasCircularReferenceWithAncestor()) {
+            symbols = symbols.concat(this.parent.getAllSymbols(bitFlags));
+        }
+        // eslint-disable-next-line no-bitwise
+        symbols = symbols.filter(symbol => symbol.flags & bitFlags);
+        //remove duplicate symbols
+        const symbolsMap = new Map();
+        for (const symbol of symbols) {
+            const lowerSymbolName = symbol.name.toLowerCase();
+            if (!symbolsMap.has(lowerSymbolName)) {
+                symbolsMap.set(lowerSymbolName, symbol);
+            }
+        }
+        return [...symbolsMap.values()];
+    }
+    resetTypeCache() {
+        var _a;
+        this.typeCache = [
+            undefined,
+            new Map(),
+            new Map(),
+            new Map() // SymbolTypeFlags.runtime & SymbolTypeFlags.typetime
+        ];
+        this.cacheToken = (_a = SymbolTable.cacheVerifier) === null || _a === void 0 ? void 0 : _a.getToken();
+    }
+    getCachedType(name, options) {
+        var _a, _b;
+        if (SymbolTable.cacheVerifier) {
+            if (!((_a = SymbolTable.cacheVerifier) === null || _a === void 0 ? void 0 : _a.checkToken(this.cacheToken))) {
+                // we have a bad token
+                this.resetTypeCache();
+                return;
+            }
         }
         else {
-            return new UninitializedType_1.UninitializedType();
+            // no cache verifier
+            return;
         }
+        const cacheKey = this.getCacheKey(name, options);
+        return (_b = this.typeCache[options.flags]) === null || _b === void 0 ? void 0 : _b.get(cacheKey);
+    }
+    setCachedType(name, cacheEntry, options) {
+        var _a, _b, _c;
+        if (!cacheEntry || !cacheEntry.type) {
+            return;
+        }
+        if (SymbolTable.cacheVerifier) {
+            if (!((_a = SymbolTable.cacheVerifier) === null || _a === void 0 ? void 0 : _a.checkToken(this.cacheToken))) {
+                // we have a bad token - remove all other caches
+                this.resetTypeCache();
+            }
+        }
+        else {
+            // no cache verifier
+            return;
+        }
+        const cacheKey = this.getCacheKey(name, options);
+        let existingCachedValue = (_b = this.typeCache[options.flags]) === null || _b === void 0 ? void 0 : _b.get(cacheKey);
+        if ((0, reflection_1.isReferenceType)(cacheEntry.type) && !(0, reflection_1.isReferenceType)(existingCachedValue)) {
+            // No need to overwrite a non-referenceType with a referenceType
+            return;
+        }
+        return (_c = this.typeCache[options.flags]) === null || _c === void 0 ? void 0 : _c.set(cacheKey, cacheEntry);
+    }
+    getCacheKey(name, options) {
+        var _a;
+        return this.isOrdered ? `${name.toLowerCase()}@${(_a = options.statementIndex) !== null && _a !== void 0 ? _a : '*'}` : `${name.toLowerCase()}`;
     }
     /**
-     * Adds all the symbols from another table to this one
-     * It will overwrite any existing symbols in this table
-     * @param symbolTable
+     * Serialize this SymbolTable to JSON (useful for debugging reasons)
      */
-    mergeSymbolTable(symbolTable) {
-        for (let [, value] of symbolTable.symbolMap) {
-            for (const symbol of value) {
-                this.addSymbol(symbol.name, symbol.range, symbol.type);
+    toJSON() {
+        var _a;
+        return {
+            name: this.name,
+            siblings: [...this.siblings].map(sibling => sibling.toJSON()),
+            parent: (_a = this.parent) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            symbols: [
+                ...new Set([...this.symbolMap.entries()].map(([key, symbols]) => {
+                    return symbols.map(x => {
+                        var _a;
+                        return { name: x.name, type: (_a = x.type) === null || _a === void 0 ? void 0 : _a.__identifier };
+                    });
+                }).flat().sort())
+            ]
+        };
+    }
+    sortSymbolsByAssignmentOrderInPlace(symbols) {
+        symbols.sort((a, b) => {
+            var _a, _b, _c, _d;
+            if (!Number.isInteger((_b = (_a = a.data) === null || _a === void 0 ? void 0 : _a.definingNode) === null || _b === void 0 ? void 0 : _b.statementIndex)) {
+                return -1;
+            }
+            if (!Number.isInteger((_d = (_c = b.data) === null || _c === void 0 ? void 0 : _c.definingNode) === null || _d === void 0 ? void 0 : _d.statementIndex)) {
+                return 1;
+            }
+            if (b.data.definingNode.statementIndex > a.data.definingNode.statementIndex) {
+                return -1;
             }
+            if (b.data.definingNode.statementIndex < a.data.definingNode.statementIndex) {
+                return 1;
+            }
+            return -1;
+        });
+        return symbols;
+    }
+    getPossiblePocketTables(options, precedingAssignmentIndex = -1) {
+        if (!this.isOrdered) {
+            return this.pocketTables;
         }
+        const pocketTablesBetweenAssignmentAndPosition = this.pocketTables.filter(pt => {
+            const isBeforePosition = options.statementIndex === 'end' ? true : options.statementIndex > pt.index;
+            let isAfterPrecedingAssignment = true;
+            if (Number.isInteger(precedingAssignmentIndex)) {
+                isAfterPrecedingAssignment = precedingAssignmentIndex < pt.index;
+            }
+            return isAfterPrecedingAssignment && isBeforePosition;
+        });
+        return pocketTablesBetweenAssignmentAndPosition;
+    }
+    getSymbolLookupFilter(currentTable, maxAllowedStatementIndex, memberOfAncestor) {
+        return (t) => {
+            var _a;
+            if (!currentTable.isOrdered) {
+                // order doesn't matter for current table
+                return true;
+            }
+            if (maxAllowedStatementIndex >= 0 && ((_a = t.data) === null || _a === void 0 ? void 0 : _a.definingNode)) {
+                if (memberOfAncestor) {
+                    // if we've already gone up a level, it's possible to have a variable assigned and used
+                    // in the same statement, eg. for loop
+                    return t.data.definingNode.statementIndex <= maxAllowedStatementIndex;
+                }
+                else {
+                    return t.data.definingNode.statementIndex < maxAllowedStatementIndex;
+                }
+            }
+            return true;
+        };
     }
 }
 exports.SymbolTable = SymbolTable;
+/**
+ * Used to invalidate the cache for all symbol tables.
+ *
+ * This is not the most optimized solution as cache will be shared across all instances of SymbolTable across all programs,
+ * but this is the easiest way to handle nested/linked symbol table cache management so we can optimize this in the future some time...
+ */
+SymbolTable.cacheVerifier = new CacheVerifier_1.CacheVerifier();
 //# sourceMappingURL=SymbolTable.js.map