Build has been canceled!

#14415

Committed 15 May 2025 01:00PM UTC coverage: 86.989% (-0.01%) from 87.001%

Build # #14415

Build Type

push

Committed by

web-flow

Commit Message

Merge 6d205e1f4 into a194c3925

Coverage Stats

13888 of 16873 branches covered (82.31%)

Branch coverage included in aggregate %.

158 of 175 new or added lines in 11 files covered. (90.29%)

136 existing lines in 10 files now uncovered.

14734 of 16030 relevant lines covered (91.92%)

21931.75 hits per line

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

93.44

/src/parser/AstNode.ts

import type { WalkVisitor, WalkOptions } from '../astUtils/visitors';
import { WalkMode } from '../astUtils/visitors';
import type { Location, Position } from 'vscode-languageserver';
import { CancellationTokenSource } from 'vscode-languageserver';
import { InternalWalkMode } from '../astUtils/visitors';
import type { SymbolTable } from '../SymbolTable';
import type { BrsTranspileState } from './BrsTranspileState';
import type { GetTypeOptions, TranspileResult } from '../interfaces';
import type { AnnotationExpression } from './Expression';
import util from '../util';
import { DynamicType } from '../types/DynamicType';
import type { BscType } from '../types/BscType';
import type { Token } from '../lexer/Token';
import { isBlock, isBody } from '../astUtils/reflection';

/**
 * A BrightScript AST node
 */
export abstract class AstNode {
    public abstract kind: AstNodeKind;
    /**
     *  The starting and ending location of the node.
     */
    public abstract location?: Location | undefined;

    public abstract transpile(state: BrsTranspileState): TranspileResult;

    /**
     * Optional property, set at the top level with a map of conditional compile consts and their values
     */
    public bsConsts?: Map<string, boolean>;

    /**
     * When being considered by the walk visitor, this describes what type of element the current class is.
     */
    public visitMode = InternalWalkMode.visitStatements;

    public abstract walk(visitor: WalkVisitor, options: WalkOptions);

    /**
     * The parent node for this statement. This is set dynamically during `onFileValidate`, and should not be set directly.
     */
    public parent?: AstNode;

    /**
     * Certain expressions or statements can have a symbol table (such as blocks, functions, namespace bodies, etc).
     * If you're interested in getting the closest SymbolTable, use `getSymbolTable` instead.
     */
    public symbolTable?: SymbolTable;

    /**
     * Get the closest symbol table for this node
     */
    public getSymbolTable(): SymbolTable {
        let node: AstNode = this;
        while (node) {
            if (node.symbolTable) {
                return node.symbolTable;
            }
            node = node.parent!;
        }

        //justification: we are following a chain of nodes until we get to one with a SymbolTable,
        //and the top-level node will always have a SymbolTable. So we'll never hit this undefined,
        //but it is not so easy to convince the typechecker of this.
        return undefined as any;
    }

    /**
     * Walk upward and return the first node that results in `true` from the matcher.
     * @param matcher a function called for each node. If you return true, this function returns the specified node. If you return a node, that node is returned. all other return values continue the loop
     *                The function's second parameter is a cancellation token. If you'd like to short-circuit the walk, call `cancellationToken.cancel()`, then this function will return `undefined`
     */
    public findAncestor<TNode extends AstNode = AstNode>(matcher: (node: AstNode, cancellationToken: CancellationTokenSource) => boolean | AstNode | undefined | void): TNode | undefined {
        let node = this.parent;

        const cancel = new CancellationTokenSource();
        while (node) {
            let matcherValue = matcher(node, cancel);
            if (cancel.token.isCancellationRequested) {
                return;
            }
            if (matcherValue) {
                cancel.cancel();
                return (matcherValue === true ? node : matcherValue) as TNode;

            }
            node = node.parent;
        }
    }

    /**
     * Find the first child where the matcher evaluates to true.
     * @param matcher a function called for each node. If you return true, this function returns the specified node. If you return a node, that node is returned. all other return values continue the loop
     */
    public findChild<TNode = AstNode>(matcher: (node: AstNode, cancellationSource) => boolean | AstNode | undefined | void, options?: WalkOptions): TNode | undefined {
        const cancel = new CancellationTokenSource();
        let result: AstNode | undefined;
        this.walk((node) => {
            const matcherValue = matcher(node, cancel);
            if (matcherValue) {
                cancel.cancel();
                result = matcherValue === true ? node : matcherValue;
            }
        }, {
            walkMode: WalkMode.visitAllRecursive,
            ...options ?? {},
            cancel: cancel.token
        });
        return result as unknown as TNode;
    }

