#12764

Committed 28 Jun 2024 07:37PM UTC coverage: 85.666%. Remained the same

Build Type

push

Committed by

Commit Message

Merge 0691af343 into 050a19173

Run Details

10876 of 13573 branches covered (80.13%)

Branch coverage included in aggregate %.

60 of 66 new or added lines in 7 files covered. (90.91%)

64 existing lines in 4 files now uncovered.

12307 of 13489 relevant lines covered (91.24%)

26517.36 hits per line

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

84.48

/src/diagnosticUtils.ts

import type { Chalk } from 'chalk';
import chalk from 'chalk';
import type { BsConfig } from './BsConfig';
import { DiagnosticSeverity } from 'vscode-languageserver';
import type { BsDiagnostic } from './interfaces';
import type { Range } from 'vscode-languageserver';

export const MAX_RELATED_INFOS_COUNT = 3;

/**
 * Prepare print diagnostic formatting options
 */
export function getPrintDiagnosticOptions(options: BsConfig) {
    let cwd = options?.cwd ? options.cwd : process.cwd();

    let emitFullPaths = options?.emitFullPaths === true;

    let diagnosticLevel = options?.diagnosticLevel ?? 'warn';

    let diagnosticSeverityMap = {} as Record<string, DiagnosticSeverity>;
    diagnosticSeverityMap.info = DiagnosticSeverity.Information;
    diagnosticSeverityMap.hint = DiagnosticSeverity.Hint;
    diagnosticSeverityMap.warn = DiagnosticSeverity.Warning;
    diagnosticSeverityMap.error = DiagnosticSeverity.Error;

    let severityLevel = diagnosticSeverityMap[diagnosticLevel] || DiagnosticSeverity.Warning;
    let order = [DiagnosticSeverity.Information, DiagnosticSeverity.Hint, DiagnosticSeverity.Warning, DiagnosticSeverity.Error];
    let includeDiagnostic = order.slice(order.indexOf(severityLevel)).reduce((acc, value) => {
        acc[value] = true;
        return acc;
    }, {});

    let typeColor = {} as Record<string, Chalk>;
    typeColor[DiagnosticSeverity.Information] = chalk.blue;
    typeColor[DiagnosticSeverity.Hint] = chalk.green;
    typeColor[DiagnosticSeverity.Warning] = chalk.yellow;
    typeColor[DiagnosticSeverity.Error] = chalk.red;

    let severityTextMap = {};
    severityTextMap[DiagnosticSeverity.Information] = 'info';
    severityTextMap[DiagnosticSeverity.Hint] = 'hint';
    severityTextMap[DiagnosticSeverity.Warning] = 'warning';
    severityTextMap[DiagnosticSeverity.Error] = 'error';

    return {
        cwd: cwd,
        emitFullPaths: emitFullPaths,
        severityLevel: severityLevel,
        includeDiagnostic: includeDiagnostic,
        typeColor: typeColor,
        severityTextMap: severityTextMap
    };
}

/**
 * Format output of one diagnostic
 */
export function printDiagnostic(
    options: ReturnType<typeof getPrintDiagnosticOptions>,
    severity: DiagnosticSeverity,
    filePath: string | undefined,
    lines: string[],
    diagnostic: BsDiagnostic,
    relatedInformation?: Array<{ range: Range; filePath: string; message: string }>
) {
    let { includeDiagnostic, severityTextMap, typeColor } = options;

    if (!includeDiagnostic[severity]) {
        return;
    }

    let severityText = severityTextMap[severity];

    console.log('');
    const printableDiagnosticCode = diagnostic.code ? diagnostic.code.toString() : 'BS' + ((diagnostic as BsDiagnostic).legacyCode ?? '');

    console.log(
        chalk.cyan(filePath ?? '<unknown file>') +
        ':' +
        chalk.yellow(
            diagnostic.range
                ? (diagnostic.range.start.line + 1) + ':' + (diagnostic.range.start.character + 1)
                : 'line?:col?'
        ) +
        ' - ' +
        typeColor[severity](severityText) +
        ' ' +
        chalk.grey(printableDiagnosticCode) +
        ': ' +
        chalk.white(diagnostic.message)
    );
    console.log('');

    //Get the line referenced by the diagnostic. if we couldn't find a line,
    // default to an empty string so it doesn't crash the error printing below
    let diagnosticLine = lines[diagnostic.range?.start?.line ?? -1] ?? '';
    console.log(
        getDiagnosticLine(diagnostic, diagnosticLine, typeColor[severity])
    );

    //print related information if present (only first few rows)
    const relatedInfoList = relatedInformation ?? [];
    let indent = '    ';
    for (let i = 0; i < relatedInfoList.length; i++) {
        let relatedInfo = relatedInfoList[i];
        //only show the first MAX_RELATED_INFOS_COUNT relatedInfo links
        if (i < MAX_RELATED_INFOS_COUNT) {
            console.log('');
            console.log(
                indent,
                chalk.cyan(relatedInfo.filePath ?? '<unknown file>') +
                ':' +
                chalk.yellow(
                    relatedInfo.range
                        ? (relatedInfo.range.start.line + 1) + ':' + (relatedInfo.range.start.character + 1)
                        : 'line?:col?'
                )
            );
            console.log(indent, relatedInfo.message);
        } else {
            console.log('\n', indent, `...and ${relatedInfoList.length - i + 1} more`);
            break;
        }
    }
    console.log('');
}

