#12693

Committed 13 Jun 2024 07:53PM UTC coverage: 85.49%. Remained the same

Build Type

push

Committed by

Commit Message

Merge e1a9c5225 into 0bf57581a

Run Details

10839 of 13577 branches covered (79.83%)

Branch coverage included in aggregate %.

252 of 277 new or added lines in 29 files covered. (90.97%)

255 existing lines in 10 files now uncovered.

12263 of 13446 relevant lines covered (91.2%)

26471.0 hits per line

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

74.5

/src/bscPlugin/definition/DefinitionProvider.ts

import { isBrsFile, isClassStatement, isDottedGetExpression, isNamespaceStatement, isVariableExpression, isXmlFile, isXmlScope } from '../../astUtils/reflection';
import type { BrsFile } from '../../files/BrsFile';
import type { ProvideDefinitionEvent } from '../../interfaces';
import { TokenKind } from '../../lexer/TokenKind';
import type { Location } from 'vscode-languageserver-protocol';
import type { ClassStatement, FunctionStatement, NamespaceStatement } from '../../parser/Statement';
import { ParseMode } from '../../parser/Parser';
import util from '../../util';
import { URI } from 'vscode-uri';
import { WalkMode, createVisitor } from '../../astUtils/visitors';
import type { Token } from '../../lexer/Token';
import type { XmlFile } from '../../files/XmlFile';

export class DefinitionProvider {
    constructor(
        private event: ProvideDefinitionEvent
    ) { }

    public process(): Location[] {
        if (isBrsFile(this.event.file)) {
            this.brsFileGetDefinition(this.event.file);
        } else if (isXmlFile(this.event.file)) {
            this.xmlFileGetDefinition(this.event.file);
        }
        return this.event.definitions;
    }

