#15129

Committed 28 Jan 2026 03:47PM UTC coverage: 87.193% (-1.8%) from 88.969%

Build Type

push

Committed by

Commit Message

Merge aa579b555 into 610607efc

Run Details

14637 of 17741 branches covered (82.5%)

Branch coverage included in aggregate %.

69 of 71 new or added lines in 11 files covered. (97.18%)

825 existing lines in 47 files now uncovered.

15395 of 16702 relevant lines covered (92.17%)

24785.89 hits per line

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

93.38

/src/bscPlugin/semanticTokens/BrsFileSemanticTokensProcessor.ts

import { SemanticTokenModifiers } from 'vscode-languageserver-protocol';
import { SemanticTokenTypes } from 'vscode-languageserver-protocol';
import { isCallableType, isClassType, isComponentType, isConstStatement, isDottedGetExpression, isDynamicType, isEnumMemberType, isEnumType, isFunctionExpression, isFunctionStatement, isInterfaceType, isNamespaceType, isPrimitiveType, isVariableExpression } from '../../astUtils/reflection';
import type { BrsFile } from '../../files/BrsFile';
import type { ExtraSymbolData, ProvideSemanticTokensEvent, SemanticToken, TypeChainEntry } from '../../interfaces';
import type { Locatable, Token } from '../../lexer/Token';
import util from '../../util';
import { SymbolTypeFlag } from '../../SymbolTypeFlag';
import type { BscType } from '../../types/BscType';
import { WalkMode, createVisitor } from '../../astUtils/visitors';
import type { AstNode } from '../../parser/AstNode';

export class BrsFileSemanticTokensProcessor {
    public constructor(
        public event: ProvideSemanticTokensEvent<BrsFile>
    ) {

    }

    public process() {
        const scope = this.event.scopes[0];
        this.result.clear();
        if (scope) {
            scope.linkSymbolTable();
        }

        this.event.file.ast.walk(createVisitor({
            VariableExpression: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            AssignmentStatement: (node) => {
                this.addToken(node.tokens.name, SemanticTokenTypes.variable);
            },
            DottedGetExpression: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            ConstStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            AliasStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            ClassStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            InterfaceStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            EnumStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            FunctionStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            },
            FunctionParameterExpression: (node) => {
                this.addToken(node.tokens.name, SemanticTokenTypes.parameter);
            },
            TypeStatement: (node) => {
                this.tryAddToken(node, node.tokens.name);
            }
        }), {
            walkMode: WalkMode.visitAllRecursive
        });

        if (scope) {
            scope.unlinkSymbolTable();
        }

        //add all tokens to the event
        this.event.semanticTokens.push(
            ...this.result.values()
        );
    }

    private result = new Map<string, SemanticToken>();


    /**
     * Add the given token and node IF we have a resolvable type
     */
    private tryAddToken(node: AstNode, token: Token) {
        const extraData = {} as ExtraSymbolData;
        const chain = [] as TypeChainEntry[];
        // eslint-disable-next-line no-bitwise
        const symbolType = node.getType({ flags: SymbolTypeFlag.runtime, data: extraData, typeChain: chain });
        if (symbolType?.isResolvable()) {
            let info = this.getSemanticTokenInfo(node, symbolType, extraData);
            if (info) {
                //mark as deprecated if applicable
                if ((extraData.flags & SymbolTypeFlag.deprecated)) { // eslint-disable-line no-bitwise
                    info.modifiers ??= [];
                    info.modifiers.push(SemanticTokenModifiers.deprecated);
                }
                this.addToken(token, info.type, info.modifiers);
            }
        }
    }

    private addToken(locatable: Locatable, type: SemanticTokenTypes, modifiers: SemanticTokenModifiers[] = []) {
        //only keep a single token per range. Last-in wins
        this.result.set(util.rangeToString(locatable.location.range), {
            range: locatable.location.range,
            tokenType: type,
            tokenModifiers: modifiers
        });
    }

    private getSemanticTokenInfo(node: AstNode, type: BscType, extraData: ExtraSymbolData): { type: SemanticTokenTypes; modifiers?: SemanticTokenModifiers[] } {
        const isInTypeExpression = util.isInTypeExpression(node);

        if (isConstStatement(extraData?.definingNode)) {
            return { type: SemanticTokenTypes.variable, modifiers: [SemanticTokenModifiers.readonly, SemanticTokenModifiers.static] };
            // non-instances of classes should be colored like classes
        } else if (isClassType(type) && extraData.isInstance !== true) {
            return { type: SemanticTokenTypes.class };
            //function statements and expressions
        } else if (!isInTypeExpression && isCallableType(type)) {
            //if the typetime type is a class, then color this like a class
            const typetimeType = node.getType({ flags: SymbolTypeFlag.typetime });
            if (isClassType(typetimeType)) {
                return { type: SemanticTokenTypes.class };
            }
            //if this is a function statement or expression, treat it as a function
            if (isFunctionExpression(node) || isFunctionStatement(node)) {
                return { type: SemanticTokenTypes.function };
            }
            if (
                //if this is a standalone function
                isVariableExpression(node) ||
                //if this is a dottedGet, and the LHS is a namespace, treat it as a function.
                (isDottedGetExpression(node) && isNamespaceType(node.obj.getType({ flags: SymbolTypeFlag.typetime })))
            ) {
                if (!isDynamicType(type)) {
                    return { type: SemanticTokenTypes.function };
                }

                //all others should be treated as methods
            } else {
                return { type: SemanticTokenTypes.method };
            }
        } else if (isInterfaceType(type) && extraData.isInstance !== true) {
            return { type: SemanticTokenTypes.interface };
        } else if (isComponentType(type) && extraData.isInstance !== true) {
            return { type: SemanticTokenTypes.class };
        } else if (isEnumType(type)) {
            return { type: SemanticTokenTypes.enum };
        } else if (isEnumMemberType(type)) {
            return { type: SemanticTokenTypes.enumMember };
        } else if (isNamespaceType(type)) {
            return { type: SemanticTokenTypes.namespace };
            //this is separate from the checks above because we want to resolve alias lookups before turning this variable into a const
        } else if (isConstStatement(node)) {
            return { type: SemanticTokenTypes.variable, modifiers: [SemanticTokenModifiers.readonly, SemanticTokenModifiers.static] };
        } else if (isInTypeExpression && isPrimitiveType(type)) {
            // primitive types in type expressions should be already properly colored. do not add a semantic token
            return undefined;
        } else if (!isInTypeExpression && isVariableExpression(node)) {
            if (/m/i.test(node.tokens?.name?.text)) {
                //don't color `m` variables
            } else {
                return { type: SemanticTokenTypes.variable };
            }
        } else {
            //we don't know what it is...return undefined to prevent creating a semantic token
        }
    }
}