export function getDiagnosticLine(diagnostic: BsDiagnostic, diagnosticLine: string, colorFunction: Chalk) {
    let result = '';

    //only print the line information if we have some
    if (diagnostic.range && diagnosticLine) {
        const lineNumberText = chalk.bgWhite(' ' + chalk.black((diagnostic.range.start.line + 1).toString()) + ' ') + ' ';
        const blankLineNumberText = chalk.bgWhite(' ' + chalk.white(' '.repeat((diagnostic.range.start.line + 1).toString().length)) + ' ') + ' ';

        //remove tabs in favor of spaces to make diagnostic printing more consistent
        let leadingText = diagnosticLine.slice(0, diagnostic.range.start.character);
        let leadingTextNormalized = leadingText.replace(/\t/g, '    ');
        let actualText = diagnosticLine.slice(diagnostic.range.start.character, diagnostic.range.end.character);
        let actualTextNormalized = actualText.replace(/\t/g, '    ');
        let startIndex = leadingTextNormalized.length;
        let endIndex = leadingTextNormalized.length + actualTextNormalized.length;

        let diagnosticLineNormalized = diagnosticLine.replace(/\t/g, '    ');

        const squigglyText = getDiagnosticSquigglyText(diagnosticLineNormalized, startIndex, endIndex);
        result +=
            lineNumberText + diagnosticLineNormalized + '\n' +
            blankLineNumberText + colorFunction(squigglyText);
    }
    return result;
}

/**
 * Given a diagnostic, compute the range for the squiggly
 */
export function getDiagnosticSquigglyText(line: string | undefined, startCharacter: number | undefined, endCharacter: number | undefined) {
    let squiggle: string;
    //fill the entire line
    if (
        //there is no range
        typeof startCharacter !== 'number' || typeof endCharacter !== 'number' ||
        //there is no line
        !line ||
        //both positions point to same location
        startCharacter === endCharacter ||
        //the diagnostic starts after the end of the line
        startCharacter >= line.length
    ) {
        squiggle = ''.padStart(line?.length ?? 0, '~');
    } else {

        let endIndex = Math.max(endCharacter, line.length);
        endIndex = endIndex > 0 ? endIndex : 0;
        if (line?.length < endIndex) {
            endIndex = line.length;
        }

        let leadingWhitespaceLength = startCharacter;
        let squiggleLength: number;
        if (endCharacter === Number.MAX_VALUE) {
            squiggleLength = line.length - leadingWhitespaceLength;
        } else {
            squiggleLength = endCharacter - startCharacter;
        }
        let trailingWhitespaceLength = endIndex - endCharacter;

        //opening whitespace
        squiggle =
            ''.padStart(leadingWhitespaceLength, ' ') +
            //squiggle
            ''.padStart(squiggleLength, '~') +
            //trailing whitespace
            ''.padStart(trailingWhitespaceLength, ' ');

        //trim the end of the squiggle so it doesn't go longer than the end of the line
        if (squiggle.length > endIndex) {
            squiggle = squiggle.slice(0, endIndex);
        }
    }
    return squiggle;
}