    /**
     * For a position in a BrsFile, get the location where the token at that position was defined
     */
    private brsFileGetDefinition(file: BrsFile): void {
        //get the token at the position
        const token = file.getTokenAt(this.event.position);

        // While certain other tokens are allowed as local variables (AllowedLocalIdentifiers: https://github.com/rokucommunity/brighterscript/blob/master/src/lexer/TokenKind.ts#L418), these are converted by the parser to TokenKind.Identifier by the time we retrieve the token using getTokenAt
        let definitionTokenTypes = [
            TokenKind.Identifier,
            TokenKind.StringLiteral
        ];

        //throw out invalid tokens and the wrong kind of tokens
        if (!token || !definitionTokenTypes.includes(token.kind)) {
            return;
        }

        const scopesForFile = this.event.program.getScopesForFile(file);
        const [scope] = scopesForFile;

        const expression = file.getClosestExpression(this.event.position);
        if (scope && expression) {
            scope.linkSymbolTable();
            let containingNamespace = expression.findAncestor<NamespaceStatement>(isNamespaceStatement)?.getName(ParseMode.BrighterScript);
            const fullName = util.getAllDottedGetParts(expression)?.map(x => x.text).join('.');

            //find a constant with this name
            const constant = scope?.getConstFileLink(fullName, containingNamespace);
            if (constant) {
                this.event.definitions.push(
                    util.createLocationFromRange(
                        URI.file(constant.file.srcPath).toString(),
                        constant.item.tokens.name?.location?.range
                    )
                );
                return;
            }
            if (isDottedGetExpression(expression) || isVariableExpression(expression)) {

                const enumLink = scope.getEnumFileLink(fullName, containingNamespace);
                if (enumLink) {
                    this.event.definitions.push(
                        util.createLocationFromRange(
                            URI.file(enumLink.file.srcPath).toString(),
                            enumLink.item.tokens.name.location?.range
                        )
                    );
                    return;
                }
                const enumMemberLink = scope.getEnumMemberFileLink(fullName, containingNamespace);
                if (enumMemberLink) {
                    this.event.definitions.push(
                        util.createLocationFromRange(
                            URI.file(enumMemberLink.file.srcPath).toString(),
                            enumMemberLink.item.tokens.name.location?.range
                        )
                    );
                    return;
                }

                const interfaceFileLink = scope.getInterfaceFileLink(fullName, containingNamespace);
                if (interfaceFileLink) {
                    this.event.definitions.push(
                        util.createLocationFromRange(
                            URI.file(interfaceFileLink.file.srcPath).toString(),
                            interfaceFileLink.item.tokens.name.location?.range
                        )
                    );
                    return;
                }

                const classFileLink = scope.getClassFileLink(fullName, containingNamespace);
                if (classFileLink) {
                    this.event.definitions.push(
                        util.createLocationFromRange(
                            URI.file(classFileLink.file.srcPath).toString(),
                            classFileLink.item.tokens.name.location?.range
                        )
                    );
                    return;
                }
            }
        }

        let textToSearchFor = token.text.toLowerCase();

        const previousToken = file.getTokenAt({ line: token.location?.range.start.line, character: token.location?.range.start.character });

        if (previousToken?.kind === TokenKind.Callfunc) {
            for (const scope of this.event.program.getScopes()) {
                //does this xml file declare this function in its interface?
                if (isXmlScope(scope)) {
                    const apiFunc = scope.xmlFile.ast?.componentElement?.interfaceElement?.functions?.find(x => x.name.toLowerCase() === textToSearchFor); // eslint-disable-line @typescript-eslint/no-loop-func
                    if (apiFunc) {
                        this.event.definitions.push(
                            util.createLocationFromRange(util.pathToUri(scope.xmlFile.srcPath), apiFunc.getAttribute('name').tokens.value.location?.range)
                        );
                        const callable = scope.getAllCallables().find((c) => c.callable.name.toLowerCase() === textToSearchFor); // eslint-disable-line @typescript-eslint/no-loop-func
                        if (callable) {
                            this.event.definitions.push(
                                util.createLocationFromRange(util.pathToUri((callable.callable.file as BrsFile).srcPath), callable.callable.functionStatement.tokens.name.location?.range)
                            );
                        }
                    }
                }
            }
            return;
        }

        // eslint-disable-next-line @typescript-eslint/dot-notation
        let classToken = file['getTokenBefore'](token, TokenKind.Class);
        if (classToken) {
            let cs = file.parser.ast.findChild<ClassStatement>((klass) => isClassStatement(klass) && klass.tokens.class.location?.range === classToken.location?.range);
            if (cs?.parentClassName) {
                const nameParts = cs.parentClassName.getNameParts();
                let extendedClass = file.getClassFileLink(nameParts[nameParts.length - 1], nameParts.slice(0, -1).join('.'));
                if (extendedClass) {
                    this.event.definitions.push(util.createLocationFromRange(util.pathToUri(extendedClass.file.srcPath), extendedClass.item.location?.range));
                }
            }
            return;
        }

        if (token.kind === TokenKind.StringLiteral) {
            // We need to strip off the quotes but only if present
            const startIndex = textToSearchFor.startsWith('"') ? 1 : 0;

            let endIndex = textToSearchFor.length;
            if (textToSearchFor.endsWith('"')) {
                endIndex--;
            }
            textToSearchFor = textToSearchFor.substring(startIndex, endIndex);
        }

        //look through local variables first, get the function scope for this position (if it exists)
        const functionScope = file.getFunctionScopeAtPosition(this.event.position);
        if (functionScope) {
            //find any variable or label with this name
            for (const varDeclaration of functionScope.variableDeclarations) {
                //we found a variable declaration with this token text!
                if (varDeclaration.name.toLowerCase() === textToSearchFor) {
                    const uri = util.pathToUri(file.srcPath);
                    this.event.definitions.push(util.createLocationFromRange(uri, varDeclaration.nameRange));
                }
            }
            // eslint-disable-next-line @typescript-eslint/dot-notation
            if (file['tokenFollows'](token, TokenKind.Goto)) {
                for (const label of functionScope.labelStatements) {
                    if (label.name.toLocaleLowerCase() === textToSearchFor) {
                        const uri = util.pathToUri(file.srcPath);
                        this.event.definitions.push(util.createLocationFromRange(uri, label.nameRange));
                    }
                }
            }
        }

        const filesSearched = new Set<BrsFile>();
        //look through all files in scope for matches
        for (const scope of scopesForFile) {
            for (const file of scope.getAllFiles()) {
                if (!isBrsFile(file) || filesSearched.has(file)) {
                    continue;
                }
                filesSearched.add(file);

                if (previousToken?.kind === TokenKind.Dot && file.parseMode === ParseMode.BrighterScript) {
                    this.event.definitions.push(...file.getClassMemberDefinitions(textToSearchFor, file));
                    const namespaceDefinition = this.brsFileGetDefinitionsForNamespace(token, file);
                    if (namespaceDefinition) {
                        this.event.definitions.push(namespaceDefinition);
                    }
                }

                file.parser.ast.walk(createVisitor({
                    FunctionStatement: (statement: FunctionStatement) => {
                        if (statement.getName(file.parseMode).toLowerCase() === textToSearchFor) {
                            const uri = util.pathToUri(file.srcPath);
                            this.event.definitions.push(util.createLocationFromRange(uri, statement.location?.range));
                        }
                    }
                }), {
                    walkMode: WalkMode.visitStatements
                });
            }
        }
    }


