#13041

Committed 06 Sep 2024 01:54PM UTC coverage: 86.524%. Remained the same

Build Type

push

Committed by

Commit Message

Merge b2bbc792d into 43cbf8b72

Run Details

10841 of 13320 branches covered (81.39%)

Branch coverage included in aggregate %.

213 of 221 new or added lines in 8 files covered. (96.38%)

168 existing lines in 6 files now uncovered.

12537 of 13699 relevant lines covered (91.52%)

27492.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.77

/src/SymbolTable.ts

import type { BscType } from './types/BscType';
import type { ExtraSymbolData, GetTypeOptions } from './interfaces';
import { CacheVerifier } from './CacheVerifier';
import type { ReferenceType } from './types/ReferenceType';
import type { UnionType } from './types/UnionType';
import { getUniqueType } from './types/helpers';
import { isAnyReferenceType, isNamespaceType, isReferenceType } from './astUtils/reflection';
import { SymbolTypeFlag } from './SymbolTypeFlag';

/**
 * Stores the types associated with variables and functions in the Brighterscript code
 * Can be part of a hierarchy, so lookups can reference parent scopes
 */
export class SymbolTable implements SymbolTypeGetter {
    constructor(
        public name: string,
        parentProvider?: SymbolTableProvider
    ) {
        this.resetTypeCache();
        if (parentProvider) {
            this.pushParentProvider(parentProvider);
        }
    }

    /**
     * The map of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
     * Indexed by lower symbol name
     */
    private symbolMap = new Map<string, BscSymbol[]>();

    private parentProviders = [] as SymbolTableProvider[];

    private cacheToken: string;

    private typeCache: Array<Map<string, TypeCacheEntry>>;

    /**
     * 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...
     */
    static cacheVerifier = new CacheVerifier();

    static referenceTypeFactory: (memberKey: string, fullName, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider) => ReferenceType;
    static unionTypeFactory: (types: BscType[]) => UnionType;

    /**
     * Push a function that will provide a parent SymbolTable when requested
     */
    public pushParentProvider(provider: SymbolTableProvider) {
        this.parentProviders.push(provider);
        return () => {
            this.popParentProvider();
        };
    }

    /**
     * Pop the current parentProvider
     */
    public popParentProvider() {
        this.parentProviders.pop();
    }

    /**
     * The parent SymbolTable (if there is one)
     */
    public get parent(): SymbolTable | undefined {
        return this.parentProviders[this.parentProviders.length - 1]?.();
    }

    private siblings = new Set<SymbolTable>();

    /**
     * Add a sibling symbol table (which will be inspected first before walking upward to the parent
     */
    public addSibling(sibling: SymbolTable) {
        this.siblings.add(sibling);
        return () => {
            this.siblings.delete(sibling);
        };
    }

    /**
     * Remove a sibling symbol table
     */
    public removeSibling(sibling: SymbolTable) {
        this.siblings.delete(sibling);
    }


