#13306

Committed 22 Nov 2024 02:25PM UTC coverage: 86.801% (-1.4%) from 88.237%

Build Type

push

Committed by

Commit Message

Merge 332332a1f into 2a6afd921

Run Details

11833 of 14419 branches covered (82.07%)

Branch coverage included in aggregate %.

191 of 205 new or added lines in 26 files covered. (93.17%)

797 existing lines in 45 files now uncovered.

12868 of 14038 relevant lines covered (91.67%)

32022.05 hits per line

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

95.96

/src/parser/TranspileState.ts

import { SourceNode } from 'source-map';
import type { Location } from 'vscode-languageserver';
import type { BsConfig } from '../BsConfig';
import { TokenKind } from '../lexer/TokenKind';
import { type Token } from '../lexer/Token';
import type { RangeLike } from '../util';
import { util } from '../util';
import type { TranspileResult } from '../interfaces';

interface TranspileToken {
    location?: Location;
    text: string;
    kind?: TokenKind;
    leadingWhitespace?: string;
    leadingTrivia?: Array<TranspileToken>;
}

/**
 * Holds the state of a transpile operation as it works its way through the transpile process
 */
export class TranspileState {
    constructor(
        /**
         * The absolute path to the source location of this file. If sourceRoot is specified,
         * this path will be full path to the file in sourceRoot instead of rootDir.
         * If the file resides outside of rootDir, then no changes will be made to this path.
         */
        public srcPath: string,
        public options: BsConfig
    ) {
        this.srcPath = srcPath;

        //if a sourceRoot is specified, use that instead of the rootDir
        if (this.options.sourceRoot) {
            this.srcPath = this.srcPath.replace(
                this.options.rootDir,
                this.options.sourceRoot
            );
        }
    }

    public indentText = '';

    /**
     * Append whitespace until we reach the current blockDepth amount
     * @param blockDepthChange - if provided, this will add (or subtract if negative) the value to the block depth BEFORE getting the next indent amount.
     */
    public indent(blockDepthChange = 0) {
        this.blockDepth += blockDepthChange;
        return this.indentText;
    }

    /**
     * The number of active parent blocks for the current location of the state.
     */
    get blockDepth() {
        return this._blockDepth;
    }
    set blockDepth(value: number) {
        this._blockDepth = value;
        this.indentText = value === 0 ? '' : '    '.repeat(value);
    }
    private _blockDepth = 0;

    public newline = '\n';

    private getSource(locatable: RangeLike) {
        let srcPath = (locatable as { location: Location })?.location?.uri ?? (locatable as Location).uri;
        if (srcPath) {
            srcPath = util.uriToPath(srcPath);
            //if a sourceRoot is specified, use that instead of the rootDir
            if (this.options.sourceRoot) {
                srcPath = srcPath.replace(
                    this.options.rootDir,
                    this.options.sourceRoot
                );
            }
            return srcPath;
        } else {
            return this.srcPath;
        }
    }

    /**
     * Shorthand for creating a new source node
     */
    public sourceNode(locatable: RangeLike, code: string | SourceNode | TranspileResult): SourceNode {
        let range = util.extractRange(locatable);
        return util.sourceNodeFromTranspileResult(
            //convert 0-based range line to 1-based SourceNode line
            range ? range.start.line + 1 : null,
            //range and SourceNode character are both 0-based, so no conversion necessary
            range ? range.start.character : null,
            this.getSource(locatable),
            code
        );
    }

    /**
     * Create a SourceNode from a token. This is more efficient than the above `sourceNode` function
     * because the entire token is passed by reference, instead of the raw string being copied to the parameter,
     * only to then be copied again for the SourceNode constructor
     */
    public tokenToSourceNode(token: TranspileToken) {
        return new SourceNode(
            //convert 0-based range line to 1-based SourceNode line
            token.location?.range ? token.location.range.start.line + 1 : null,
            //range and SourceNode character are both 0-based, so no conversion necessary
            token.location?.range ? token.location.range.start.character : null,
            this.getSource(token),
            token.text
        );
    }

    public transpileLeadingCommentsForAstNode(node: { leadingTrivia?: Token[] }) {
        const leadingTrivia = node?.leadingTrivia ?? [];
        const leadingCommentsSourceNodes = this.transpileComments(leadingTrivia);
        if (leadingCommentsSourceNodes.length > 0) {
            // indent in preparation for next text
            leadingCommentsSourceNodes.push(this.indent());
        }

        return leadingCommentsSourceNodes;
    }

    public transpileLeadingComments(token: TranspileToken) {
        const leadingTrivia = (token?.leadingTrivia ?? []);
        const leadingCommentsSourceNodes = this.transpileComments(leadingTrivia);
        if (leadingCommentsSourceNodes.length > 0 && token.text) {
            // indent in preparation for next text
            leadingCommentsSourceNodes.push(this.indent());
        }

        return leadingCommentsSourceNodes;
    }

