#12931

Committed 13 Aug 2024 05:02PM UTC coverage: 86.193% (-1.7%) from 87.933%

Build Type

push

Committed by

Commit Message

Merge 58ad447a2 into 0e968f1c3

Run Details

10630 of 13125 branches covered (80.99%)

Branch coverage included in aggregate %.

6675 of 7284 new or added lines in 99 files covered. (91.64%)

84 existing lines in 18 files now uncovered.

12312 of 13492 relevant lines covered (91.25%)

26867.76 hits per line

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

88.61

/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;
        }
        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,168,369✔
17	parentProvider?: SymbolTableProvider
18	) {
19	this.resetTypeCache();	5,168,369✔
20	if (parentProvider) {	5,168,369✔
21	this.pushParentProvider(parentProvider);	168,459✔
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,168,369✔
30
31	private parentProviders = [] as SymbolTableProvider[];	5,168,369✔
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);	324,418✔
53	return () => {	324,418✔
54	this.popParentProvider();	7,500✔
55	};
56	}
57
58	/**
59	* Pop the current parentProvider
60	*/
61	public popParentProvider() {
62	this.parentProviders.pop();	7,500✔
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]?.();	404,380✔
70	}
71
72	private siblings = new Set<SymbolTable>();	5,168,369✔
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,134✔
79	return () => {	8,134✔
80	this.siblings.delete(sibling);	6,566✔
81	};
82	}
83
84	/**
85	* Remove a sibling symbol table
86	*/
87	public removeSibling(sibling: SymbolTable) {
UNCOV 88	this.siblings.delete(sibling);	×
89	}
90
91
92	public clearSymbols() {
NEW 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;	287,829✔
106	const key = name?.toLowerCase();	287,829!
107	let result: BscSymbol[];
108	do {	287,829✔
109	// look in our map first
110	if ((result = currentTable.symbolMap.get(key))) {	292,401✔
111	// eslint-disable-next-line no-bitwise
112	if (result.find(symbol => symbol.flags & bitFlags)) {	139,922✔
113	return true;	139,919✔
114	}
115	}
116
117	//look through any sibling maps next
118	for (let sibling of currentTable.siblings) {	152,482✔
119	if ((result = sibling.symbolMap.get(key))) {	466✔
120	// eslint-disable-next-line no-bitwise
121	if (result.find(symbol => symbol.flags & bitFlags)) {	1!
122	return true;	1✔
123	}
124	}
125	}
126	currentTable = currentTable.parent;	152,481✔
127	} while (currentTable);
128	return false;	147,909✔
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;	388,280✔
141	const key = name?.toLowerCase();	388,280!
142	let result: BscSymbol[];
143	let memberOfAncestor = false;	388,280✔
144	const addAncestorInfo = (symbol: BscSymbol) => ({ ...symbol, data: { ...symbol.data, memberOfAncestor: memberOfAncestor } });	388,280✔
145	do {	388,280✔
146	// look in our map first
147	if ((result = currentTable.symbolMap.get(key))) {	440,070✔
148	// eslint-disable-next-line no-bitwise
149	result = result.filter(symbol => symbol.flags & bitFlags);	187,956✔
150	if (result.length > 0) {	187,860✔
151	return result.map(addAncestorInfo);	187,388✔
152	}
153	}
154	//look through any sibling maps next
155	for (let sibling of currentTable.siblings) {	252,682✔
156	result = sibling.getSymbol(key, bitFlags);	16,699✔
157	if (result?.length > 0) {	16,699✔
158	return result.map(addAncestorInfo);	1,306✔
159	}
160	}
161	currentTable = currentTable.parent;	251,376✔
162	memberOfAncestor = true;	251,376✔
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,399,788✔
171	return;	1✔
172	}
173	const key = name?.toLowerCase();	5,399,787!
174	if (!this.symbolMap.has(key)) {	5,399,787✔
175	this.symbolMap.set(key, []);	5,374,704✔
176	}
177	this.symbolMap.get(key)?.push({	5,399,787!
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,252✔
190	if (!this.symbolMap.has(key)) {	1,252✔
191	this.symbolMap.set(key, []);	293✔
192	}
193	this.symbolMap.delete(key);	1,252✔
194	}
195
196	public getSymbolTypes(name: string, options: GetSymbolTypeOptions): TypeCacheEntry[] {
197	const symbolArray = this.getSymbol(name, options.flags);	367,187✔
198	if (!symbolArray) {	367,187✔
199	return undefined;	180,284✔
200	}
201	return symbolArray?.map(symbol => ({ type: symbol.type, data: symbol.data, flags: symbol.flags }));	186,989!
202	}
203
204	getSymbolType(name: string, options: GetSymbolTypeOptions): BscType {
205	const cacheEntry = options.ignoreCacheForRetrieval ? undefined : this.getCachedType(name, options);	767,233!
206	let resolvedType = cacheEntry?.type;	767,233✔
207	let doSetCache = !resolvedType;	767,233✔
208	const originalIsReferenceType = isAnyReferenceType(resolvedType);	767,233✔
209	let data = cacheEntry?.data \|\| {} as ExtraSymbolData;	767,233✔
210	let foundFlags: SymbolTypeFlag = cacheEntry?.flags;	767,233✔
211	if (!resolvedType \|\| originalIsReferenceType) {	767,233✔
212	const symbolTypes = this.getSymbolTypes(name, options);	366,372✔
213	data = symbolTypes?.[0]?.data;	366,372✔
214	foundFlags = symbolTypes?.[0].flags;	366,372✔
215	resolvedType = getUniqueType(symbolTypes?.map(symbol => symbol.type), SymbolTable.unionTypeFactory);	366,372✔
216	}
217	if (!resolvedType && options.fullName && options.tableProvider) {	767,233✔
218	resolvedType = SymbolTable.referenceTypeFactory(name, options.fullName, options.flags, options.tableProvider);	157,613✔
219	}
220	const resolvedTypeIsReference = isAnyReferenceType(resolvedType);	767,233✔
221	const newNonReferenceType = originalIsReferenceType && !isAnyReferenceType(resolvedType);	767,233✔
222	doSetCache = doSetCache && (options.onlyCacheResolvedTypes ? !resolvedTypeIsReference : true);	767,233✔
223	if (doSetCache \|\| newNonReferenceType) {	767,233✔
224	this.setCachedType(name, { type: resolvedType, data: data, flags: foundFlags }, options);	365,052✔
225	}
226	options.data ??= {};	767,233✔
227	if (options.data) {	767,233!
228	options.data.definingNode = data?.definingNode;	767,233✔
229	options.data.description = data?.description;	767,233✔
230	options.data.flags = foundFlags ?? options.flags;	767,233✔
231	options.data.memberOfAncestor = data?.memberOfAncestor;	767,233✔
232	options.data.doNotMerge = data?.doNotMerge;	767,233✔
233	options.data.isAlias = data?.isAlias;	767,233✔
234	options.data.isInstance = data?.isInstance;	767,233✔
235	}
236	return resolvedType;	767,233✔
237	}
238
239	isSymbolTypeInstance(name: string) {
240	const data: ExtraSymbolData = {};	4✔
241	this.getSymbolType(name, { flags: SymbolTypeFlag.runtime, data: data });	4✔
242	return data?.isInstance;	4!
243	}
244
245	/**
246	* Adds all the symbols from another table to this one
247	* It will overwrite any existing symbols in this table
248	*/
249	mergeSymbolTable(symbolTable: SymbolTable) {
250	for (let [, value] of symbolTable.symbolMap) {	3,963✔
251	for (const symbol of value) {	3,760✔
252	if (symbol.data?.doNotMerge) {	3,779✔
253	continue;	40✔
254	}
255	this.addSymbol(	3,739✔
256	symbol.name,
257	symbol.data,
258	symbol.type,
259	symbol.flags
260	);
261	}
262	}
263	}
264
265	mergeNamespaceSymbolTables(symbolTable: SymbolTable) {
266	const disposables = [] as Array<() => void>;	5,383✔
267	for (let [_name, value] of symbolTable.symbolMap) {	5,383✔
268	const symbol = value[0];	1,445✔
269	if (symbol) {	1,445!
270	if (symbol.data?.doNotMerge) {	1,445!
NEW 271	continue;	×
272	}
273	const existingRuntimeType = this.getSymbolType(symbol.name, { flags: symbol.flags });	1,445✔
274
275	if (isNamespaceType(existingRuntimeType) && isNamespaceType(symbol.type)) {	1,445✔
276	disposables.push(...existingRuntimeType.memberTable.mergeNamespaceSymbolTables(symbol.type.memberTable));	481✔
277	} else {
278	this.addSymbol(	964✔
279	symbol.name,
280	symbol.data,
281	symbol.type,
282	symbol.flags
283	);
284	disposables.push(() => this.removeSymbol(symbol.name));	964✔
285	}
286	}
287	}
288
289	for (let siblingTable of symbolTable.siblings) {	5,383✔
290	disposables.push(...this.mergeNamespaceSymbolTables(siblingTable));	479✔
291	}
292	return disposables;	5,383✔
293	}
294
295	/**
296	* Get list of symbols declared directly in this SymbolTable (excludes parent SymbolTable).
297	*/
298	public getOwnSymbols(bitFlags: SymbolTypeFlag): BscSymbol[] {
299	let symbols: BscSymbol[] = [].concat(...this.symbolMap.values());	4,488✔
300	// eslint-disable-next-line no-bitwise
301	symbols = symbols.filter(symbol => symbol.flags & bitFlags);	24,433✔
302	return symbols;	4,488✔
303	}
304
305	/**
306	* Get list of all symbols declared in this SymbolTable (includes parent SymbolTable).
307	*/
308	public getAllSymbols(bitFlags: SymbolTypeFlag): BscSymbol[] {
309	let symbols: BscSymbol[] = [].concat(...this.symbolMap.values());	403✔
310	//look through any sibling maps next
311	for (let sibling of this.siblings) {	403✔
312	symbols = symbols.concat(sibling.getAllSymbols(bitFlags));	32✔
313	}
314	if (this.parent) {	403✔
315	symbols = symbols.concat(this.parent.getAllSymbols(bitFlags));	120✔
316	}
317	// eslint-disable-next-line no-bitwise
318	symbols = symbols.filter(symbol => symbol.flags & bitFlags);	1,595✔
319
320	//remove duplicate symbols
321	const symbolsMap = new Map<string, BscSymbol>();	403✔
322	for (const symbol of symbols) {	403✔
323	const lowerSymbolName = symbol.name.toLowerCase();	1,595✔
324	if (!symbolsMap.has(lowerSymbolName)) {	1,595✔
325	symbolsMap.set(lowerSymbolName, symbol);	1,590✔
326	}
327	}
328	return [...symbolsMap.values()];	403✔
329	}
330
331	private resetTypeCache() {
332	this.typeCache = [	5,171,844✔
333	undefined,
334	new Map<string, TypeCacheEntry>(), // SymbolTypeFlags.runtime
335	new Map<string, TypeCacheEntry>(), // SymbolTypeFlags.typetime
336	new Map<string, TypeCacheEntry>() // SymbolTypeFlags.runtime & SymbolTypeFlags.typetime
337	];
338	this.cacheToken = SymbolTable.cacheVerifier?.getToken();	5,171,844!
339	}
340
341	getCachedType(name: string, options: GetTypeOptions): TypeCacheEntry {
342	if (SymbolTable.cacheVerifier) {	767,233!
343	if (!SymbolTable.cacheVerifier?.checkToken(this.cacheToken)) {	767,233!
344	// we have a bad token
345	this.resetTypeCache();	3,475✔
346	return;	3,475✔
347	}
348	} else {
349	// no cache verifier
NEW 350	return;	×
351	}
352	return this.typeCache[options.flags]?.get(name.toLowerCase());	763,758!
353	}
354
355	setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetTypeOptions) {
356	if (!cacheEntry) {	365,742!
NEW 357	return;	×
358	}
359	if (SymbolTable.cacheVerifier) {	365,742!
360	if (!SymbolTable.cacheVerifier?.checkToken(this.cacheToken)) {	365,742!
361	// we have a bad token - remove all other caches
NEW 362	this.resetTypeCache();	×
363	}
364	} else {
365	// no cache verifier
NEW 366	return;	×
367	}
368	let existingCachedValue = this.typeCache[options.flags]?.get(name.toLowerCase());	365,742!
369	if (isReferenceType(cacheEntry.type) && !isReferenceType(existingCachedValue)) {	365,742✔
370	// No need to overwrite a non-referenceType with a referenceType
371	return;	157,208✔
372	}
373	return this.typeCache[options.flags]?.set(name.toLowerCase(), cacheEntry);	208,534!
374	}
375
376	/**
377	* Serialize this SymbolTable to JSON (useful for debugging reasons)
378	*/
379	private toJSON() {
380	return {	×
381	name: this.name,
NEW 382	siblings: [...this.siblings].map(sibling => sibling.toJSON()),	×
383	parent: this.parent?.toJSON(),	×
384	symbols: [
385	...new Set(
386	[...this.symbolMap.entries()].map(([key, symbols]) => {
NEW 387	return symbols.map(x => {	×
NEW 388	return { name: x.name, type: (x.type as any)?.__identifier };	×
389	});
390	}).flat().sort()
391	)
392	]
393	};
394	}
395	}
396
397	export interface BscSymbol {
398	name: string;
399	data: ExtraSymbolData;
400	type: BscType;
401	flags: SymbolTypeFlag;
402	}
403
404	export interface BscSymbolWithSource extends BscSymbol {
405	comesFromAncestor: boolean; // this symbol comes from an ancestor symbol table
406	}
407
408	export interface SymbolTypeGetter {
409	name: string;
410	getSymbolType(name: string, options: GetSymbolTypeOptions): BscType;
411	setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetSymbolTypeOptions);
412	}
413
414	/**
415	* A function that returns a symbol table.
416	*/
417	export type SymbolTableProvider = () => SymbolTable;
418
419	/**
420	* A function that returns a symbol types getter - smaller interface used in types
421	*/
422	export type SymbolTypeGetterProvider = () => SymbolTypeGetter;
423
424
425	export interface GetSymbolTypeOptions extends GetTypeOptions {
426	fullName?: string;
427	tableProvider?: SymbolTableProvider;
428	}
429
430	export interface TypeCacheEntry {
431	type: BscType;
432	data?: ExtraSymbolData;
433	flags?: SymbolTypeFlag;
434	}

rokucommunity / brighterscript / #12931

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