    private brsFileGetDefinitionsForNamespace(token: Token, file: BrsFile): Location {
        //BrightScript does not support namespaces, so return an empty list in that case
        if (!token) {
            return undefined;
        }
        let location;

        const nameParts = (this.event.file as BrsFile).getPartialVariableName(token, [TokenKind.New]).split('.');
        const endName = nameParts[nameParts.length - 1].toLowerCase();
        const namespaceName = nameParts.slice(0, -1).join('.').toLowerCase();

        const statementHandler = (statement: NamespaceStatement) => {
            if (!location && statement.getName(ParseMode.BrighterScript).toLowerCase() === namespaceName) {
                const namespaceItemStatementHandler = (statement: ClassStatement | FunctionStatement) => {
                    if (!location && statement.tokens.name.text.toLowerCase() === endName) {
                        const uri = util.pathToUri(file.srcPath);
                        location = util.createLocationFromRange(uri, statement.location?.range);
                    }
                };

                file.parser.ast.walk(createVisitor({
                    ClassStatement: namespaceItemStatementHandler,
                    FunctionStatement: namespaceItemStatementHandler
                }), {
                    walkMode: WalkMode.visitStatements
                });

            }
        };

        file.parser.ast.walk(createVisitor({
            NamespaceStatement: statementHandler
        }), {
            walkMode: WalkMode.visitStatements
        });

        return location;
    }

    private xmlFileGetDefinition(file: XmlFile) {
        //if the position is within the file's parent component name
        if (
            isXmlFile(file) &&
            file.parentComponent &&
            file.parentComponentName &&
            util.rangeContains(file.parentComponentName.location?.range, this.event.position)
        ) {
            this.event.definitions.push({
                range: util.createRange(0, 0, 0, 0),
                uri: util.pathToUri(file.parentComponent.srcPath)
            });
        }
    }
}