    public transpileComments(tokens: TranspileToken[], prepNextLine = false): Array<string | SourceNode> {
        const leadingCommentsSourceNodes = [];
        const justComments = tokens.filter(t => t.kind === TokenKind.Comment || t.kind === TokenKind.Newline);
        let newLinesSinceComment = 0;

        let transpiledCommentAlready = false;
        for (const commentToken of justComments) {
            if (commentToken.kind === TokenKind.Newline && !transpiledCommentAlready) {
                continue;
            }
            if (commentToken.kind === TokenKind.Comment) {
                if (leadingCommentsSourceNodes.length > 0) {
                    leadingCommentsSourceNodes.push(this.indent());
                }
                leadingCommentsSourceNodes.push(this.tokenToSourceNode(commentToken));
                newLinesSinceComment = 0;
            } else {
                newLinesSinceComment++;
            }

            if (newLinesSinceComment === 1 || newLinesSinceComment === 2) {
                //new line that is not touching a previous new line
                leadingCommentsSourceNodes.push(this.newline);
            }
            transpiledCommentAlready = true;
        }
        //if we should prepare for the next line, add an indent (only if applicable)
        if (prepNextLine && transpiledCommentAlready) {
            leadingCommentsSourceNodes.push(this.indent());
        }
        return leadingCommentsSourceNodes;
    }

    /**
     * Create a SourceNode from a token, accounting for missing range and multi-line text
     * Adds all leading trivia for the token
     */
    public transpileToken(token: TranspileToken, defaultValue?: string, commentOut = false, skipLeadingComments = false): TranspileResult {
        const leadingCommentsSourceNodes = skipLeadingComments ? [] : this.transpileLeadingComments(token);
        const commentIfCommentedOut = commentOut ? `'` : '';

        if (!token?.text && defaultValue !== undefined) {
            return [new SourceNode(null, null, null, [...leadingCommentsSourceNodes, commentIfCommentedOut, defaultValue])];
        }

        if (!token?.location?.range) {
            return [new SourceNode(null, null, null, [...leadingCommentsSourceNodes, commentIfCommentedOut, token.text])];
        }
        //split multi-line text
        if (token.location.range.end.line > token.location.range.start.line) {
            const lines = token.text.split(/\r?\n/g);
            const code = [
                this.sourceNode(token, [...leadingCommentsSourceNodes, commentIfCommentedOut, lines[0]])
            ] as Array<string | SourceNode>;
            for (let i = 1; i < lines.length; i++) {
                code.push(
                    this.newline,
                    commentIfCommentedOut,
                    new SourceNode(
                        //convert 0-based range line to 1-based SourceNode line
                        token.location.range.start.line + i + 1,
                        //SourceNode column is 0-based, and this starts at the beginning of the line
                        0,
                        this.getSource(token),
                        lines[i]
                    )
                );
            }
            return [new SourceNode(null, null, null, code)];
        } else {
            return [...leadingCommentsSourceNodes, commentIfCommentedOut, this.tokenToSourceNode(token)];
        }
    }

    public transpileEndBlockToken(previousLocatable: { location?: Location }, endToken: Token, defaultValue: string, alwaysAddNewlineBeforeEndToken = true) {
        const result = [];

        if (util.hasLeadingComments(endToken)) {
            // add comments before `end token` - they should be indented
            if (util.isLeadingCommentOnSameLine(previousLocatable?.location, endToken)) {
                this.blockDepth++;
                result.push(' ');
            } else {
                result.push(this.newline);
                result.push(this.indent(1));
            }
            result.push(...this.transpileToken({ ...endToken, text: '' }));
            this.blockDepth--;
            result.push(this.indent());
        } else if (alwaysAddNewlineBeforeEndToken) {
            result.push(this.newline, this.indent());
        }
        result.push(this.transpileToken({ ...endToken, leadingTrivia: [] }, defaultValue));
        return result;
    }
}