    /**
     * Find a list of all children first child where the matcher evaluates to true.
     * @param matcher a function called for each node. If you return true, the specified node is included in the results. If you return a node,
     * that node is returned. all other return values exclude that value and continue the loop
     */
    public findChildren<TNode extends AstNode = AstNode>(matcher: (node: AstNode, cancellationSource: CancellationTokenSource) => boolean | AstNode | undefined | void, options?: WalkOptions): Array<TNode> {
        const cancel = new CancellationTokenSource();
        let result: Array<AstNode> = [];
        this.walk((node) => {
            const matcherValue = matcher(node, cancel);
            if (matcherValue) {
                result.push(matcherValue === true ? node : matcherValue);
            }
        }, {
            walkMode: WalkMode.visitAllRecursive,
            ...options ?? {},
            cancel: cancel.token
        });
        return result as TNode[];
    }

    /**
     * FInd the deepest child that includes the given position
     */
    public findChildAtPosition<TNodeType extends AstNode = AstNode>(position: Position, options?: WalkOptions): TNodeType | undefined {
        return this.findChild<TNodeType>((node) => {
            //if the current node includes this range, keep that node
            if (util.rangeContains(node?.location.range, position)) {
                return node.findChildAtPosition(position, options) ?? node;
            }
        }, options);
    }

    /**
     * Get the BscType of this node.
     */
    public getType(options: GetTypeOptions): BscType {
        return DynamicType.instance;
    }

    /**
     * Links all child nodes to their parent AstNode, and the same with symbol tables. This performs a full AST walk, so you should use this sparingly
     */
    public link() {
        //the act of walking causes the nodes to be linked
        this.walk(() => { }, {
            // eslint-disable-next-line no-bitwise
            walkMode: WalkMode.visitAllRecursive | InternalWalkMode.visitFalseConditionalCompilationBlocks
        });
    }

    /**
     * Walk upward and return the root node
     */
    public getRoot() {
        let node = this as AstNode;

        while (node) {
            if (!node.parent) {
                return node;
            }
            node = node.parent;
        }
    }


    /**
     * Gets all the trivia (comments, whitespace) that is directly before the start of this node
     * Note: this includes all trivia that might start on the line of the previous node
     */
    public get leadingTrivia(): Token[] {
        return [];
    }

    /**
     * Gets any trivia that is directly before the end of the node
     * For example, this would return all trivia before a `end function` token of a FunctionExpression
     */
    public get endTrivia(): Token[] {
        return [];
    }

    public getBsConsts() {
        return this.bsConsts ?? this.parent?.getBsConsts?.();
    }

    /**
     * Clone this node and all of its children. This creates a completely detached and identical copy of the AST.
     * All tokens, statements, expressions, range, and location are cloned.
     */
    public abstract clone();

    /**
     * Helper function for creating a clone. This will clone any attached annotations, as well as reparent the cloned node's children to the clone
     */
    protected finalizeClone<T extends AstNode>(
        clone: T,
        propsToReparent?: Array<{ [K in keyof T]: T[K] extends AstNode | AstNode[] ? K : never }[keyof T]>
    ) {
        //clone the annotations if they exist
        if (Array.isArray((this as unknown as Statement).annotations)) {
            (clone as unknown as Statement).annotations = (this as unknown as Statement).annotations?.map(x => x.clone());
        }
        //reparent all of the supplied props
        for (let key of propsToReparent ?? []) {
            const children = (Array.isArray(clone?.[key]) ? clone[key] : [clone?.[key]]) as any[];
            for (let child of children ?? []) {
                if (child) {
                    (clone[key as any] as AstNode).parent = clone;
                }
            }
        }

        //reapply the location if we have one but the clone doesn't
        if (!clone.location && this.location) {
            clone.location = util.cloneLocation(this.location);
        }
        return clone;
    }