    public 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 bitFlags flags to match (See SymbolTypeFlags)
     * @returns true if this symbol is in the symbol table
     */
    hasSymbol(name: string, bitFlags: SymbolTypeFlag): boolean {
        let currentTable: SymbolTable = this;
        const key = name?.toLowerCase();
        let result: BscSymbol[];
        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 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 bitFlags flags to match
     * @returns An array of BscSymbols - one for each time this symbol had a type implicitly defined
     */
    getSymbol(name: string, bitFlags: SymbolTypeFlag): BscSymbol[] {
        let currentTable: SymbolTable = this;
        const key = name?.toLowerCase();
        let result: BscSymbol[];
        let memberOfAncestor = false;
        const addAncestorInfo = (symbol: BscSymbol) => ({ ...symbol, data: { ...symbol.data, memberOfAncestor: memberOfAncestor } });
        do {
            // look in our map first
            if ((result = currentTable.symbolMap.get(key))) {
                // eslint-disable-next-line no-bitwise
                result = result.filter(symbol => symbol.flags & bitFlags);
                if (result.length > 0) {
                    return result.map(addAncestorInfo);
                }
            }
            //look through any sibling maps next
            for (let sibling of currentTable.siblings) {
                result = sibling.getSymbol(key, bitFlags);
                if (result?.length > 0) {
                    return result.map(addAncestorInfo);
                }
            }
            currentTable = currentTable.parent;
            memberOfAncestor = true;
        } while (currentTable);
    }

    /**
     * Adds a new symbol to the table
     */
    addSymbol(name: string, data: ExtraSymbolData, type: BscType, bitFlags: SymbolTypeFlag) {
        if (!name) {
            return;
        }
        const key = name?.toLowerCase();
        if (!this.symbolMap.has(key)) {
            this.symbolMap.set(key, []);
        }
        this.symbolMap.get(key)?.push({
            name: name,
            data: data,
            type: type,
            flags: bitFlags
        });
    }

    /**
     * Removes a new symbol from the table
     */
    removeSymbol(name: string) {
        const key = name.toLowerCase();
        if (!this.symbolMap.has(key)) {
            this.symbolMap.set(key, []);
        }
        this.symbolMap.delete(key);
    }

    public getSymbolTypes(name: string, options: GetSymbolTypeOptions): TypeCacheEntry[] {
        const symbolArray = this.getSymbol(name, options.flags);
        if (!symbolArray) {
            return undefined;
        }
        return symbolArray?.map(symbol => ({ type: symbol.type, data: symbol.data, flags: symbol.flags }));
    }

    getSymbolType(name: string, options: GetSymbolTypeOptions): BscType {
        const cacheEntry = options.ignoreCacheForRetrieval ? undefined : this.getCachedType(name, options);
        let resolvedType = cacheEntry?.type;
        let doSetCache = !resolvedType;
        const originalIsReferenceType = isAnyReferenceType(resolvedType);
        let data = cacheEntry?.data || {} as ExtraSymbolData;
        let foundFlags: SymbolTypeFlag = cacheEntry?.flags;
        if (!resolvedType || originalIsReferenceType) {
            const symbolTypes = this.getSymbolTypes(name, options);
            data = symbolTypes?.[0]?.data;
            foundFlags = symbolTypes?.[0].flags;
            resolvedType = getUniqueType(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 = isAnyReferenceType(resolvedType);
        const newNonReferenceType = originalIsReferenceType && !isAnyReferenceType(resolvedType);
        doSetCache = doSetCache && (options.onlyCacheResolvedTypes ? !resolvedTypeIsReference : true);
        if (doSetCache || newNonReferenceType) {
            this.setCachedType(name, { type: resolvedType, data: data, flags: foundFlags }, options);
        }
        options.data ??= {};
        if (options.data) {
            options.data.definingNode = data?.definingNode;
            options.data.description = data?.description;
            options.data.flags = foundFlags ?? options.flags;
            options.data.memberOfAncestor = data?.memberOfAncestor;
            options.data.doNotMerge = data?.doNotMerge;
            options.data.isAlias = data?.isAlias;
            options.data.isInstance = data?.isInstance;
            options.data.isFromDocComment = data?.isFromDocComment;
        }
        return resolvedType;
    }

    isSymbolTypeInstance(name: string) {
        const data: ExtraSymbolData = {};
        this.getSymbolType(name, { flags: SymbolTypeFlag.runtime, data: data });
        return data?.isInstance;
    }

    /**
     * Adds all the symbols from another table to this one
     * It will overwrite any existing symbols in this table
     */
    mergeSymbolTable(symbolTable: SymbolTable) {
        for (let [, value] of symbolTable.symbolMap) {
            for (const symbol of value) {
                if (symbol.data?.doNotMerge) {
                    continue;
                }
                this.addSymbol(
                    symbol.name,
                    symbol.data,
                    symbol.type,
                    symbol.flags
                );
            }
        }
    }

    mergeNamespaceSymbolTables(symbolTable: SymbolTable) {
        const disposables = [] as Array<() => void>;
        for (let [_name, value] of symbolTable.symbolMap) {
            const symbol = value[0];
            if (symbol) {
                if (symbol.data?.doNotMerge) {
                    continue;
                }
                const existingRuntimeType = this.getSymbolType(symbol.name, { flags: symbol.flags });

                if (isNamespaceType(existingRuntimeType) && 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));
                }
            }
        }

        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).
     */
    public getOwnSymbols(bitFlags: SymbolTypeFlag): BscSymbol[] {
        let symbols: BscSymbol[] = [].concat(...this.symbolMap.values());
        // eslint-disable-next-line no-bitwise
        symbols = symbols.filter(symbol => symbol.flags & bitFlags);
        return symbols;
    }

    /**
     * Get list of all symbols declared in this SymbolTable (includes parent SymbolTable).
     */
    public getAllSymbols(bitFlags: SymbolTypeFlag): BscSymbol[] {
        let symbols: BscSymbol[] = [].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) {
            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<string, BscSymbol>();
        for (const symbol of symbols) {
            const lowerSymbolName = symbol.name.toLowerCase();
            if (!symbolsMap.has(lowerSymbolName)) {
                symbolsMap.set(lowerSymbolName, symbol);
            }
        }
        return [...symbolsMap.values()];
    }

    private resetTypeCache() {
        this.typeCache = [
            undefined,
            new Map<string, TypeCacheEntry>(), // SymbolTypeFlags.runtime
            new Map<string, TypeCacheEntry>(), // SymbolTypeFlags.typetime
            new Map<string, TypeCacheEntry>() // SymbolTypeFlags.runtime & SymbolTypeFlags.typetime
        ];
        this.cacheToken = SymbolTable.cacheVerifier?.getToken();
    }

    getCachedType(name: string, options: GetTypeOptions): TypeCacheEntry {
        if (SymbolTable.cacheVerifier) {
            if (!SymbolTable.cacheVerifier?.checkToken(this.cacheToken)) {
                // we have a bad token
                this.resetTypeCache();
                return;
            }
        } else {
            // no cache verifier
            return;
        }
        return this.typeCache[options.flags]?.get(name.toLowerCase());
    }

    setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetTypeOptions) {
        if (!cacheEntry) {
            return;
        }
        if (SymbolTable.cacheVerifier) {
            if (!SymbolTable.cacheVerifier?.checkToken(this.cacheToken)) {
                // we have a bad token - remove all other caches
                this.resetTypeCache();
            }
        } else {
            // no cache verifier
            return;
        }
        let existingCachedValue = this.typeCache[options.flags]?.get(name.toLowerCase());
        if (isReferenceType(cacheEntry.type) && !isReferenceType(existingCachedValue)) {
            // No need to overwrite a non-referenceType with a referenceType
            return;
        }
        return this.typeCache[options.flags]?.set(name.toLowerCase(), cacheEntry);
    }