1	import { SourceNode } from 'source-map';	1✔
2	import type { Location } from 'vscode-languageserver';
3	import type { BsConfig } from '../BsConfig';
4	import { TokenKind } from '../lexer/TokenKind';	1✔
5	import { type Token } from '../lexer/Token';
6	import type { RangeLike } from '../util';
7	import { util } from '../util';	1✔
8	import type { TranspileResult } from '../interfaces';
9
10	interface TranspileToken {
11	location?: Location;
12	text: string;
13	kind?: TokenKind;
14	leadingWhitespace?: string;
15	leadingTrivia?: Array<TranspileToken>;
16	}
17
18	/**
19	* Holds the state of a transpile operation as it works its way through the transpile process
20	*/
21	export class TranspileState {	1✔
22	constructor(
23	/**
24	* The absolute path to the source location of this file. If sourceRoot is specified,
25	* this path will be full path to the file in sourceRoot instead of rootDir.
26	* If the file resides outside of rootDir, then no changes will be made to this path.
27	*/
28	public srcPath: string,	742✔
29	public options: BsConfig	742✔
30	) {
31	this.srcPath = srcPath;	742✔
32
33	//if a sourceRoot is specified, use that instead of the rootDir
34	if (this.options.sourceRoot) {	742✔
35	this.srcPath = this.srcPath.replace(	10✔
36	this.options.rootDir,
37	this.options.sourceRoot
38	);
39	}
40	}
41
42	public indentText = '';	742✔
43
44	/**
45	* Append whitespace until we reach the current blockDepth amount
46	* @param blockDepthChange - if provided, this will add (or subtract if negative) the value to the block depth BEFORE getting the next indent amount.
47	*/
48	public indent(blockDepthChange = 0) {	16,304✔
49	this.blockDepth += blockDepthChange;	16,394✔
50	return this.indentText;	16,394✔
51	}
52
53	/**
54	* The number of active parent blocks for the current location of the state.
55	*/
56	get blockDepth() {
57	return this._blockDepth;	25,538✔
58	}
59	set blockDepth(value: number) {
60	this._blockDepth = value;	25,538✔
61	this.indentText = value === 0 ? '' : ' '.repeat(value);	25,538✔
62	}
63	private _blockDepth = 0;	742✔
64
65	public newline = '\n';	742✔
66
67	private getSource(locatable: RangeLike) {
68	let srcPath = (locatable as { location: Location })?.location?.uri ?? (locatable as Location).uri;	53,753!
69	if (srcPath) {	53,753✔
70	srcPath = util.uriToPath(srcPath);	53,699✔
71	//if a sourceRoot is specified, use that instead of the rootDir
72	if (this.options.sourceRoot) {	53,699✔
73	srcPath = srcPath.replace(	710✔
74	this.options.rootDir,
75	this.options.sourceRoot
76	);
77	}
78	return srcPath;	53,699✔
79	} else {
80	return this.srcPath;	54✔
81	}
82	}
83
84	/**
85	* Shorthand for creating a new source node
86	*/
87	public sourceNode(locatable: RangeLike, code: string \| SourceNode \| TranspileResult): SourceNode {
88	let range = util.extractRange(locatable);	6,782✔
89	return util.sourceNodeFromTranspileResult(	6,782✔
90	//convert 0-based range line to 1-based SourceNode line
91	range ? range.start.line + 1 : null,	6,782✔
92	//range and SourceNode character are both 0-based, so no conversion necessary
93	range ? range.start.character : null,	6,782✔
94	this.getSource(locatable),
95	code
96	);
97	}
98
99	/**
100	* Create a SourceNode from a token. This is more efficient than the above `sourceNode` function
101	* because the entire token is passed by reference, instead of the raw string being copied to the parameter,
102	* only to then be copied again for the SourceNode constructor
103	*/
104	public tokenToSourceNode(token: TranspileToken) {
105	return new SourceNode(	46,967✔
106	//convert 0-based range line to 1-based SourceNode line
107	token.location?.range ? token.location.range.start.line + 1 : null,	187,868✔
108	//range and SourceNode character are both 0-based, so no conversion necessary
109	token.location?.range ? token.location.range.start.character : null,	187,868✔
110	this.getSource(token),
111	token.text
112	);
113	}
114
115	public transpileLeadingCommentsForAstNode(node: { leadingTrivia?: Token[] }) {
116	const leadingTrivia = node?.leadingTrivia ?? [];	38!
117	const leadingCommentsSourceNodes = this.transpileComments(leadingTrivia);	38✔
118	if (leadingCommentsSourceNodes.length > 0) {	38✔
119	// indent in preparation for next text
120	leadingCommentsSourceNodes.push(this.indent());	2✔
121	}
122
123	return leadingCommentsSourceNodes;	38✔
124	}
125
126	public transpileLeadingComments(token: TranspileToken) {
127	const leadingTrivia = (token?.leadingTrivia ?? []);	42,106✔
128	const leadingCommentsSourceNodes = this.transpileComments(leadingTrivia);	42,106✔
129	if (leadingCommentsSourceNodes.length > 0 && token.text) {	42,106✔
130	// indent in preparation for next text
131	leadingCommentsSourceNodes.push(this.indent());	1,803✔
132	}
133
134	return leadingCommentsSourceNodes;	42,106✔
135	}
136
137	public transpileComments(tokens: TranspileToken[], prepNextLine = false): Array<string \| SourceNode> {	42,162✔
138	const leadingCommentsSourceNodes = [];	42,162✔
139	const justComments = tokens.filter(t => t.kind === TokenKind.Comment \|\| t.kind === TokenKind.Newline);	45,913✔
140	let newLinesSinceComment = 0;	42,162✔
141
142	let transpiledCommentAlready = false;	42,162✔
143	for (const commentToken of justComments) {	42,162✔
144	if (commentToken.kind === TokenKind.Newline && !transpiledCommentAlready) {	19,803✔
145	continue;	7,209✔
146	}
147	if (commentToken.kind === TokenKind.Comment) {	12,594✔
148	if (leadingCommentsSourceNodes.length > 0) {	5,952✔
149	leadingCommentsSourceNodes.push(this.indent());	4,101✔
150	}
151	leadingCommentsSourceNodes.push(this.tokenToSourceNode(commentToken));	5,952✔
152	newLinesSinceComment = 0;	5,952✔
153	} else {
154	newLinesSinceComment++;	6,642✔
155	}
156
157	if (newLinesSinceComment === 1 \|\| newLinesSinceComment === 2) {	12,594✔
158	//new line that is not touching a previous new line
159	leadingCommentsSourceNodes.push(this.newline);	6,640✔
160	}
161	transpiledCommentAlready = true;	12,594✔
162	}
163	//if we should prepare for the next line, add an indent (only if applicable)
164	if (prepNextLine && transpiledCommentAlready) {	42,162!
UNCOV 165	leadingCommentsSourceNodes.push(this.indent());	×
166	}
167	return leadingCommentsSourceNodes;	42,162✔
168	}
169
170	/**
171	* Create a SourceNode from a token, accounting for missing range and multi-line text
172	* Adds all leading trivia for the token
173	*/
174	public transpileToken(token: TranspileToken, defaultValue?: string, commentOut = false, skipLeadingComments = false): TranspileResult {	80,982✔
175	const leadingCommentsSourceNodes = skipLeadingComments ? [] : this.transpileLeadingComments(token);	41,932✔
176	const commentIfCommentedOut = commentOut ? `'` : '';	41,932✔
177
178	if (!token?.text && defaultValue !== undefined) {	41,932✔
179	return [new SourceNode(null, null, null, [...leadingCommentsSourceNodes, commentIfCommentedOut, defaultValue])];	10✔
180	}
181
182	if (!token?.location?.range) {	41,922!
183	return [new SourceNode(null, null, null, [...leadingCommentsSourceNodes, commentIfCommentedOut, token.text])];	950✔
184	}
185	//split multi-line text
186	if (token.location.range.end.line > token.location.range.start.line) {	40,972✔
187	const lines = token.text.split(/\r?\n/g);	1✔
188	const code = [	1✔
189	this.sourceNode(token, [...leadingCommentsSourceNodes, commentIfCommentedOut, lines[0]])
190	] as Array<string \| SourceNode>;
191	for (let i = 1; i < lines.length; i++) {	1✔
192	code.push(	4✔
193	this.newline,
194	commentIfCommentedOut,
195	new SourceNode(
196	//convert 0-based range line to 1-based SourceNode line
197	token.location.range.start.line + i + 1,
198	//SourceNode column is 0-based, and this starts at the beginning of the line
199	0,
200	this.getSource(token),
201	lines[i]
202	)
203	);
204	}
205	return [new SourceNode(null, null, null, code)];	1✔
206	} else {
207	return [...leadingCommentsSourceNodes, commentIfCommentedOut, this.tokenToSourceNode(token)];	40,971✔
208	}
209	}
210
211	public transpileEndBlockToken(previousLocatable: { location?: Location }, endToken: Token, defaultValue: string, alwaysAddNewlineBeforeEndToken = true) {	4,247✔
212	const result = [];	4,358✔
213
214	if (util.hasLeadingComments(endToken)) {	4,358✔
215	// add comments before `end token` - they should be indented
216	if (util.isLeadingCommentOnSameLine(previousLocatable?.location, endToken)) {	28!
217	this.blockDepth++;	22✔
218	result.push(' ');	22✔
219	} else {
220	result.push(this.newline);	6✔
221	result.push(this.indent(1));	6✔
222	}
223	result.push(...this.transpileToken({ ...endToken, text: '' }));	28✔
224	this.blockDepth--;	28✔
225	result.push(this.indent());	28✔
226	} else if (alwaysAddNewlineBeforeEndToken) {	4,330✔
227	result.push(this.newline, this.indent());	4,272✔
228	}
229	result.push(this.transpileToken({ ...endToken, leadingTrivia: [] }, defaultValue));	4,358✔
230	return result;	4,358✔
231	}
232	}

rokucommunity / brighterscript / #13306

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