1	import { SemanticTokenModifiers } from 'vscode-languageserver-protocol';	1✔
2	import { SemanticTokenTypes } from 'vscode-languageserver-protocol';	1✔
3	import { isCallableType, isClassType, isComponentType, isConstStatement, isDottedGetExpression, isDynamicType, isEnumMemberType, isEnumType, isFunctionExpression, isFunctionStatement, isInterfaceType, isNamespaceType, isPrimitiveType, isVariableExpression } from '../../astUtils/reflection';	1✔
4	import type { BrsFile } from '../../files/BrsFile';
5	import type { ExtraSymbolData, ProvideSemanticTokensEvent, SemanticToken, TypeChainEntry } from '../../interfaces';
6	import type { Locatable, Token } from '../../lexer/Token';
7	import util from '../../util';	1✔
8	import { SymbolTypeFlag } from '../../SymbolTypeFlag';	1✔
9	import type { BscType } from '../../types/BscType';
10	import { WalkMode, createVisitor } from '../../astUtils/visitors';	1✔
11	import type { AstNode } from '../../parser/AstNode';
12
13	export class BrsFileSemanticTokensProcessor {	1✔
14	public constructor(
15	public event: ProvideSemanticTokensEvent<BrsFile>	26✔
16	) {
17
18	}
19
20	public process() {
21	const scope = this.event.scopes[0];	26✔
22	this.result.clear();	26✔
23	if (scope) {	26!
24	scope.linkSymbolTable();	26✔
25	}
26
27	this.event.file.ast.walk(createVisitor({	26✔
28	VariableExpression: (node) => {
29	this.tryAddToken(node, node.tokens.name);	70✔
30	},
31	AssignmentStatement: (node) => {
32	this.addToken(node.tokens.name, SemanticTokenTypes.variable);	9✔
33	},
34	DottedGetExpression: (node) => {
35	this.tryAddToken(node, node.tokens.name);	41✔
36	},
37	ConstStatement: (node) => {
38	this.tryAddToken(node, node.tokens.name);	4✔
39	},
40	AliasStatement: (node) => {
41	this.tryAddToken(node, node.tokens.name);	1✔
42	},
43	ClassStatement: (node) => {
44	this.tryAddToken(node, node.tokens.name);	6✔
45	},
46	InterfaceStatement: (node) => {
47	this.tryAddToken(node, node.tokens.name);	3✔
48	},
49	EnumStatement: (node) => {
50	this.tryAddToken(node, node.tokens.name);	3✔
51	},
52	FunctionStatement: (node) => {
53	this.tryAddToken(node, node.tokens.name);	28✔
54	},
55	FunctionParameterExpression: (node) => {
56	this.addToken(node.tokens.name, SemanticTokenTypes.parameter);	12✔
57	},
58	TypeStatement: (node) => {
UNCOV 59	this.tryAddToken(node, node.tokens.name);	×
60	}
61	}), {
62	walkMode: WalkMode.visitAllRecursive
63	});
64
65	if (scope) {	26!
66	scope.unlinkSymbolTable();	26✔
67	}
68
69	//add all tokens to the event
70	this.event.semanticTokens.push(	26✔
71	...this.result.values()
72	);
73	}
74
75	private result = new Map<string, SemanticToken>();	26✔
76
77
78	/**
79	* Add the given token and node IF we have a resolvable type
80	*/
81	private tryAddToken(node: AstNode, token: Token) {
82	const extraData = {} as ExtraSymbolData;	156✔
83	const chain = [] as TypeChainEntry[];	156✔
84	// eslint-disable-next-line no-bitwise
85	const symbolType = node.getType({ flags: SymbolTypeFlag.runtime, data: extraData, typeChain: chain });	156✔
86	if (symbolType?.isResolvable()) {	156!
87	let info = this.getSemanticTokenInfo(node, symbolType, extraData);	152✔
88	if (info) {	152✔
89	//mark as deprecated if applicable
90	if ((extraData.flags & SymbolTypeFlag.deprecated)) { // eslint-disable-line no-bitwise	136✔
91	info.modifiers ??= [];	1!
92	info.modifiers.push(SemanticTokenModifiers.deprecated);	1✔
93	}
94	this.addToken(token, info.type, info.modifiers);	136✔
95	}
96	}
97	}
98
99	private addToken(locatable: Locatable, type: SemanticTokenTypes, modifiers: SemanticTokenModifiers[] = []) {	148✔
100	//only keep a single token per range. Last-in wins
101	this.result.set(util.rangeToString(locatable.location.range), {	157✔
102	range: locatable.location.range,
103	tokenType: type,
104	tokenModifiers: modifiers
105	});
106	}
107
108	private getSemanticTokenInfo(node: AstNode, type: BscType, extraData: ExtraSymbolData): { type: SemanticTokenTypes; modifiers?: SemanticTokenModifiers[] } {
109	const isInTypeExpression = util.isInTypeExpression(node);	152✔
110
111	if (isConstStatement(extraData?.definingNode)) {	152!
112	return { type: SemanticTokenTypes.variable, modifiers: [SemanticTokenModifiers.readonly, SemanticTokenModifiers.static] };	4✔
113	// non-instances of classes should be colored like classes
114	} else if (isClassType(type) && extraData.isInstance !== true) {	148✔
115	return { type: SemanticTokenTypes.class };	10✔
116	//function statements and expressions
117	} else if (!isInTypeExpression && isCallableType(type)) {	138✔
118	//if the typetime type is a class, then color this like a class
119	const typetimeType = node.getType({ flags: SymbolTypeFlag.typetime });	44✔
120	if (isClassType(typetimeType)) {	44✔
121	return { type: SemanticTokenTypes.class };	1✔
122	}
123	//if this is a function statement or expression, treat it as a function
124	if (isFunctionExpression(node) \|\| isFunctionStatement(node)) {	43✔
125	return { type: SemanticTokenTypes.function };	28✔
126	}
127	if (	15✔
128	//if this is a standalone function
129	isVariableExpression(node) \|\|	33✔
130	//if this is a dottedGet, and the LHS is a namespace, treat it as a function.
131	(isDottedGetExpression(node) && isNamespaceType(node.obj.getType({ flags: SymbolTypeFlag.typetime })))
132	) {
133	if (!isDynamicType(type)) {	12✔
134	return { type: SemanticTokenTypes.function };	10✔
135	}
136
137	//all others should be treated as methods
138	} else {
139	return { type: SemanticTokenTypes.method };	3✔
140	}
141	} else if (isInterfaceType(type) && extraData.isInstance !== true) {	94✔
142	return { type: SemanticTokenTypes.interface };	3✔
143	} else if (isComponentType(type) && extraData.isInstance !== true) {	91!
UNCOV 144	return { type: SemanticTokenTypes.class };	×
145	} else if (isEnumType(type)) {	91✔
146	return { type: SemanticTokenTypes.enum };	6✔
147	} else if (isEnumMemberType(type)) {	85✔
148	return { type: SemanticTokenTypes.enumMember };	2✔
149	} else if (isNamespaceType(type)) {	83✔
150	return { type: SemanticTokenTypes.namespace };	57✔
151	//this is separate from the checks above because we want to resolve alias lookups before turning this variable into a const
152	} else if (isConstStatement(node)) {	26✔
153	return { type: SemanticTokenTypes.variable, modifiers: [SemanticTokenModifiers.readonly, SemanticTokenModifiers.static] };	4✔
154	} else if (isInTypeExpression && isPrimitiveType(type)) {	22✔
155	// primitive types in type expressions should be already properly colored. do not add a semantic token
156	return undefined;	8✔
157	} else if (!isInTypeExpression && isVariableExpression(node)) {	14✔
158	if (/m/i.test(node.tokens?.name?.text)) {	11!
159	//don't color `m` variables
160	} else {
161	return { type: SemanticTokenTypes.variable };	8✔
162	}
163	} else {
164	//we don't know what it is...return undefined to prevent creating a semantic token
165	}
166	}
167	}

rokucommunity / brighterscript / #15129

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