#15903

Committed 11 May 2026 06:41PM UTC coverage: 86.896% (-2.2%) from 89.094%

Build Type

push

Committed by

Commit Message

Merge 70dfd6181 into ce68f5cb7

Coverage Stats

15597 of 18958 branches covered (82.27%)

Branch coverage included in aggregate %.

9 of 9 new or added lines in 3 files covered. (100.0%)

955 existing lines in 53 files now uncovered.

16351 of 17808 relevant lines covered (91.82%)

27326.16 hits per line

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

93.68

/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, isFunctionParameterExpression } 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>;

    /**
     * Get the typedef for this node. (defaults to transpiling the node, should be overridden by subclasses if there's a more specific typedef requirement)
     */
    public getTypedef(state: BrsTranspileState) {
        return this.transpile(state);
    }

    /**
     * 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 `validateFile`, 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;
        if (isFunctionParameterExpression(currentNode)) {
            // function parameters are not part of statement lists
            return -1;
        }
        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',
    AAIndexedMemberExpression = 'AAIndexedMemberExpression',
    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',
    InlineInterfaceExpression = 'InlineInterfaceExpression',
    InlineInterfaceMemberExpression = 'InlineInterfaceMemberExpression',
    TypeStatement = 'TypeStatement',
    TypedFunctionTypeExpression = 'TypedFunctionTypeExpression'
}

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

rokucommunity / brighterscript / #15903

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