    /**
     * The index of the statement containing this node (or in the case of a statement, itself) within the containing block.
     */
    public get statementIndex(): number {
        if (isBody(this)) {
            return 0;
        }
        if (!this.parent) {
            return -1;
        }
        let currentNode: AstNode = this;
        while (currentNode && !(isBlock(currentNode?.parent) || isBody(currentNode?.parent))) {
            currentNode = currentNode.parent;
        }
        if (isBlock(currentNode?.parent) || isBody(currentNode?.parent)) {
            return currentNode.parent.statements.indexOf(currentNode);
        }
        return -1;
    }
}

export abstract class Statement extends AstNode {
    /**
     * When being considered by the walk visitor, this describes what type of element the current class is.
     */
    public visitMode = InternalWalkMode.visitStatements;
    /**
     * Annotations for this statement
     */
    public annotations?: AnnotationExpression[] | undefined;
}


/** A BrightScript expression */
export abstract class Expression extends AstNode {
    /**
     * When being considered by the walk visitor, this describes what type of element the current class is.
     */
    public visitMode = InternalWalkMode.visitExpressions;
}

export enum AstNodeKind {
    Body = 'Body',
    BinaryExpression = 'BinaryExpression',
    CallExpression = 'CallExpression',
    FunctionExpression = 'FunctionExpression',
    FunctionParameterExpression = 'FunctionParameterExpression',
    NamespacedVariableNameExpression = 'NamespacedVariableNameExpression',
    DottedGetExpression = 'DottedGetExpression',
    XmlAttributeGetExpression = 'XmlAttributeGetExpression',
    IndexedGetExpression = 'IndexedGetExpression',
    GroupingExpression = 'GroupingExpression',
    LiteralExpression = 'LiteralExpression',
    EscapedCharCodeLiteralExpression = 'EscapedCharCodeLiteralExpression',
    ArrayLiteralExpression = 'ArrayLiteralExpression',
    AAMemberExpression = 'AAMemberExpression',
    AALiteralExpression = 'AALiteralExpression',
    UnaryExpression = 'UnaryExpression',
    VariableExpression = 'VariableExpression',
    SourceLiteralExpression = 'SourceLiteralExpression',
    NewExpression = 'NewExpression',
    CallfuncExpression = 'CallfuncExpression',
    TemplateStringQuasiExpression = 'TemplateStringQuasiExpression',
    TemplateStringExpression = 'TemplateStringExpression',
    TaggedTemplateStringExpression = 'TaggedTemplateStringExpression',
    AnnotationExpression = 'AnnotationExpression',
    TernaryExpression = 'TernaryExpression',
    NullCoalescingExpression = 'NullCoalescingExpression',
    RegexLiteralExpression = 'RegexLiteralExpression',
    EmptyStatement = 'EmptyStatement',
    AssignmentStatement = 'AssignmentStatement',
    ExpressionStatement = 'ExpressionStatement',
    ExitStatement = 'ExitStatement',
    FunctionStatement = 'FunctionStatement',
    IfStatement = 'IfStatement',
    IncrementStatement = 'IncrementStatement',
    PrintStatement = 'PrintStatement',
    DimStatement = 'DimStatement',
    GotoStatement = 'GotoStatement',
    LabelStatement = 'LabelStatement',
    ReturnStatement = 'ReturnStatement',
    EndStatement = 'EndStatement',
    StopStatement = 'StopStatement',
    ForStatement = 'ForStatement',
    ForEachStatement = 'ForEachStatement',
    WhileStatement = 'WhileStatement',
    DottedSetStatement = 'DottedSetStatement',
    IndexedSetStatement = 'IndexedSetStatement',
    LibraryStatement = 'LibraryStatement',
    NamespaceStatement = 'NamespaceStatement',
    ImportStatement = 'ImportStatement',
    InterfaceStatement = 'InterfaceStatement',
    InterfaceFieldStatement = 'InterfaceFieldStatement',
    InterfaceMethodStatement = 'InterfaceMethodStatement',
    ClassStatement = 'ClassStatement',
    MethodStatement = 'MethodStatement',
    ClassMethodStatement = 'ClassMethodStatement',
    FieldStatement = 'FieldStatement',
    ClassFieldStatement = 'ClassFieldStatement',
    TryCatchStatement = 'TryCatchStatement',
    CatchStatement = 'CatchStatement',
    ThrowStatement = 'ThrowStatement',
    EnumStatement = 'EnumStatement',
    EnumMemberStatement = 'EnumMemberStatement',
    ConstStatement = 'ConstStatement',
    ContinueStatement = 'ContinueStatement',
    Block = 'Block',
    TypeExpression = 'TypeExpression',
    TypecastExpression = 'TypecastExpression',
    TypedArrayExpression = 'TypedArrayExpression',
    TypecastStatement = 'TypecastStatement',
    AliasStatement = 'AliasStatement',
    ConditionalCompileStatement = 'ConditionalCompileStatement',
    ConditionalCompileConstStatement = 'ConditionalCompileConstStatement',
    ConditionalCompileErrorStatement = 'ConditionalCompileErrorStatement',
    AugmentedAssignmentStatement = 'AugmentedAssignmentStatement',
    PrintSeparatorExpression = 'PrintSeparatorExpression'
}