1	import { isBrsFile, isClassStatement, isDottedGetExpression, isNamespaceStatement, isVariableExpression, isXmlFile, isXmlScope } from '../../astUtils/reflection';	1✔
2	import type { BrsFile } from '../../files/BrsFile';
3	import type { ProvideDefinitionEvent } from '../../interfaces';
4	import { TokenKind } from '../../lexer/TokenKind';	1✔
5	import type { Location } from 'vscode-languageserver-protocol';
6	import type { ClassStatement, FunctionStatement, NamespaceStatement } from '../../parser/Statement';
7	import { ParseMode } from '../../parser/Parser';	1✔
8	import util from '../../util';	1✔
9	import { URI } from 'vscode-uri';	1✔
10	import { WalkMode, createVisitor } from '../../astUtils/visitors';	1✔
11	import type { Token } from '../../lexer/Token';
12	import type { XmlFile } from '../../files/XmlFile';
13
14	export class DefinitionProvider {	1✔
15	constructor(
16	private event: ProvideDefinitionEvent	19✔
17	) { }
18
19	public process(): Location[] {
20	if (isBrsFile(this.event.file)) {	19✔
21	this.brsFileGetDefinition(this.event.file);	17✔
22	} else if (isXmlFile(this.event.file)) {	2✔
23	this.xmlFileGetDefinition(this.event.file);	1✔
24	}
25	return this.event.definitions;	19✔
26	}
27
28	/**
29	* For a position in a BrsFile, get the location where the token at that position was defined
30	*/
31	private brsFileGetDefinition(file: BrsFile): void {
32	//get the token at the position
33	const token = file.getTokenAt(this.event.position);	17✔
34
35	// While certain other tokens are allowed as local variables (AllowedLocalIdentifiers: https://github.com/rokucommunity/brighterscript/blob/master/src/lexer/TokenKind.ts#L418), these are converted by the parser to TokenKind.Identifier by the time we retrieve the token using getTokenAt
36	let definitionTokenTypes = [	17✔
37	TokenKind.Identifier,
38	TokenKind.StringLiteral
39	];
40
41	//throw out invalid tokens and the wrong kind of tokens
42	if (!token \|\| !definitionTokenTypes.includes(token.kind)) {	17✔
43	return;	2✔
44	}
45
46	const scopesForFile = this.event.program.getScopesForFile(file);	15✔
47	const [scope] = scopesForFile;	15✔
48
49	const expression = file.getClosestExpression(this.event.position);	15✔
50	if (scope && expression) {	15!
51	scope.linkSymbolTable();	15✔
52	let containingNamespace = expression.findAncestor<NamespaceStatement>(isNamespaceStatement)?.getName(ParseMode.BrighterScript);	15!
53	const fullName = util.getAllDottedGetParts(expression)?.map(x => x.text).join('.');	21✔
54
55	//find a constant with this name
56	const constant = scope?.getConstFileLink(fullName, containingNamespace);	15!
57	if (constant) {	15✔
58	this.event.definitions.push(	1✔
59	util.createLocationFromRange(
60	URI.file(constant.file.srcPath).toString(),
61	constant.item.tokens.name?.location?.range	6!
62	)
63	);
64	return;	1✔
65	}
66	if (isDottedGetExpression(expression) \|\| isVariableExpression(expression)) {	14✔
67
68	const enumLink = scope.getEnumFileLink(fullName, containingNamespace);	10✔
69	if (enumLink) {	10✔
70	this.event.definitions.push(	1✔
71	util.createLocationFromRange(
72	URI.file(enumLink.file.srcPath).toString(),
73	enumLink.item.tokens.name.location?.range	3!
74	)
75	);
76	return;	1✔
77	}
78	const enumMemberLink = scope.getEnumMemberFileLink(fullName, containingNamespace);	9✔
79	if (enumMemberLink) {	9✔
80	this.event.definitions.push(	1✔
81	util.createLocationFromRange(
82	URI.file(enumMemberLink.file.srcPath).toString(),
83	enumMemberLink.item.tokens.name.location?.range	3!
84	)
85	);
86	return;	1✔
87	}
88
89	const interfaceFileLink = scope.getInterfaceFileLink(fullName, containingNamespace);	8✔
90	if (interfaceFileLink) {	8✔
91	this.event.definitions.push(	2✔
92	util.createLocationFromRange(
93	URI.file(interfaceFileLink.file.srcPath).toString(),
94	interfaceFileLink.item.tokens.name.location?.range	6!
95	)
96	);
97	return;	2✔
98	}
99
100	const classFileLink = scope.getClassFileLink(fullName, containingNamespace);	6✔
101	if (classFileLink) {	6✔
102	this.event.definitions.push(	2✔
103	util.createLocationFromRange(
104	URI.file(classFileLink.file.srcPath).toString(),
105	classFileLink.item.tokens.name.location?.range	6!
106	)
107	);
108	return;	2✔
109	}
110	}
111	}
112
113	let textToSearchFor = token.text.toLowerCase();	8✔
114
115	const previousToken = file.getTokenAt({ line: token.location?.range.start.line, character: token.location?.range.start.character });	8!
116
117	if (previousToken?.kind === TokenKind.Callfunc) {	8!
118	for (const scope of this.event.program.getScopes()) {	2✔
119	//does this xml file declare this function in its interface?
120	if (isXmlScope(scope)) {	6✔
121	const apiFunc = scope.xmlFile.ast?.componentElement?.interfaceElement?.functions?.find(x => x.name.toLowerCase() === textToSearchFor); // eslint-disable-line @typescript-eslint/no-loop-func	2!
122	if (apiFunc) {	2✔
123	this.event.definitions.push(	1✔
124	util.createLocationFromRange(util.pathToUri(scope.xmlFile.srcPath), apiFunc.getAttribute('name').tokens.value.location?.range)	3!
125	);
126	const callable = scope.getAllCallables().find((c) => c.callable.name.toLowerCase() === textToSearchFor); // eslint-disable-line @typescript-eslint/no-loop-func	1✔
127	if (callable) {	1!
128	this.event.definitions.push(	1✔
129	util.createLocationFromRange(util.pathToUri((callable.callable.file as BrsFile).srcPath), callable.callable.functionStatement.tokens.name.location?.range)	3!
130	);
131	}
132	}
133	}
134	}
135	return;	2✔
136	}
137
138	// eslint-disable-next-line @typescript-eslint/dot-notation
139	let classToken = file['getTokenBefore'](token, TokenKind.Class);	6✔
140	if (classToken) {	6!
NEW 141	let cs = file.parser.ast.findChild<ClassStatement>((klass) => isClassStatement(klass) && klass.tokens.class.location?.range === classToken.location?.range);	×
142	if (cs?.parentClassName) {	×
143	const nameParts = cs.parentClassName.getNameParts();	×
144	let extendedClass = file.getClassFileLink(nameParts[nameParts.length - 1], nameParts.slice(0, -1).join('.'));	×
145	if (extendedClass) {	×
NEW 146	this.event.definitions.push(util.createLocationFromRange(util.pathToUri(extendedClass.file.srcPath), extendedClass.item.location?.range));	×
147	}
148	}
149	return;	×
150	}
151
152	if (token.kind === TokenKind.StringLiteral) {	6✔
153	// We need to strip off the quotes but only if present
154	const startIndex = textToSearchFor.startsWith('"') ? 1 : 0;	1!
155
156	let endIndex = textToSearchFor.length;	1✔
157	if (textToSearchFor.endsWith('"')) {	1!
158	endIndex--;	1✔
159	}
160	textToSearchFor = textToSearchFor.substring(startIndex, endIndex);	1✔
161	}
162
163	//look through local variables first, get the function scope for this position (if it exists)
164	const functionScope = file.getFunctionScopeAtPosition(this.event.position);	6✔
165	if (functionScope) {	6!
166	//find any variable or label with this name
167	for (const varDeclaration of functionScope.variableDeclarations) {	6✔
168	//we found a variable declaration with this token text!
169	if (varDeclaration.name.toLowerCase() === textToSearchFor) {	4✔
170	const uri = util.pathToUri(file.srcPath);	1✔
171	this.event.definitions.push(util.createLocationFromRange(uri, varDeclaration.nameRange));	1✔
172	}
173	}
174	// eslint-disable-next-line @typescript-eslint/dot-notation
175	if (file['tokenFollows'](token, TokenKind.Goto)) {	6✔
176	for (const label of functionScope.labelStatements) {	1✔
177	if (label.name.toLocaleLowerCase() === textToSearchFor) {	1!
178	const uri = util.pathToUri(file.srcPath);	1✔
179	this.event.definitions.push(util.createLocationFromRange(uri, label.nameRange));	1✔
180	}
181	}
182	}
183	}
184
185	const filesSearched = new Set<BrsFile>();	6✔
186	//look through all files in scope for matches
187	for (const scope of scopesForFile) {	6✔
188	for (const file of scope.getAllFiles()) {	6✔
189	if (!isBrsFile(file) \|\| filesSearched.has(file)) {	14✔
190	continue;	4✔
191	}
192	filesSearched.add(file);	10✔
193
194	if (previousToken?.kind === TokenKind.Dot && file.parseMode === ParseMode.BrighterScript) {	10!
195	this.event.definitions.push(...file.getClassMemberDefinitions(textToSearchFor, file));	2✔
196	const namespaceDefinition = this.brsFileGetDefinitionsForNamespace(token, file);	2✔
197	if (namespaceDefinition) {	2!
198	this.event.definitions.push(namespaceDefinition);	×
199	}
200	}
201
202	file.parser.ast.walk(createVisitor({	10✔
203	FunctionStatement: (statement: FunctionStatement) => {
204	if (statement.getName(file.parseMode).toLowerCase() === textToSearchFor) {	12✔
205	const uri = util.pathToUri(file.srcPath);	2✔
206	this.event.definitions.push(util.createLocationFromRange(uri, statement.location?.range));	2!
207	}
208	}
209	}), {
210	walkMode: WalkMode.visitStatements
211	});
212	}
213	}
214	}
215
216
217	private brsFileGetDefinitionsForNamespace(token: Token, file: BrsFile): Location {
218	//BrightScript does not support namespaces, so return an empty list in that case
219	if (!token) {	2!
220	return undefined;	×
221	}
222	let location;
223
224	const nameParts = (this.event.file as BrsFile).getPartialVariableName(token, [TokenKind.New]).split('.');	2✔
225	const endName = nameParts[nameParts.length - 1].toLowerCase();	2✔
226	const namespaceName = nameParts.slice(0, -1).join('.').toLowerCase();	2✔
227
228	const statementHandler = (statement: NamespaceStatement) => {	2✔
229	if (!location && statement.getName(ParseMode.BrighterScript).toLowerCase() === namespaceName) {	×
230	const namespaceItemStatementHandler = (statement: ClassStatement \| FunctionStatement) => {	×
231	if (!location && statement.tokens.name.text.toLowerCase() === endName) {	×
232	const uri = util.pathToUri(file.srcPath);	×
NEW 233	location = util.createLocationFromRange(uri, statement.location?.range);	×
234	}
235	};
236
237	file.parser.ast.walk(createVisitor({	×
238	ClassStatement: namespaceItemStatementHandler,
239	FunctionStatement: namespaceItemStatementHandler
240	}), {
241	walkMode: WalkMode.visitStatements
242	});
243
244	}
245	};
246
247	file.parser.ast.walk(createVisitor({	2✔
248	NamespaceStatement: statementHandler
249	}), {
250	walkMode: WalkMode.visitStatements
251	});
252
253	return location;	2✔
254	}
255
256	private xmlFileGetDefinition(file: XmlFile) {
257	//if the position is within the file's parent component name
258	if (	1!
259	isXmlFile(file) &&	4✔
260	file.parentComponent &&
261	file.parentComponentName &&
262	util.rangeContains(file.parentComponentName.location?.range, this.event.position)	3!
263	) {
264	this.event.definitions.push({	1✔
265	range: util.createRange(0, 0, 0, 0),
266	uri: util.pathToUri(file.parentComponent.srcPath)
267	});
268	}
269	}
270	}

rokucommunity / brighterscript / #12693

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