    /**
     * Serialize this SymbolTable to JSON (useful for debugging reasons)
     */
    private toJSON() {
        return {
            name: this.name,
            siblings: [...this.siblings].map(sibling => sibling.toJSON()),
            parent: this.parent?.toJSON(),
            symbols: [
                ...new Set(
                    [...this.symbolMap.entries()].map(([key, symbols]) => {
                        return symbols.map(x => {
                            return { name: x.name, type: (x.type as any)?.__identifier };
                        });
                    }).flat().sort()
                )
            ]
        };
    }
}

export interface BscSymbol {
    name: string;
    data: ExtraSymbolData;
    type: BscType;
    flags: SymbolTypeFlag;
}

export interface BscSymbolWithSource extends BscSymbol {
    comesFromAncestor: boolean; // this symbol comes from an ancestor symbol table
}

export interface SymbolTypeGetter {
    name: string;
    getSymbolType(name: string, options: GetSymbolTypeOptions): BscType;
    setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetSymbolTypeOptions);
}

/**
 * A function that returns a symbol table.
 */
export type SymbolTableProvider = () => SymbolTable;

/**
 * A function that returns a symbol types getter - smaller interface used in types
 */
export type SymbolTypeGetterProvider = () => SymbolTypeGetter;


export interface GetSymbolTypeOptions extends GetTypeOptions {
    fullName?: string;
    tableProvider?: SymbolTableProvider;
}

export interface TypeCacheEntry {
    type: BscType;
    data?: ExtraSymbolData;
    flags?: SymbolTypeFlag;
}