1	import type { WalkVisitor, WalkOptions } from '../astUtils/visitors';
2	import { WalkMode } from '../astUtils/visitors';	1✔
3	import type { Location, Position } from 'vscode-languageserver';
4	import { CancellationTokenSource } from 'vscode-languageserver';	1✔
5	import { InternalWalkMode } from '../astUtils/visitors';	1✔
6	import type { SymbolTable } from '../SymbolTable';
7	import type { BrsTranspileState } from './BrsTranspileState';
8	import type { GetTypeOptions, TranspileResult } from '../interfaces';
9	import type { AnnotationExpression } from './Expression';
10	import util from '../util';	1✔
11	import { DynamicType } from '../types/DynamicType';	1✔
12	import type { BscType } from '../types/BscType';
13	import type { Token } from '../lexer/Token';
14	import { isBlock, isBody } from '../astUtils/reflection';	1✔
15
16	/**
17	* A BrightScript AST node
18	*/
19	export abstract class AstNode {	1✔
20	public abstract kind: AstNodeKind;
21	/**
22	* The starting and ending location of the node.
23	*/
24	public abstract location?: Location \| undefined;
25
26	public abstract transpile(state: BrsTranspileState): TranspileResult;
27
28	/**
29	* Optional property, set at the top level with a map of conditional compile consts and their values
30	*/
31	public bsConsts?: Map<string, boolean>;
32
33	/**
34	* When being considered by the walk visitor, this describes what type of element the current class is.
35	*/
36	public visitMode = InternalWalkMode.visitStatements;	74,911✔
37
38	public abstract walk(visitor: WalkVisitor, options: WalkOptions);
39
40	/**
41	* The parent node for this statement. This is set dynamically during `onFileValidate`, and should not be set directly.
42	*/
43	public parent?: AstNode;
44
45	/**
46	* Certain expressions or statements can have a symbol table (such as blocks, functions, namespace bodies, etc).
47	* If you're interested in getting the closest SymbolTable, use `getSymbolTable` instead.
48	*/
49	public symbolTable?: SymbolTable;
50
51	/**
52	* Get the closest symbol table for this node
53	*/
54	public getSymbolTable(): SymbolTable {
55	let node: AstNode = this;	185,745✔
56	while (node) {	185,745✔
57	if (node.symbolTable) {	477,236✔
58	return node.symbolTable;	185,745✔
59	}
60	node = node.parent!;	291,491✔
61	}
62
63	//justification: we are following a chain of nodes until we get to one with a SymbolTable,
64	//and the top-level node will always have a SymbolTable. So we'll never hit this undefined,
65	//but it is not so easy to convince the typechecker of this.
UNCOV 66	return undefined as any;	×
67	}
68
69	/**
70	* Walk upward and return the first node that results in `true` from the matcher.
71	* @param matcher a function called for each node. If you return true, this function returns the specified node. If you return a node, that node is returned. all other return values continue the loop
72	* The function's second parameter is a cancellation token. If you'd like to short-circuit the walk, call `cancellationToken.cancel()`, then this function will return `undefined`
73	*/
74	public findAncestor<TNode extends AstNode = AstNode>(matcher: (node: AstNode, cancellationToken: CancellationTokenSource) => boolean \| AstNode \| undefined \| void): TNode \| undefined {
75	let node = this.parent;	80,442✔
76
77	const cancel = new CancellationTokenSource();	80,442✔
78	while (node) {	80,442✔
79	let matcherValue = matcher(node, cancel);	299,331✔
80	if (cancel.token.isCancellationRequested) {	299,331✔
81	return;	1✔
82	}
83	if (matcherValue) {	299,330✔
84	cancel.cancel();	23,982✔
85	return (matcherValue === true ? node : matcherValue) as TNode;	23,982✔
86
87	}
88	node = node.parent;	275,348✔
89	}
90	}
91
92	/**
93	* Find the first child where the matcher evaluates to true.
94	* @param matcher a function called for each node. If you return true, this function returns the specified node. If you return a node, that node is returned. all other return values continue the loop
95	*/
96	public findChild<TNode = AstNode>(matcher: (node: AstNode, cancellationSource) => boolean \| AstNode \| undefined \| void, options?: WalkOptions): TNode \| undefined {
97	const cancel = new CancellationTokenSource();	1,882✔
98	let result: AstNode \| undefined;
99	this.walk((node) => {	1,882✔
100	const matcherValue = matcher(node, cancel);	4,466✔
101	if (matcherValue) {	4,466✔
102	cancel.cancel();	1,684✔
103	result = matcherValue === true ? node : matcherValue;	1,684✔
104	}
105	}, {
106	walkMode: WalkMode.visitAllRecursive,
107	...options ?? {},	5,646✔
108	cancel: cancel.token
109	});
110	return result as unknown as TNode;	1,882✔
111	}
112
113	/**
114	* Find a list of all children first child where the matcher evaluates to true.
115	* @param matcher a function called for each node. If you return true, the specified node is included in the results. If you return a node,
116	* that node is returned. all other return values exclude that value and continue the loop
117	*/
118	public findChildren<TNode extends AstNode = AstNode>(matcher: (node: AstNode, cancellationSource: CancellationTokenSource) => boolean \| AstNode \| undefined \| void, options?: WalkOptions): Array<TNode> {
119	const cancel = new CancellationTokenSource();	34✔
120	let result: Array<AstNode> = [];	34✔
121	this.walk((node) => {	34✔
122	const matcherValue = matcher(node, cancel);	480✔
123	if (matcherValue) {	480✔
124	result.push(matcherValue === true ? node : matcherValue);	73!
125	}
126	}, {
127	walkMode: WalkMode.visitAllRecursive,
128	...options ?? {},	102✔
129	cancel: cancel.token
130	});
131	return result as TNode[];	34✔
132	}
133
134	/**
135	* FInd the deepest child that includes the given position
136	*/
137	public findChildAtPosition<TNodeType extends AstNode = AstNode>(position: Position, options?: WalkOptions): TNodeType \| undefined {
138	return this.findChild<TNodeType>((node) => {	1,456✔
139	//if the current node includes this range, keep that node
140	if (util.rangeContains(node?.location.range, position)) {	3,034!
141	return node.findChildAtPosition(position, options) ?? node;	1,272✔
142	}
143	}, options);
144	}
145
146	/**
147	* Get the BscType of this node.
148	*/
149	public getType(options: GetTypeOptions): BscType {
150	return DynamicType.instance;	508✔
151	}
152
153	/**
154	* Links all child nodes to their parent AstNode, and the same with symbol tables. This performs a full AST walk, so you should use this sparingly
155	*/
156	public link() {
157	//the act of walking causes the nodes to be linked
158	this.walk(() => { }, {	3,936✔
159	// eslint-disable-next-line no-bitwise
160	walkMode: WalkMode.visitAllRecursive \| InternalWalkMode.visitFalseConditionalCompilationBlocks
161	});
162	}
163
164	/**
165	* Walk upward and return the root node
166	*/
167	public getRoot() {
168	let node = this as AstNode;	13,051✔
169
170	while (node) {	13,051✔
171	if (!node.parent) {	71,287✔
172	return node;	13,051✔
173	}
174	node = node.parent;	58,236✔
175	}
176	}
177
178
179	/**
180	* Gets all the trivia (comments, whitespace) that is directly before the start of this node
181	* Note: this includes all trivia that might start on the line of the previous node
182	*/
183	public get leadingTrivia(): Token[] {
184	return [];	6,993✔
185	}
186
187	/**
188	* Gets any trivia that is directly before the end of the node
189	* For example, this would return all trivia before a `end function` token of a FunctionExpression
190	*/
191	public get endTrivia(): Token[] {
192	return [];	35✔
193	}
194
195	public getBsConsts() {
196	return this.bsConsts ?? this.parent?.getBsConsts?.();	93,550✔
197	}
198
199	/**
200	* Clone this node and all of its children. This creates a completely detached and identical copy of the AST.
201	* All tokens, statements, expressions, range, and location are cloned.
202	*/
203	public abstract clone();
204
205	/**
206	* Helper function for creating a clone. This will clone any attached annotations, as well as reparent the cloned node's children to the clone
207	*/
208	protected finalizeClone<T extends AstNode>(
209	clone: T,
210	propsToReparent?: Array<{ [K in keyof T]: T[K] extends AstNode \| AstNode[] ? K : never }[keyof T]>
211	) {
212	//clone the annotations if they exist
213	if (Array.isArray((this as unknown as Statement).annotations)) {	976✔
214	(clone as unknown as Statement).annotations = (this as unknown as Statement).annotations?.map(x => x.clone());	7!
215	}
216	//reparent all of the supplied props
217	for (let key of propsToReparent ?? []) {	976✔
218	const children = (Array.isArray(clone?.[key]) ? clone[key] : [clone?.[key]]) as any[];	1,027!
219	for (let child of children ?? []) {	1,027!
220	if (child) {	1,048✔
221	(clone[key as any] as AstNode).parent = clone;	797✔
222	}
223	}
224	}
225
226	//reapply the location if we have one but the clone doesn't
227	if (!clone.location && this.location) {	976✔
228	clone.location = util.cloneLocation(this.location);	25✔
229	}
230	return clone;	976✔
231	}
232
233	/**
234	* The index of the statement containing this node (or in the case of a statement, itself) within the containing block.
235	*/
236	public get statementIndex(): number {
237	if (isBody(this)) {	25,756!
NEW 238	return 0;	×
239	}
240	if (!this.parent) {	25,756!
NEW 241	return -1;	×
242	}
243	let currentNode: AstNode = this;	25,756✔
244	while (currentNode && !(isBlock(currentNode?.parent) \|\| isBody(currentNode?.parent))) {	25,756!
245	currentNode = currentNode.parent;	62,337✔
246	}
247	if (isBlock(currentNode?.parent) \|\| isBody(currentNode?.parent)) {	25,756!
248	return currentNode.parent.statements.indexOf(currentNode);	25,756✔
249	}
NEW 250	return -1;	×
251	}
252	}
253
254	export abstract class Statement extends AstNode {	1✔
255	/**
256	* When being considered by the walk visitor, this describes what type of element the current class is.
257	*/
258	public visitMode = InternalWalkMode.visitStatements;	34,515✔
259	/**
260	* Annotations for this statement
261	*/
262	public annotations?: AnnotationExpression[] \| undefined;
263	}
264
265
266	/** A BrightScript expression */
267	export abstract class Expression extends AstNode {	1✔
268	/**
269	* When being considered by the walk visitor, this describes what type of element the current class is.
270	*/
271	public visitMode = InternalWalkMode.visitExpressions;	40,396✔
272	}
273
274	export enum AstNodeKind {	1✔
275	Body = 'Body',	1✔
276	BinaryExpression = 'BinaryExpression',	1✔
277	CallExpression = 'CallExpression',	1✔
278	FunctionExpression = 'FunctionExpression',	1✔
279	FunctionParameterExpression = 'FunctionParameterExpression',	1✔
280	NamespacedVariableNameExpression = 'NamespacedVariableNameExpression',	1✔
281	DottedGetExpression = 'DottedGetExpression',	1✔
282	XmlAttributeGetExpression = 'XmlAttributeGetExpression',	1✔
283	IndexedGetExpression = 'IndexedGetExpression',	1✔
284	GroupingExpression = 'GroupingExpression',	1✔
285	LiteralExpression = 'LiteralExpression',	1✔
286	EscapedCharCodeLiteralExpression = 'EscapedCharCodeLiteralExpression',	1✔
287	ArrayLiteralExpression = 'ArrayLiteralExpression',	1✔
288	AAMemberExpression = 'AAMemberExpression',	1✔
289	AALiteralExpression = 'AALiteralExpression',	1✔
290	UnaryExpression = 'UnaryExpression',	1✔
291	VariableExpression = 'VariableExpression',	1✔
292	SourceLiteralExpression = 'SourceLiteralExpression',	1✔
293	NewExpression = 'NewExpression',	1✔
294	CallfuncExpression = 'CallfuncExpression',	1✔
295	TemplateStringQuasiExpression = 'TemplateStringQuasiExpression',	1✔
296	TemplateStringExpression = 'TemplateStringExpression',	1✔
297	TaggedTemplateStringExpression = 'TaggedTemplateStringExpression',	1✔
298	AnnotationExpression = 'AnnotationExpression',	1✔
299	TernaryExpression = 'TernaryExpression',	1✔
300	NullCoalescingExpression = 'NullCoalescingExpression',	1✔
301	RegexLiteralExpression = 'RegexLiteralExpression',	1✔
302	EmptyStatement = 'EmptyStatement',	1✔
303	AssignmentStatement = 'AssignmentStatement',	1✔
304	ExpressionStatement = 'ExpressionStatement',	1✔
305	ExitStatement = 'ExitStatement',	1✔
306	FunctionStatement = 'FunctionStatement',	1✔
307	IfStatement = 'IfStatement',	1✔
308	IncrementStatement = 'IncrementStatement',	1✔
309	PrintStatement = 'PrintStatement',	1✔
310	DimStatement = 'DimStatement',	1✔
311	GotoStatement = 'GotoStatement',	1✔
312	LabelStatement = 'LabelStatement',	1✔
313	ReturnStatement = 'ReturnStatement',	1✔
314	EndStatement = 'EndStatement',	1✔
315	StopStatement = 'StopStatement',	1✔
316	ForStatement = 'ForStatement',	1✔
317	ForEachStatement = 'ForEachStatement',	1✔
318	WhileStatement = 'WhileStatement',	1✔
319	DottedSetStatement = 'DottedSetStatement',	1✔
320	IndexedSetStatement = 'IndexedSetStatement',	1✔
321	LibraryStatement = 'LibraryStatement',	1✔
322	NamespaceStatement = 'NamespaceStatement',	1✔
323	ImportStatement = 'ImportStatement',	1✔
324	InterfaceStatement = 'InterfaceStatement',	1✔
325	InterfaceFieldStatement = 'InterfaceFieldStatement',	1✔
326	InterfaceMethodStatement = 'InterfaceMethodStatement',	1✔
327	ClassStatement = 'ClassStatement',	1✔
328	MethodStatement = 'MethodStatement',	1✔
329	ClassMethodStatement = 'ClassMethodStatement',	1✔
330	FieldStatement = 'FieldStatement',	1✔
331	ClassFieldStatement = 'ClassFieldStatement',	1✔
332	TryCatchStatement = 'TryCatchStatement',	1✔
333	CatchStatement = 'CatchStatement',	1✔
334	ThrowStatement = 'ThrowStatement',	1✔
335	EnumStatement = 'EnumStatement',	1✔
336	EnumMemberStatement = 'EnumMemberStatement',	1✔
337	ConstStatement = 'ConstStatement',	1✔
338	ContinueStatement = 'ContinueStatement',	1✔
339	Block = 'Block',	1✔
340	TypeExpression = 'TypeExpression',	1✔
341	TypecastExpression = 'TypecastExpression',	1✔
342	TypedArrayExpression = 'TypedArrayExpression',	1✔
343	TypecastStatement = 'TypecastStatement',	1✔
344	AliasStatement = 'AliasStatement',	1✔
345	ConditionalCompileStatement = 'ConditionalCompileStatement',	1✔
346	ConditionalCompileConstStatement = 'ConditionalCompileConstStatement',	1✔
347	ConditionalCompileErrorStatement = 'ConditionalCompileErrorStatement',	1✔
348	AugmentedAssignmentStatement = 'AugmentedAssignmentStatement',	1✔
349	PrintSeparatorExpression = 'PrintSeparatorExpression'	1✔
350	}

rokucommunity / brighterscript / #14415

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