1	import type { Chalk } from 'chalk';
2	import chalk from 'chalk';	1✔
3	import type { BsConfig } from './BsConfig';
4	import { DiagnosticSeverity } from 'vscode-languageserver';	1✔
5	import type { BsDiagnostic } from './interfaces';
6	import type { Range } from 'vscode-languageserver';
7
8	export const MAX_RELATED_INFOS_COUNT = 3;	1✔
9
10	/**
11	* Prepare print diagnostic formatting options
12	*/
13	export function getPrintDiagnosticOptions(options: BsConfig) {	1✔
14	let cwd = options?.cwd ? options.cwd : process.cwd();	57!
15
16	let emitFullPaths = options?.emitFullPaths === true;	57!
17
18	let diagnosticLevel = options?.diagnosticLevel ?? 'warn';	57!
19
20	let diagnosticSeverityMap = {} as Record<string, DiagnosticSeverity>;	57✔
21	diagnosticSeverityMap.info = DiagnosticSeverity.Information;	57✔
22	diagnosticSeverityMap.hint = DiagnosticSeverity.Hint;	57✔
23	diagnosticSeverityMap.warn = DiagnosticSeverity.Warning;	57✔
24	diagnosticSeverityMap.error = DiagnosticSeverity.Error;	57✔
25
26	let severityLevel = diagnosticSeverityMap[diagnosticLevel] \|\| DiagnosticSeverity.Warning;	57✔
27	let order = [DiagnosticSeverity.Information, DiagnosticSeverity.Hint, DiagnosticSeverity.Warning, DiagnosticSeverity.Error];	57✔
28	let includeDiagnostic = order.slice(order.indexOf(severityLevel)).reduce((acc, value) => {	57✔
29	acc[value] = true;	118✔
30	return acc;	118✔
31	}, {});
32
33	let typeColor = {} as Record<string, Chalk>;	57✔
34	typeColor[DiagnosticSeverity.Information] = chalk.blue;	57✔
35	typeColor[DiagnosticSeverity.Hint] = chalk.green;	57✔
36	typeColor[DiagnosticSeverity.Warning] = chalk.yellow;	57✔
37	typeColor[DiagnosticSeverity.Error] = chalk.red;	57✔
38
39	let severityTextMap = {};	57✔
40	severityTextMap[DiagnosticSeverity.Information] = 'info';	57✔
41	severityTextMap[DiagnosticSeverity.Hint] = 'hint';	57✔
42	severityTextMap[DiagnosticSeverity.Warning] = 'warning';	57✔
43	severityTextMap[DiagnosticSeverity.Error] = 'error';	57✔
44
45	return {	57✔
46	cwd: cwd,
47	emitFullPaths: emitFullPaths,
48	severityLevel: severityLevel,
49	includeDiagnostic: includeDiagnostic,
50	typeColor: typeColor,
51	severityTextMap: severityTextMap
52	};
53	}
54
55	/**
56	* Format output of one diagnostic
57	*/
58	export function printDiagnostic(	1✔
59	options: ReturnType<typeof getPrintDiagnosticOptions>,
60	severity: DiagnosticSeverity,
61	filePath: string \| undefined,
62	lines: string[],
63	diagnostic: BsDiagnostic,
64	relatedInformation?: Array<{ range: Range; filePath: string; message: string }>
65	) {
66	let { includeDiagnostic, severityTextMap, typeColor } = options;	8✔
67
68	if (!includeDiagnostic[severity]) {	8!
69	return;	×
70	}
71
72	let severityText = severityTextMap[severity];	8✔
73
74	console.log('');	8✔
75	const printableDiagnosticCode = diagnostic.code ? diagnostic.code.toString() : 'BS' + ((diagnostic as BsDiagnostic).legacyCode ?? '');	8!
76
77	console.log(	8✔
78	chalk.cyan(filePath ?? '<unknown file>') +	24✔
79	':' +
80	chalk.yellow(
81	diagnostic.range
82	? (diagnostic.range.start.line + 1) + ':' + (diagnostic.range.start.character + 1)	8✔
83	: 'line?:col?'
84	) +
85	' - ' +
86	typeColor[severity](severityText) +
87	' ' +
88	chalk.grey(printableDiagnosticCode) +
89	': ' +
90	chalk.white(diagnostic.message)
91	);
92	console.log('');	8✔
93
94	//Get the line referenced by the diagnostic. if we couldn't find a line,
95	// default to an empty string so it doesn't crash the error printing below
96	let diagnosticLine = lines[diagnostic.range?.start?.line ?? -1] ?? '';	8✔
97	console.log(	8✔
98	getDiagnosticLine(diagnostic, diagnosticLine, typeColor[severity])
99	);
100
101	//print related information if present (only first few rows)
102	const relatedInfoList = relatedInformation ?? [];	8✔
103	let indent = ' ';	8✔
104	for (let i = 0; i < relatedInfoList.length; i++) {	8✔
UNCOV 105	let relatedInfo = relatedInfoList[i];	×
106	//only show the first MAX_RELATED_INFOS_COUNT relatedInfo links
107	if (i < MAX_RELATED_INFOS_COUNT) {	×
UNCOV 108	console.log('');	×
109	console.log(	×
110	indent,
111	chalk.cyan(relatedInfo.filePath ?? '<unknown file>') +	×
112	':' +
113	chalk.yellow(
114	relatedInfo.range
115	? (relatedInfo.range.start.line + 1) + ':' + (relatedInfo.range.start.character + 1)	×
116	: 'line?:col?'
117	)
118	);
UNCOV 119	console.log(indent, relatedInfo.message);	×
120	} else {
121	console.log('\n', indent, `...and ${relatedInfoList.length - i + 1} more`);	×
UNCOV 122	break;	×
123	}
124	}
125	console.log('');	8✔
126	}
127
128	export function getDiagnosticLine(diagnostic: BsDiagnostic, diagnosticLine: string, colorFunction: Chalk) {	1✔
129	let result = '';	14✔
130
131	//only print the line information if we have some
132	if (diagnostic.range && diagnosticLine) {	14✔
133	const lineNumberText = chalk.bgWhite(' ' + chalk.black((diagnostic.range.start.line + 1).toString()) + ' ') + ' ';	9✔
134	const blankLineNumberText = chalk.bgWhite(' ' + chalk.white(' '.repeat((diagnostic.range.start.line + 1).toString().length)) + ' ') + ' ';	9✔
135
136	//remove tabs in favor of spaces to make diagnostic printing more consistent
137	let leadingText = diagnosticLine.slice(0, diagnostic.range.start.character);	9✔
138	let leadingTextNormalized = leadingText.replace(/\t/g, ' ');	9✔
139	let actualText = diagnosticLine.slice(diagnostic.range.start.character, diagnostic.range.end.character);	9✔
140	let actualTextNormalized = actualText.replace(/\t/g, ' ');	9✔
141	let startIndex = leadingTextNormalized.length;	9✔
142	let endIndex = leadingTextNormalized.length + actualTextNormalized.length;	9✔
143
144	let diagnosticLineNormalized = diagnosticLine.replace(/\t/g, ' ');	9✔
145
146	const squigglyText = getDiagnosticSquigglyText(diagnosticLineNormalized, startIndex, endIndex);	9✔
147	result +=	9✔
148	lineNumberText + diagnosticLineNormalized + '\n' +
149	blankLineNumberText + colorFunction(squigglyText);
150	}
151	return result;	14✔
152	}
153
154	/**
155	* Given a diagnostic, compute the range for the squiggly
156	*/
157	export function getDiagnosticSquigglyText(line: string \| undefined, startCharacter: number \| undefined, endCharacter: number \| undefined) {	1✔
158	let squiggle: string;
159	//fill the entire line
160	if (	21✔
161	//there is no range
162	typeof startCharacter !== 'number' \|\| typeof endCharacter !== 'number' \|\|	96✔
163	//there is no line
164	!line \|\|
165	//both positions point to same location
166	startCharacter === endCharacter \|\|
167	//the diagnostic starts after the end of the line
168	startCharacter >= line.length
169	) {
170	squiggle = ''.padStart(line?.length ?? 0, '~');	4✔
171	} else {
172
173	let endIndex = Math.max(endCharacter, line.length);	17✔
174	endIndex = endIndex > 0 ? endIndex : 0;	17!
175	if (line?.length < endIndex) {	17!
176	endIndex = line.length;	3✔
177	}
178
179	let leadingWhitespaceLength = startCharacter;	17✔
180	let squiggleLength: number;
181	if (endCharacter === Number.MAX_VALUE) {	17✔
182	squiggleLength = line.length - leadingWhitespaceLength;	1✔
183	} else {
184	squiggleLength = endCharacter - startCharacter;	16✔
185	}
186	let trailingWhitespaceLength = endIndex - endCharacter;	17✔
187
188	//opening whitespace
189	squiggle =	17✔
190	''.padStart(leadingWhitespaceLength, ' ') +
191	//squiggle
192	''.padStart(squiggleLength, '~') +
193	//trailing whitespace
194	''.padStart(trailingWhitespaceLength, ' ');
195
196	//trim the end of the squiggle so it doesn't go longer than the end of the line
197	if (squiggle.length > endIndex) {	17✔
198	squiggle = squiggle.slice(0, endIndex);	2✔
199	}
200	}
201	return squiggle;	21✔
202	}

rokucommunity / brighterscript / #12764

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