1	import type { BscType } from './types/BscType';
2	import type { ExtraSymbolData, GetTypeOptions } from './interfaces';
3	import { CacheVerifier } from './CacheVerifier';	1✔
4	import type { ReferenceType } from './types/ReferenceType';
5	import type { UnionType } from './types/UnionType';
6	import { getUniqueType } from './types/helpers';	1✔
7	import { isAnyReferenceType, isNamespaceType, isReferenceType } from './astUtils/reflection';	1✔
8	import { SymbolTypeFlag } from './SymbolTypeFlag';	1✔
9
10	/**
11	* Stores the types associated with variables and functions in the Brighterscript code
12	* Can be part of a hierarchy, so lookups can reference parent scopes
13	*/
14	export class SymbolTable implements SymbolTypeGetter {	1✔
15	constructor(
16	public name: string,	5,301,123✔
17	parentProvider?: SymbolTableProvider
18	) {
19	this.resetTypeCache();	5,301,123✔
20	if (parentProvider) {	5,301,123✔
21	this.pushParentProvider(parentProvider);	172,584✔
22	}
23	}
24
25	/**
26	* The map of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
27	* Indexed by lower symbol name
28	*/
29	private symbolMap = new Map<string, BscSymbol[]>();	5,301,123✔
30
31	private parentProviders = [] as SymbolTableProvider[];	5,301,123✔
32
33	private cacheToken: string;
34
35	private typeCache: Array<Map<string, TypeCacheEntry>>;
36
37	/**
38	* Used to invalidate the cache for all symbol tables.
39	*
40	* This is not the most optimized solution as cache will be shared across all instances of SymbolTable across all programs,
41	* but this is the easiest way to handle nested/linked symbol table cache management so we can optimize this in the future some time...
42	*/
43	static cacheVerifier = new CacheVerifier();	1✔
44
45	static referenceTypeFactory: (memberKey: string, fullName, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider) => ReferenceType;
46	static unionTypeFactory: (types: BscType[]) => UnionType;
47
48	/**
49	* Push a function that will provide a parent SymbolTable when requested
50	*/
51	public pushParentProvider(provider: SymbolTableProvider) {
52	this.parentProviders.push(provider);	332,405✔
53	return () => {	332,405✔
54	this.popParentProvider();	7,695✔
55	};
56	}
57
58	/**
59	* Pop the current parentProvider
60	*/
61	public popParentProvider() {
62	this.parentProviders.pop();	7,695✔
63	}
64
65	/**
66	* The parent SymbolTable (if there is one)
67	*/
68	public get parent(): SymbolTable \| undefined {
69	return this.parentProviders[this.parentProviders.length - 1]?.();	475,966✔
70	}
71
72	private siblings = new Set<SymbolTable>();	5,301,123✔
73
74	/**
75	* Add a sibling symbol table (which will be inspected first before walking upward to the parent
76	*/
77	public addSibling(sibling: SymbolTable) {
78	this.siblings.add(sibling);	8,362✔
79	return () => {	8,362✔
80	this.siblings.delete(sibling);	6,754✔
81	};
82	}
83
84	/**
85	* Remove a sibling symbol table
86	*/
87	public removeSibling(sibling: SymbolTable) {
88	this.siblings.delete(sibling);	×
89	}
90
91
92	public clearSymbols() {
93	this.symbolMap.clear();	×
94	}
95
96	/**
97	* Checks if the symbol table contains the given symbol by name
98	* If the identifier is not in this table, it will check the parent
99	*
100	* @param name the name to lookup
101	* @param bitFlags flags to match (See SymbolTypeFlags)
102	* @returns true if this symbol is in the symbol table
103	*/
104	hasSymbol(name: string, bitFlags: SymbolTypeFlag): boolean {
105	let currentTable: SymbolTable = this;	301,576✔
106	const key = name?.toLowerCase();	301,576!
107	let result: BscSymbol[];
108	do {	301,576✔
109	// look in our map first
110	if ((result = currentTable.symbolMap.get(key))) {	308,281✔
111	// eslint-disable-next-line no-bitwise
112	if (result.find(symbol => symbol.flags & bitFlags)) {	143,614✔
113	return true;	143,611✔
114	}
115	}
116
117	//look through any sibling maps next
118	for (let sibling of currentTable.siblings) {	164,670✔
119	if ((result = sibling.symbolMap.get(key))) {	1,896✔
120	// eslint-disable-next-line no-bitwise
121	if (result.find(symbol => symbol.flags & bitFlags)) {	319!
122	return true;	319✔
123	}
124	}
125	}
126	currentTable = currentTable.parent;	164,351✔
127	} while (currentTable);
128	return false;	157,646✔
129	}
130
131	/**
132	* Gets the name/type pair for a given named variable or function name
133	* If the identifier is not in this table, it will check the parent
134	*
135	* @param name the name to lookup
136	* @param bitFlags flags to match
137	* @returns An array of BscSymbols - one for each time this symbol had a type implicitly defined
138	*/
139	getSymbol(name: string, bitFlags: SymbolTypeFlag): BscSymbol[] {
140	let currentTable: SymbolTable = this;	416,356✔
141	const key = name?.toLowerCase();	416,356!
142	let result: BscSymbol[];
143	let memberOfAncestor = false;	416,356✔
144	const addAncestorInfo = (symbol: BscSymbol) => ({ ...symbol, data: { ...symbol.data, memberOfAncestor: memberOfAncestor } });	416,356✔
145	do {	416,356✔
146	// look in our map first
147	if ((result = currentTable.symbolMap.get(key))) {	504,794✔
148	// eslint-disable-next-line no-bitwise
149	result = result.filter(symbol => symbol.flags & bitFlags);	192,999✔
150	if (result.length > 0) {	192,865✔
151	return result.map(addAncestorInfo);	192,373✔
152	}
153	}
154	//look through any sibling maps next
155	for (let sibling of currentTable.siblings) {	312,421✔
156	result = sibling.getSymbol(key, bitFlags);	17,841✔
157	if (result?.length > 0) {	17,841✔
158	return result.map(addAncestorInfo);	1,380✔
159	}
160	}
161	currentTable = currentTable.parent;	311,041✔
162	memberOfAncestor = true;	311,041✔
163	} while (currentTable);
164	}
165
166	/**
167	* Adds a new symbol to the table
168	*/
169	addSymbol(name: string, data: ExtraSymbolData, type: BscType, bitFlags: SymbolTypeFlag) {
170	if (!name) {	5,532,495✔
171	return;	1✔
172	}
173	const key = name?.toLowerCase();	5,532,494!
174	if (!this.symbolMap.has(key)) {	5,532,494✔
175	this.symbolMap.set(key, []);	5,506,800✔
176	}
177	this.symbolMap.get(key)?.push({	5,532,494!
178	name: name,
179	data: data,
180	type: type,
181	flags: bitFlags
182	});
183	}
184
185	/**
186	* Removes a new symbol from the table
187	*/
188	removeSymbol(name: string) {
189	const key = name.toLowerCase();	1,289✔
190	if (!this.symbolMap.has(key)) {	1,289✔
191	this.symbolMap.set(key, []);	293✔
192	}
193	this.symbolMap.delete(key);	1,289✔
194	}
195
196	public getSymbolTypes(name: string, options: GetSymbolTypeOptions): TypeCacheEntry[] {
197	const symbolArray = this.getSymbol(name, options.flags);	393,913✔
198	if (!symbolArray) {	393,913✔
199	return undefined;	202,025✔
200	}
201	return symbolArray?.map(symbol => ({ type: symbol.type, data: symbol.data, flags: symbol.flags }));	192,002!
202	}
203
204	getSymbolType(name: string, options: GetSymbolTypeOptions): BscType {
205	const cacheEntry = options.ignoreCacheForRetrieval ? undefined : this.getCachedType(name, options);	804,353!
206	let resolvedType = cacheEntry?.type;	804,353✔
207	let doSetCache = !resolvedType;	804,353✔
208	const originalIsReferenceType = isAnyReferenceType(resolvedType);	804,353✔
209	let data = cacheEntry?.data \|\| {} as ExtraSymbolData;	804,353✔
210	let foundFlags: SymbolTypeFlag = cacheEntry?.flags;	804,353✔
211	if (!resolvedType \|\| originalIsReferenceType) {	804,353✔
212	const symbolTypes = this.getSymbolTypes(name, options);	393,068✔
213	data = symbolTypes?.[0]?.data;	393,068✔
214	foundFlags = symbolTypes?.[0].flags;	393,068✔
215	resolvedType = getUniqueType(symbolTypes?.map(symbol => symbol.type), SymbolTable.unionTypeFactory);	393,068✔
216	}
217	if (!resolvedType && options.fullName && options.tableProvider) {	804,353✔
218	resolvedType = SymbolTable.referenceTypeFactory(name, options.fullName, options.flags, options.tableProvider);	167,225✔
219	}
220	const resolvedTypeIsReference = isAnyReferenceType(resolvedType);	804,353✔
221	const newNonReferenceType = originalIsReferenceType && !isAnyReferenceType(resolvedType);	804,353✔
222	doSetCache = doSetCache && (options.onlyCacheResolvedTypes ? !resolvedTypeIsReference : true);	804,353✔
223	if (doSetCache \|\| newNonReferenceType) {	804,353✔
224	this.setCachedType(name, { type: resolvedType, data: data, flags: foundFlags }, options);	391,740✔
225	}
226	options.data ??= {};	804,353✔
227	if (options.data) {	804,353!
228	options.data.definingNode = data?.definingNode;	804,353✔
229	options.data.description = data?.description;	804,353✔
230	options.data.flags = foundFlags ?? options.flags;	804,353✔
231	options.data.memberOfAncestor = data?.memberOfAncestor;	804,353✔
232	options.data.doNotMerge = data?.doNotMerge;	804,353✔
233	options.data.isAlias = data?.isAlias;	804,353✔
234	options.data.isInstance = data?.isInstance;	804,353✔
235	options.data.isFromDocComment = data?.isFromDocComment;	804,353✔
236	}
237	return resolvedType;	804,353✔
238	}
239
240	isSymbolTypeInstance(name: string) {
241	const data: ExtraSymbolData = {};	4✔
242	this.getSymbolType(name, { flags: SymbolTypeFlag.runtime, data: data });	4✔
243	return data?.isInstance;	4!
244	}
245
246	/**
247	* Adds all the symbols from another table to this one
248	* It will overwrite any existing symbols in this table
249	*/
250	mergeSymbolTable(symbolTable: SymbolTable) {
251	for (let [, value] of symbolTable.symbolMap) {	4,046✔
252	for (const symbol of value) {	3,987✔
253	if (symbol.data?.doNotMerge) {	4,007✔
254	continue;	40✔
255	}
256	this.addSymbol(	3,967✔
257	symbol.name,
258	symbol.data,
259	symbol.type,
260	symbol.flags
261	);
262	}
263	}
264	}
265
266	mergeNamespaceSymbolTables(symbolTable: SymbolTable) {
267	const disposables = [] as Array<() => void>;	5,492✔
268	for (let [_name, value] of symbolTable.symbolMap) {	5,492✔
269	const symbol = value[0];	1,482✔
270	if (symbol) {	1,482!
271	if (symbol.data?.doNotMerge) {	1,482!
UNCOV 272	continue;	×
273	}
274	const existingRuntimeType = this.getSymbolType(symbol.name, { flags: symbol.flags });	1,482✔
275
276	if (isNamespaceType(existingRuntimeType) && isNamespaceType(symbol.type)) {	1,482✔
277	disposables.push(...existingRuntimeType.memberTable.mergeNamespaceSymbolTables(symbol.type.memberTable));	481✔
278	} else {
279	this.addSymbol(	1,001✔
280	symbol.name,
281	symbol.data,
282	symbol.type,
283	symbol.flags
284	);
285	disposables.push(() => this.removeSymbol(symbol.name));	1,001✔
286	}
287	}
288	}
289
290	for (let siblingTable of symbolTable.siblings) {	5,492✔
291	disposables.push(...this.mergeNamespaceSymbolTables(siblingTable));	479✔
292	}
293	return disposables;	5,492✔
294	}
295
296	/**
297	* Get list of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
298	*/
299	public getOwnSymbols(bitFlags: SymbolTypeFlag): BscSymbol[] {
300	let symbols: BscSymbol[] = [].concat(...this.symbolMap.values());	4,614✔
301	// eslint-disable-next-line no-bitwise
302	symbols = symbols.filter(symbol => symbol.flags & bitFlags);	24,837✔
303	return symbols;	4,614✔
304	}
305
306	/**
307	* Get list of all symbols declared in this SymbolTable (includes parent SymbolTable).
308	*/
309	public getAllSymbols(bitFlags: SymbolTypeFlag): BscSymbol[] {
310	let symbols: BscSymbol[] = [].concat(...this.symbolMap.values());	437✔
311	//look through any sibling maps next
312	for (let sibling of this.siblings) {	437✔
313	symbols = symbols.concat(sibling.getAllSymbols(bitFlags));	32✔
314	}
315	if (this.parent) {	437✔
316	symbols = symbols.concat(this.parent.getAllSymbols(bitFlags));	137✔
317	}
318	// eslint-disable-next-line no-bitwise
319	symbols = symbols.filter(symbol => symbol.flags & bitFlags);	1,625✔
320
321	//remove duplicate symbols
322	const symbolsMap = new Map<string, BscSymbol>();	437✔
323	for (const symbol of symbols) {	437✔
324	const lowerSymbolName = symbol.name.toLowerCase();	1,625✔
325	if (!symbolsMap.has(lowerSymbolName)) {	1,625✔
326	symbolsMap.set(lowerSymbolName, symbol);	1,620✔
327	}
328	}
329	return [...symbolsMap.values()];	437✔
330	}
331
332	private resetTypeCache() {
333	this.typeCache = [	5,305,523✔
334	undefined,
335	new Map<string, TypeCacheEntry>(), // SymbolTypeFlags.runtime
336	new Map<string, TypeCacheEntry>(), // SymbolTypeFlags.typetime
337	new Map<string, TypeCacheEntry>() // SymbolTypeFlags.runtime & SymbolTypeFlags.typetime
338	];
339	this.cacheToken = SymbolTable.cacheVerifier?.getToken();	5,305,523!
340	}
341
342	getCachedType(name: string, options: GetTypeOptions): TypeCacheEntry {
343	if (SymbolTable.cacheVerifier) {	804,353!
344	if (!SymbolTable.cacheVerifier?.checkToken(this.cacheToken)) {	804,353!
345	// we have a bad token
346	this.resetTypeCache();	4,400✔
347	return;	4,400✔
348	}
349	} else {
350	// no cache verifier
UNCOV 351	return;	×
352	}
353	return this.typeCache[options.flags]?.get(name.toLowerCase());	799,953!
354	}
355
356	setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetTypeOptions) {
357	if (!cacheEntry) {	392,430!
UNCOV 358	return;	×
359	}
360	if (SymbolTable.cacheVerifier) {	392,430!
361	if (!SymbolTable.cacheVerifier?.checkToken(this.cacheToken)) {	392,430!
362	// we have a bad token - remove all other caches
UNCOV 363	this.resetTypeCache();	×
364	}
365	} else {
366	// no cache verifier
UNCOV 367	return;	×
368	}
369	let existingCachedValue = this.typeCache[options.flags]?.get(name.toLowerCase());	392,430!
370	if (isReferenceType(cacheEntry.type) && !isReferenceType(existingCachedValue)) {	392,430✔
371	// No need to overwrite a non-referenceType with a referenceType
372	return;	166,846✔
373	}
374	return this.typeCache[options.flags]?.set(name.toLowerCase(), cacheEntry);	225,584!
375	}
376
377	/**
378	* Serialize this SymbolTable to JSON (useful for debugging reasons)
379	*/
380	private toJSON() {
UNCOV 381	return {	×
382	name: this.name,
UNCOV 383	siblings: [...this.siblings].map(sibling => sibling.toJSON()),	×
384	parent: this.parent?.toJSON(),	×
385	symbols: [
386	...new Set(
387	[...this.symbolMap.entries()].map(([key, symbols]) => {
UNCOV 388	return symbols.map(x => {	×
389	return { name: x.name, type: (x.type as any)?.__identifier };	×
390	});
391	}).flat().sort()
392	)
393	]
394	};
395	}
396	}
397
398	export interface BscSymbol {
399	name: string;
400	data: ExtraSymbolData;
401	type: BscType;
402	flags: SymbolTypeFlag;
403	}
404
405	export interface BscSymbolWithSource extends BscSymbol {
406	comesFromAncestor: boolean; // this symbol comes from an ancestor symbol table
407	}
408
409	export interface SymbolTypeGetter {
410	name: string;
411	getSymbolType(name: string, options: GetSymbolTypeOptions): BscType;
412	setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetSymbolTypeOptions);
413	}
414
415	/**
416	* A function that returns a symbol table.
417	*/
418	export type SymbolTableProvider = () => SymbolTable;
419
420	/**
421	* A function that returns a symbol types getter - smaller interface used in types
422	*/
423	export type SymbolTypeGetterProvider = () => SymbolTypeGetter;
424
425
426	export interface GetSymbolTypeOptions extends GetTypeOptions {
427	fullName?: string;
428	tableProvider?: SymbolTableProvider;
429	}
430
431	export interface TypeCacheEntry {
432	type: BscType;
433	data?: ExtraSymbolData;
434	flags?: SymbolTypeFlag;
435	}

rokucommunity / brighterscript / #13041

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous