#13949

Committed 24 Feb 2025 07:44PM UTC coverage: 86.729% (-0.03%) from 86.755%

Build Type

push

Committed by

Commit Message

Merge 87502c2a3 into c5c4ff29c

Coverage Stats

12674 of 15448 branches covered (82.04%)

Branch coverage included in aggregate %.

237 of 255 new or added lines in 9 files covered. (92.94%)

21 existing lines in 3 files now uncovered.

13552 of 14791 relevant lines covered (91.62%)

33981.05 hits per line

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

94.17

/src/astUtils/CachedLookups.ts

import type { AALiteralExpression, BinaryExpression, CallExpression, CallfuncExpression, DottedGetExpression, FunctionExpression, VariableExpression } from '../parser/Expression';
import type { AliasStatement, AssignmentStatement, AugmentedAssignmentStatement, ClassStatement, ConstStatement, EnumStatement, FunctionStatement, ImportStatement, InterfaceStatement, LibraryStatement, NamespaceStatement, TypecastStatement } from '../parser/Statement';
import { Cache } from '../Cache';
import { InternalWalkMode, WalkMode, createVisitor } from './visitors';
import type { Expression } from '../parser/AstNode';
import { isAAMemberExpression, isBinaryExpression, isCallExpression, isDottedGetExpression, isFunctionExpression, isGroupingExpression, isIndexedGetExpression, isLiteralExpression, isMethodStatement, isNamespaceStatement, isNewExpression, isVariableExpression } from './reflection';
import type { Parser } from '../parser/Parser';
import { ParseMode } from '../parser/Parser';
import type { Token } from '../lexer/Token';
import { isToken } from '../lexer/Token';
import type { Program } from '../Program';
import util from '../util';


export interface BscFileLike {
    program: Program;
    _parser: Parser;
}

export class CachedLookups {

    private cache = new Cache();

    constructor(private file: BscFileLike) { }

    get namespaceStatements(): NamespaceStatement[] {
        return this.getFromCache<Array<NamespaceStatement>>('namespaceStatements');
    }

    get functionStatements(): FunctionStatement[] {
        return this.getFromCache<Array<FunctionStatement>>('functionStatements');
    }

    get functionStatementMap() {
        return this.cache.getOrAdd('functionStatementMap', () => {
            const funcMap = new Map<string, FunctionStatement>();
            for (const stmt of this.functionStatements) {
                funcMap.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
            }
            return funcMap;
        });
    }

    get functionExpressions(): FunctionExpression[] {
        return this.getFromCache<Array<FunctionExpression>>('functionExpressions');
    }

    get libraryStatements(): LibraryStatement[] {
        return this.getFromCache<Array<LibraryStatement>>('libraryStatements');
    }

    get importStatements(): ImportStatement[] {
        return this.getFromCache<Array<ImportStatement>>('importStatements');
    }

    get typecastStatements(): TypecastStatement[] {
        return this.getFromCache<Array<TypecastStatement>>('typecastStatements');
    }

    get aliasStatements(): AliasStatement[] {
        return this.getFromCache<Array<AliasStatement>>('aliasStatements');
    }

    /**
     * A collection of full expressions. This excludes intermediary expressions.
     *
     * Example 1:
     * `a.b.c` is composed of `a` (variableExpression)  `.b` (DottedGetExpression) `.c` (DottedGetExpression)
     * This will only contain the final `.c` DottedGetExpression because `.b` and `a` can both be derived by walking back from the `.c` DottedGetExpression.
     *
     * Example 2:
     * `name.space.doSomething(a.b.c)` will result in 2 entries in this list. the `CallExpression` for `doSomething`, and the `.c` DottedGetExpression.
     *
     * Example 3:
     * `value = SomeEnum.value > 2 or SomeEnum.otherValue < 10` will result in 4 entries. `SomeEnum.value`, `2`, `SomeEnum.otherValue`, `10`
     */
    get expressions(): Set<Expression> {
        return this.getFromCache<Set<Expression>>('expressions');
    }

    get classStatements(): ClassStatement[] {
        return this.getFromCache<Array<ClassStatement>>('classStatements');
    }

    get classStatementMap() {
        return this.cache.getOrAdd('classStatementMap', () => {
            const classMap = new Map<string, ClassStatement>();
            for (const stmt of this.classStatements) {
                classMap.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
            }
            return classMap;
        });
    }

    get assignmentStatements(): AssignmentStatement[] {
        return this.getFromCache<Array<AssignmentStatement>>('assignmentStatements');
    }

    get augmentedAssignmentStatements(): AugmentedAssignmentStatement[] {
        return this.getFromCache<Array<AugmentedAssignmentStatement>>('augmentedAssignmentStatements');
    }

    get enumStatements(): EnumStatement[] {
        return this.getFromCache<Array<EnumStatement>>('enumStatements');
    }

    get enumStatementMap() {
        return this.cache.getOrAdd('enumStatementMap', () => {
            const enumMap = new Map<string, EnumStatement>();
            for (const stmt of this.enumStatements) {
                enumMap.set(stmt.fullName.toLowerCase(), stmt);
            }
            return enumMap;
        });
    }

    get constStatements(): ConstStatement[] {
        return this.getFromCache<Array<ConstStatement>>('constStatements');
    }

    get constStatementMap() {
        return this.cache.getOrAdd('constStatementMap', () => {
            const constMap = new Map<string, ConstStatement>();
            for (const stmt of this.constStatements) {
                constMap.set(stmt.fullName.toLowerCase(), stmt);
            }
            return constMap;
        });
    }

    get interfaceStatements(): InterfaceStatement[] {
        return this.getFromCache<Array<InterfaceStatement>>('interfaceStatements');
    }

    get interfaceStatementMap() {
        return this.cache.getOrAdd('interfaceStatementMap', () => {
            const ifaceMap = new Map<string, InterfaceStatement>();
            for (const stmt of this.interfaceStatements) {
                ifaceMap.set(stmt.fullName.toLowerCase(), stmt);
            }
            return ifaceMap;
        });
    }

    get propertyHints(): Record<string, string> {
        return this.getFromCache<Record<string, string>>('propertyHints');
    }


    invalidate() {
        this.cache.clear();
    }


    private getFromCache<T>(cacheKey: string): T {
        if (!this.cache.has(cacheKey)) {
            this.rehydrate();
        }
        if (!this.cache.has(cacheKey)) {
            this.file.program.logger.info('Unable to get cached lookup', cacheKey);
        }
        return this.cache.get(cacheKey);
    }

    private rehydrate() {
        const expressions = new Set<Expression>();
        const classStatements: ClassStatement[] = [];
        const namespaceStatements: NamespaceStatement[] = [];
        const enumStatements: EnumStatement[] = [];
        const constStatements: ConstStatement[] = [];
        const interfaceStatements: InterfaceStatement[] = [];
        const assignmentStatements: AssignmentStatement[] = [];
        const libraryStatements: LibraryStatement[] = [];
        const importStatements: ImportStatement[] = [];
        const typecastStatements: TypecastStatement[] = [];
        const aliasStatements: AliasStatement[] = [];
        const functionStatements: FunctionStatement[] = [];
        const functionExpressions: FunctionExpression[] = [];

        const augmentedAssignmentStatements: AugmentedAssignmentStatement[] = [];

        const propertyHints: Record<string, string> = {};
        const addPropertyHints = (item: Token | AALiteralExpression) => {
            if (isToken(item)) {
                const name = item.text;
                propertyHints[name.toLowerCase()] = name;
            } else {
                for (const member of item.elements) {
                    const name = member.tokens.key.text;
                    if (!name.startsWith('"')) {
                        propertyHints[name.toLowerCase()] = name;
                    }

                }
            }
        };

        const excludedExpressions = new Set<Expression>();

        const visitBinaryExpression = (e: BinaryExpression) => {
            //walk the chain of binary expressions and add each one to the list of expressions
            const expressionsParts: Expression[] = [e];
            let expression: Expression;
            while ((expression = expressionsParts.pop())) {
                if (isBinaryExpression(expression)) {
                    expressionsParts.push(expression.left, expression.right);
                } else {
                    expressions.add(expression);
                }
            }
        };

        const visitCallExpression = (e: CallExpression | CallfuncExpression) => {
            for (const p of e.args) {
                expressions.add(p);
            }
            //add calls that were not excluded (from loop below)
            if (!excludedExpressions.has(e)) {
                expressions.add(e);
            }

            //if this call is part of a longer expression that includes a call higher up, find that higher one and remove it
            if (e.callee) {
                let node: Expression = e.callee;
                while (node) {
                    //the primary goal for this loop. If we found a parent call expression, remove it from `references`
                    if (isCallExpression(node)) {
                        expressions.delete(node);
                        excludedExpressions.add(node);
                        //stop here. even if there are multiple calls in the chain, each child will find and remove its closest parent, so that reduces excess walking.
                        break;

                        //when we hit a variable expression, we're definitely at the leftmost expression so stop
                    } else if (isVariableExpression(node) || isLiteralExpression(node) || isGroupingExpression(node)) {
                        break;
                    } else if (isDottedGetExpression(node) || isIndexedGetExpression(node)) {
                        node = node.obj;
                    } else {
                        //some expression we don't understand. log it and quit the loop
                        this.file.program.logger.debug('Encountered unknown expression while calculating function expression chain', node.kind, node.location);
                        break;
                    }
                }
            }
        };
        const visitVariableNameExpression = (e: VariableExpression | DottedGetExpression) => {
            if (!isDottedGetExpression(e.parent) && // not last expression in a dotted-get chain
                !isFunctionExpression(e) && // don't include function expressions
                !isNamespaceStatement(e.parent) && // don't include the name of namespace
                !isNewExpression(e.parent) && // don't include the inside of a new expression
                !(isCallExpression(e.parent) && e.parent?.callee === e) && // don't include the callee
                !util.isInTypeExpression(e)) {
                expressions.add(e);
            }
        };

        // eslint-disable-next-line @typescript-eslint/dot-notation
        this.file['_parser']?.ast.walk(createVisitor({
            AssignmentStatement: s => {
                assignmentStatements.push(s);
                expressions.add(s.value);
            },
            ClassStatement: s => {
                classStatements.push(s);
            },
            InterfaceStatement: s => {
                interfaceStatements.push(s);
            },
            FieldStatement: s => {
                if (s.initialValue) {
                    expressions.add(s.initialValue);
                }
            },
            NamespaceStatement: s => {
                namespaceStatements.push(s);
            },
            FunctionStatement: s => {
                functionStatements.push(s);
            },
            ImportStatement: s => {
                importStatements.push(s);
            },
            TypecastStatement: s => {
                typecastStatements.push(s);
            },
            LibraryStatement: s => {
                libraryStatements.push(s);
            },
            AliasStatement: s => {
                aliasStatements.push(s);
            },
            FunctionExpression: (expression, parent) => {
                if (!isMethodStatement(parent)) {
                    functionExpressions.push(expression);
                }
            },
            ExpressionStatement: s => {
                expressions.add(s.expression);
            },
            CallfuncExpression: e => {
                visitCallExpression(e);
            },
            CallExpression: e => {
                visitCallExpression(e);
            },
            AALiteralExpression: e => {
                addPropertyHints(e);
                expressions.add(e);
                for (const member of e.elements) {
                    if (isAAMemberExpression(member)) {
                        expressions.add(member.value);
                    }
                }
            },
            BinaryExpression: (e, parent) => {
                visitBinaryExpression(e);
            },
            ArrayLiteralExpression: e => {
                for (const element of e.elements) {
                    //keep everything except comments
                    expressions.add(element);
                }
            },
            DottedGetExpression: e => {
                visitVariableNameExpression(e);
                addPropertyHints(e.tokens.name);
            },
            DottedSetStatement: e => {
                addPropertyHints(e.tokens.name);
            },
            EnumStatement: e => {
                enumStatements.push(e);
            },
            ConstStatement: s => {
                constStatements.push(s);
            },
            UnaryExpression: e => {
                expressions.add(e);
            },
            IncrementStatement: e => {
                expressions.add(e);
            },
            VariableExpression: e => {
                visitVariableNameExpression(e);
            },
            AugmentedAssignmentStatement: e => {
                augmentedAssignmentStatements.push(e);
            }
        }), {
            // eslint-disable-next-line no-bitwise
            walkMode: WalkMode.visitAllRecursive | InternalWalkMode.visitFalseConditionalCompilationBlocks
        });

        this.cache.set('expressions', expressions);
        this.cache.set('classStatements', classStatements);
        this.cache.set('namespaceStatements', namespaceStatements);
        this.cache.set('namespaceStatements', namespaceStatements);
        this.cache.set('enumStatements', enumStatements);
        this.cache.set('constStatements', constStatements);
        this.cache.set('interfaceStatements', interfaceStatements);
        this.cache.set('assignmentStatements', assignmentStatements);
        this.cache.set('libraryStatements', libraryStatements);
        this.cache.set('importStatements', importStatements);
        this.cache.set('typecastStatements', typecastStatements);
        this.cache.set('aliasStatements', aliasStatements);
        this.cache.set('functionStatements', functionStatements);
        this.cache.set('functionExpressions', functionExpressions);
        this.cache.set('propertyHints', propertyHints);
        this.cache.set('augmentedAssignmentStatements', augmentedAssignmentStatements);
    }
}

1	import type { AALiteralExpression, BinaryExpression, CallExpression, CallfuncExpression, DottedGetExpression, FunctionExpression, VariableExpression } from '../parser/Expression';
2	import type { AliasStatement, AssignmentStatement, AugmentedAssignmentStatement, ClassStatement, ConstStatement, EnumStatement, FunctionStatement, ImportStatement, InterfaceStatement, LibraryStatement, NamespaceStatement, TypecastStatement } from '../parser/Statement';
3	import { Cache } from '../Cache';	1✔
4	import { InternalWalkMode, WalkMode, createVisitor } from './visitors';	1✔
5	import type { Expression } from '../parser/AstNode';
6	import { isAAMemberExpression, isBinaryExpression, isCallExpression, isDottedGetExpression, isFunctionExpression, isGroupingExpression, isIndexedGetExpression, isLiteralExpression, isMethodStatement, isNamespaceStatement, isNewExpression, isVariableExpression } from './reflection';	1✔
7	import type { Parser } from '../parser/Parser';
8	import { ParseMode } from '../parser/Parser';	1✔
9	import type { Token } from '../lexer/Token';
10	import { isToken } from '../lexer/Token';	1✔
11	import type { Program } from '../Program';
12	import util from '../util';	1✔
13
14
15	export interface BscFileLike {
16	program: Program;
17	_parser: Parser;
18	}
19
20	export class CachedLookups {	1✔
21
22	private cache = new Cache();	2,690✔
23
24	constructor(private file: BscFileLike) { }	2,690✔
25
26	get namespaceStatements(): NamespaceStatement[] {
27	return this.getFromCache<Array<NamespaceStatement>>('namespaceStatements');	14,166✔
28	}
29
30	get functionStatements(): FunctionStatement[] {
31	return this.getFromCache<Array<FunctionStatement>>('functionStatements');	1,723✔
32	}
33
34	get functionStatementMap() {
35	return this.cache.getOrAdd('functionStatementMap', () => {	17✔
36	const funcMap = new Map<string, FunctionStatement>();	15✔
37	for (const stmt of this.functionStatements) {	15✔
38	funcMap.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);	13✔
39	}
40	return funcMap;	15✔
41	});
42	}
43
44	get functionExpressions(): FunctionExpression[] {
45	return this.getFromCache<Array<FunctionExpression>>('functionExpressions');	83✔
46	}
47
48	get libraryStatements(): LibraryStatement[] {
49	return this.getFromCache<Array<LibraryStatement>>('libraryStatements');	1,765✔
50	}
51
52	get importStatements(): ImportStatement[] {
53	return this.getFromCache<Array<ImportStatement>>('importStatements');	5,509✔
54	}
55
56	get typecastStatements(): TypecastStatement[] {
57	return this.getFromCache<Array<TypecastStatement>>('typecastStatements');	1,765✔
58	}
59
60	get aliasStatements(): AliasStatement[] {
61	return this.getFromCache<Array<AliasStatement>>('aliasStatements');	12,408✔
62	}
63
64	/**
65	* A collection of full expressions. This excludes intermediary expressions.
66	*
67	* Example 1:
68	* `a.b.c` is composed of `a` (variableExpression) `.b` (DottedGetExpression) `.c` (DottedGetExpression)
69	* This will only contain the final `.c` DottedGetExpression because `.b` and `a` can both be derived by walking back from the `.c` DottedGetExpression.
70	*
71	* Example 2:
72	* `name.space.doSomething(a.b.c)` will result in 2 entries in this list. the `CallExpression` for `doSomething`, and the `.c` DottedGetExpression.
73	*
74	* Example 3:
75	* `value = SomeEnum.value > 2 or SomeEnum.otherValue < 10` will result in 4 entries. `SomeEnum.value`, `2`, `SomeEnum.otherValue`, `10`
76	*/
77	get expressions(): Set<Expression> {
78	return this.getFromCache<Set<Expression>>('expressions');	695✔
79	}
80
81	get classStatements(): ClassStatement[] {
82	return this.getFromCache<Array<ClassStatement>>('classStatements');	3,347✔
83	}
84
85	get classStatementMap() {
86	return this.cache.getOrAdd('classStatementMap', () => {	312✔
87	const classMap = new Map<string, ClassStatement>();	178✔
88	for (const stmt of this.classStatements) {	178✔
89	classMap.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);	5✔
90	}
91	return classMap;	178✔
92	});
93	}
94
95	get assignmentStatements(): AssignmentStatement[] {
96	return this.getFromCache<Array<AssignmentStatement>>('assignmentStatements');	83✔
97	}
98
99	get augmentedAssignmentStatements(): AugmentedAssignmentStatement[] {
100	return this.getFromCache<Array<AugmentedAssignmentStatement>>('augmentedAssignmentStatements');	×
101	}
102
103	get enumStatements(): EnumStatement[] {
104	return this.getFromCache<Array<EnumStatement>>('enumStatements');	254✔
105	}
106
107	get enumStatementMap() {
108	return this.cache.getOrAdd('enumStatementMap', () => {	57✔
109	const enumMap = new Map<string, EnumStatement>();	37✔
110	for (const stmt of this.enumStatements) {	37✔
111	enumMap.set(stmt.fullName.toLowerCase(), stmt);	1✔
112	}
113	return enumMap;	37✔
114	});
115	}
116
117	get constStatements(): ConstStatement[] {
118	return this.getFromCache<Array<ConstStatement>>('constStatements');	255✔
119	}
120
121	get constStatementMap() {
122	return this.cache.getOrAdd('constStatementMap', () => {	32✔
123	const constMap = new Map<string, ConstStatement>();	21✔
124	for (const stmt of this.constStatements) {	21✔
UNCOV 125	constMap.set(stmt.fullName.toLowerCase(), stmt);	×
126	}
127	return constMap;	21✔
128	});
129	}
130
131	get interfaceStatements(): InterfaceStatement[] {
132	return this.getFromCache<Array<InterfaceStatement>>('interfaceStatements');	11✔
133	}
134
135	get interfaceStatementMap() {
UNCOV 136	return this.cache.getOrAdd('interfaceStatementMap', () => {	×
UNCOV 137	const ifaceMap = new Map<string, InterfaceStatement>();	×
UNCOV 138	for (const stmt of this.interfaceStatements) {	×
UNCOV 139	ifaceMap.set(stmt.fullName.toLowerCase(), stmt);	×
140	}
UNCOV 141	return ifaceMap;	×
142	});
143	}
144
145	get propertyHints(): Record<string, string> {
146	return this.getFromCache<Record<string, string>>('propertyHints');	7✔
147	}
148
149
150	invalidate() {
151	this.cache.clear();	1,767✔
152	}
153
154
155	private getFromCache<T>(cacheKey: string): T {
156	if (!this.cache.has(cacheKey)) {	42,071✔
157	this.rehydrate();	4,144✔
158	}
159	if (!this.cache.has(cacheKey)) {	42,071!
160	this.file.program.logger.info('Unable to get cached lookup', cacheKey);	×
161	}
162	return this.cache.get(cacheKey);	42,071✔
163	}
164
165	private rehydrate() {
166	const expressions = new Set<Expression>();	4,144✔
167	const classStatements: ClassStatement[] = [];	4,144✔
168	const namespaceStatements: NamespaceStatement[] = [];	4,144✔
169	const enumStatements: EnumStatement[] = [];	4,144✔
170	const constStatements: ConstStatement[] = [];	4,144✔
171	const interfaceStatements: InterfaceStatement[] = [];	4,144✔
172	const assignmentStatements: AssignmentStatement[] = [];	4,144✔
173	const libraryStatements: LibraryStatement[] = [];	4,144✔
174	const importStatements: ImportStatement[] = [];	4,144✔
175	const typecastStatements: TypecastStatement[] = [];	4,144✔
176	const aliasStatements: AliasStatement[] = [];	4,144✔
177	const functionStatements: FunctionStatement[] = [];	4,144✔
178	const functionExpressions: FunctionExpression[] = [];	4,144✔
179
180	const augmentedAssignmentStatements: AugmentedAssignmentStatement[] = [];	4,144✔
181
182	const propertyHints: Record<string, string> = {};	4,144✔
183	const addPropertyHints = (item: Token \| AALiteralExpression) => {	4,144✔
184	if (isToken(item)) {	4,495✔
185	const name = item.text;	4,168✔
186	propertyHints[name.toLowerCase()] = name;	4,168✔
187	} else {
188	for (const member of item.elements) {	327✔
189	const name = member.tokens.key.text;	319✔
190	if (!name.startsWith('"')) {	319✔
191	propertyHints[name.toLowerCase()] = name;	304✔
192	}
193
194	}
195	}
196	};
197
198	const excludedExpressions = new Set<Expression>();	4,144✔
199
200	const visitBinaryExpression = (e: BinaryExpression) => {	4,144✔
201	//walk the chain of binary expressions and add each one to the list of expressions
202	const expressionsParts: Expression[] = [e];	3,461✔
203	let expression: Expression;
204	while ((expression = expressionsParts.pop())) {	3,461✔
205	if (isBinaryExpression(expression)) {	11,915✔
206	expressionsParts.push(expression.left, expression.right);	4,227✔
207	} else {
208	expressions.add(expression);	7,688✔
209	}
210	}
211	};
212
213	const visitCallExpression = (e: CallExpression \| CallfuncExpression) => {	4,144✔
214	for (const p of e.args) {	3,384✔
215	expressions.add(p);	2,478✔
216	}
217	//add calls that were not excluded (from loop below)
218	if (!excludedExpressions.has(e)) {	3,384✔
219	expressions.add(e);	3,298✔
220	}
221
222	//if this call is part of a longer expression that includes a call higher up, find that higher one and remove it
223	if (e.callee) {	3,384!
224	let node: Expression = e.callee;	3,384✔
225	while (node) {	3,384✔
226	//the primary goal for this loop. If we found a parent call expression, remove it from `references`
227	if (isCallExpression(node)) {	5,058✔
228	expressions.delete(node);	86✔
229	excludedExpressions.add(node);	86✔
230	//stop here. even if there are multiple calls in the chain, each child will find and remove its closest parent, so that reduces excess walking.
231	break;	86✔
232
233	//when we hit a variable expression, we're definitely at the leftmost expression so stop
234	} else if (isVariableExpression(node) \|\| isLiteralExpression(node) \|\| isGroupingExpression(node)) {	4,972✔
235	break;	3,229✔
236	} else if (isDottedGetExpression(node) \|\| isIndexedGetExpression(node)) {	1,743✔
237	node = node.obj;	1,674✔
238	} else {
239	//some expression we don't understand. log it and quit the loop
240	this.file.program.logger.debug('Encountered unknown expression while calculating function expression chain', node.kind, node.location);	69✔
241	break;	69✔
242	}
243	}
244	}
245	};
246	const visitVariableNameExpression = (e: VariableExpression \| DottedGetExpression) => {	4,144✔
247	if (!isDottedGetExpression(e.parent) && // not last expression in a dotted-get chain	18,176✔
248	!isFunctionExpression(e) && // don't include function expressions
249	!isNamespaceStatement(e.parent) && // don't include the name of namespace
250	!isNewExpression(e.parent) && // don't include the inside of a new expression
251	!(isCallExpression(e.parent) && e.parent?.callee === e) && // don't include the callee	30,192!
252	!util.isInTypeExpression(e)) {
253	expressions.add(e);	7,435✔
254	}
255	};
256
257	// eslint-disable-next-line @typescript-eslint/dot-notation
258	this.file['_parser']?.ast.walk(createVisitor({	4,144✔
259	AssignmentStatement: s => {
260	assignmentStatements.push(s);	1,791✔
261	expressions.add(s.value);	1,791✔
262	},
263	ClassStatement: s => {
264	classStatements.push(s);	853✔
265	},
266	InterfaceStatement: s => {
267	interfaceStatements.push(s);	292✔
268	},
269	FieldStatement: s => {
270	if (s.initialValue) {	435✔
271	expressions.add(s.initialValue);	140✔
272	}
273	},
274	NamespaceStatement: s => {
275	namespaceStatements.push(s);	1,207✔
276	},
277	FunctionStatement: s => {
278	functionStatements.push(s);	4,677✔
279	},
280	ImportStatement: s => {
281	importStatements.push(s);	398✔
282	},
283	TypecastStatement: s => {
284	typecastStatements.push(s);	42✔
285	},
286	LibraryStatement: s => {
287	libraryStatements.push(s);	11✔
288	},
289	AliasStatement: s => {
290	aliasStatements.push(s);	60✔
291	},
292	FunctionExpression: (expression, parent) => {
293	if (!isMethodStatement(parent)) {	5,243✔
294	functionExpressions.push(expression);	4,761✔
295	}
296	},
297	ExpressionStatement: s => {
298	expressions.add(s.expression);	919✔
299	},
300	CallfuncExpression: e => {
301	visitCallExpression(e);	96✔
302	},
303	CallExpression: e => {
304	visitCallExpression(e);	3,288✔
305	},
306	AALiteralExpression: e => {
307	addPropertyHints(e);	327✔
308	expressions.add(e);	327✔
309	for (const member of e.elements) {	327✔
310	if (isAAMemberExpression(member)) {	319!
311	expressions.add(member.value);	319✔
312	}
313	}
314	},
315	BinaryExpression: (e, parent) => {
316	visitBinaryExpression(e);	3,461✔
317	},
318	ArrayLiteralExpression: e => {
319	for (const element of e.elements) {	240✔
320	//keep everything except comments
321	expressions.add(element);	325✔
322	}
323	},
324	DottedGetExpression: e => {
325	visitVariableNameExpression(e);	3,960✔
326	addPropertyHints(e.tokens.name);	3,960✔
327	},
328	DottedSetStatement: e => {
329	addPropertyHints(e.tokens.name);	208✔
330	},
331	EnumStatement: e => {
332	enumStatements.push(e);	303✔
333	},
334	ConstStatement: s => {
335	constStatements.push(s);	296✔
336	},
337	UnaryExpression: e => {
338	expressions.add(e);	67✔
339	},
340	IncrementStatement: e => {
341	expressions.add(e);	24✔
342	},
343	VariableExpression: e => {
344	visitVariableNameExpression(e);	14,216✔
345	},
346	AugmentedAssignmentStatement: e => {
347	augmentedAssignmentStatements.push(e);	123✔
348	}
349	}), {
350	// eslint-disable-next-line no-bitwise
351	walkMode: WalkMode.visitAllRecursive \| InternalWalkMode.visitFalseConditionalCompilationBlocks
352	});
353
354	this.cache.set('expressions', expressions);	4,144✔
355	this.cache.set('classStatements', classStatements);	4,144✔
356	this.cache.set('namespaceStatements', namespaceStatements);	4,144✔
357	this.cache.set('namespaceStatements', namespaceStatements);	4,144✔
358	this.cache.set('enumStatements', enumStatements);	4,144✔
359	this.cache.set('constStatements', constStatements);	4,144✔
360	this.cache.set('interfaceStatements', interfaceStatements);	4,144✔
361	this.cache.set('assignmentStatements', assignmentStatements);	4,144✔
362	this.cache.set('libraryStatements', libraryStatements);	4,144✔
363	this.cache.set('importStatements', importStatements);	4,144✔
364	this.cache.set('typecastStatements', typecastStatements);	4,144✔
365	this.cache.set('aliasStatements', aliasStatements);	4,144✔
366	this.cache.set('functionStatements', functionStatements);	4,144✔
367	this.cache.set('functionExpressions', functionExpressions);	4,144✔
368	this.cache.set('propertyHints', propertyHints);	4,144✔
369	this.cache.set('augmentedAssignmentStatements', augmentedAssignmentStatements);	4,144✔
370	}
371	}

rokucommunity / brighterscript / #13949

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