#12586

Committed 04 Jun 2024 01:26PM UTC coverage: 86.401%. Remained the same

Build Type

push

Committed by

Commit Message

Merge 43f9215d0 into b2bb9c4d9

Run Details

9981 of 12311 branches covered (81.07%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

18 existing lines in 2 files now uncovered.

12174 of 13331 relevant lines covered (91.32%)

25675.01 hits per line

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

81.52

/src/DiagnosticManager.ts

import type { DiagnosticContext, BsDiagnostic, DiagnosticContextPair } from './interfaces';
import { URI } from 'vscode-uri';
import type { AstNode } from './parser/AstNode';
import type { Scope } from './Scope';
import { util } from './util';
import { Cache } from './Cache';
import { isBsDiagnostic, isXmlScope } from './astUtils/reflection';
import type { BscFile } from './files/BscFile';
import type { DiagnosticRelatedInformation } from 'vscode-languageserver-protocol';
import { DiagnosticFilterer } from './DiagnosticFilterer';
import { DiagnosticSeverityAdjuster } from './DiagnosticSeverityAdjuster';
import type { FinalizedBsConfig } from './BsConfig';
import chalk from 'chalk';
import type { Logger } from './logging';
import { LogLevel, createLogger } from './logging';

/**
 * Manages all diagnostics for a program.
 * Diagnostics can be added specific to a certain file/range and optionally scope or an AST node
 * and can be tagged with arbitrary keys.
 * Diagnostics can be cleared based on file, scope, and/or AST node.
 * If multiple diagnostics are added related to the same range of code, they will be consolidated as related information
 */
export class DiagnosticManager {

    constructor(options?: { logger?: Logger }) {
        this.logger = options?.logger ?? createLogger();
    }

    private diagnosticsCache = new Cache<string, { diagnostic: BsDiagnostic; contexts: Set<DiagnosticContext> }>();

    private diagnosticFilterer = new DiagnosticFilterer();

    private diagnosticAdjuster = new DiagnosticSeverityAdjuster();

    public logger: Logger;

    public options: FinalizedBsConfig;

    /**
     * Registers a diagnostic (or multiple diagnostics) for a program.
     * Diagnostics can optionally be associated with a context
     */
    public register(diagnostic: BsDiagnostic, context?: DiagnosticContext);
    public register(diagnostics: Array<BsDiagnostic>, context?: DiagnosticContext);
    public register(diagnostics: Array<DiagnosticContextPair>);
    public register(diagnosticArg: BsDiagnostic | Array<BsDiagnostic | DiagnosticContextPair>, context?: DiagnosticContext) {
        const diagnostics = Array.isArray(diagnosticArg) ? diagnosticArg : [{ diagnostic: diagnosticArg, context: context }];
        for (const diagnosticData of diagnostics) {
            const diagnostic = isBsDiagnostic(diagnosticData) ? diagnosticData : diagnosticData.diagnostic;
            const diagContext = (diagnosticData as DiagnosticContextPair)?.context ?? context;
            const key = this.getDiagnosticKey(diagnostic);
            let fromCache = true;
            const cacheData = this.diagnosticsCache.getOrAdd(key, () => {

                if (!diagnostic.relatedInformation) {
                    diagnostic.relatedInformation = [];
                }
                fromCache = false;
                return { diagnostic: diagnostic, contexts: new Set<DiagnosticContext>() };
            });

            const cachedDiagnostic = cacheData.diagnostic;
            if (!fromCache && diagnostic.relatedInformation) {
                this.mergeRelatedInformation(cachedDiagnostic.relatedInformation, diagnostic.relatedInformation);
            }
            const contexts = cacheData.contexts;
            if (diagContext) {
                contexts.add(diagContext);
            }
        }
    }

    /**
     * Returns a list of all diagnostics, filtered by the in-file comment filters, filtered by BsConfig diagnostics and adjusted based on BsConfig
     * If the same diagnostic is included in multiple contexts, they are included in a single diagnostic's relatedInformation
     */
    public getDiagnostics() {
        const doDiagnosticsGathering = () => {
            const diagnostics = this.getNonSuppresedDiagnostics();
            const filteredDiagnostics = this.logger?.time(LogLevel.debug, ['filter diagnostics'], () => {
                return this.filterDiagnostics(diagnostics);
            }) ?? this.filterDiagnostics(diagnostics);

            this.logger?.time(LogLevel.debug, ['adjust diagnostics severity'], () => {
                this.diagnosticAdjuster?.adjust(this.options ?? {}, filteredDiagnostics);
            });

            this.logger?.info(`diagnostic counts: total=${chalk.yellow(diagnostics.length.toString())}, after filter=${chalk.yellow(filteredDiagnostics.length.toString())}`);
            return filteredDiagnostics;
        };

        return this.logger?.time(LogLevel.info, ['DiagnosticsManager.getDiagnostics()'], doDiagnosticsGathering) ?? doDiagnosticsGathering();
    }

    private getNonSuppresedDiagnostics() {
        const results = [] as Array<BsDiagnostic>;
        for (const cachedDiagnostic of this.diagnosticsCache.values()) {
            const diagnostic = { ...cachedDiagnostic.diagnostic };
            const relatedInformation = [...cachedDiagnostic.diagnostic.relatedInformation];
            const affectedScopes = new Set<Scope>();
            for (const context of cachedDiagnostic.contexts.values()) {
                if (context.scope) {
                    affectedScopes.add(context.scope);
                }
            }
            for (const scope of affectedScopes) {
                if (isXmlScope(scope) && scope.xmlFile?.srcPath) {
                    relatedInformation.push({
                        message: `In component scope '${scope?.xmlFile?.componentName?.text}'`,
                        location: util.createLocation(
                            URI.file(scope.xmlFile.srcPath).toString(),
                            scope?.xmlFile?.ast?.componentElement?.getAttribute('name')?.tokens?.value?.range ?? util.createRange(0, 0, 0, 10)
                        )
                    });
                } else {
                    relatedInformation.push({
                        message: `In scope '${scope.name}'`,
                        location: util.createLocation(
                            URI.file(diagnostic.file.srcPath).toString(),
                            diagnostic.range
                        )
                    });
                }

            }
            diagnostic.relatedInformation = relatedInformation;
            results.push(diagnostic);
        }
        return results.filter((x) => {
            return !util.diagnosticIsSuppressed(x);
        });
    }

    private filterDiagnostics(diagnostics: BsDiagnostic[]) {
        //filter out diagnostics based on our diagnostic filters
        let filteredDiagnostics = this.diagnosticFilterer.filter({
            ...this.options ?? {},
            rootDir: this.options?.rootDir
        }, diagnostics);
        return filteredDiagnostics;
    }

    public clear() {
        this.diagnosticsCache.clear();
    }

    public clearForFile(fileSrcPath: string) {
        const fileSrcPathLower = fileSrcPath.toLowerCase();
        for (const [key, cachedData] of this.diagnosticsCache.entries()) {
            if (cachedData.diagnostic.file.srcPath.toLowerCase() === fileSrcPathLower) {
                this.diagnosticsCache.delete(key);
            }
        }
    }

    public clearForScope(scope: Scope) {
        for (const [key, cachedData] of this.diagnosticsCache.entries()) {
            let removedContext = false;
            for (const context of cachedData.contexts.values()) {
                if (context.scope === scope) {
                    cachedData.contexts.delete(context);
                    removedContext = true;
                }
            }
            if (removedContext && cachedData.contexts.size === 0) {
                // no more contexts for this diagnostic - remove diagnostic
                this.diagnosticsCache.delete(key);
            }
        }
    }

    public clearForSegment(segment: AstNode) {
        for (const [key, cachedData] of this.diagnosticsCache.entries()) {
            let removedContext = false;
            for (const context of cachedData.contexts.values()) {
                if (context.segment === segment) {
                    cachedData.contexts.delete(context);
                }
            }
            if (removedContext && cachedData.contexts.size === 0) {
                // no more contexts for this diagnostic - remove diagnostic
                this.diagnosticsCache.delete(key);
            }
        }
    }

    public clearForTag(tag: string) {
        for (const [key, cachedData] of this.diagnosticsCache.entries()) {
            for (const context of cachedData.contexts.values()) {
                if (context.tags.includes(tag)) {
                    this.diagnosticsCache.delete(key);
                }
            }
        }
    }

    /**
     * Clears all diagnostics that match all aspects of the filter provided
     * Matches equality of tag, scope, file, segment filters. Leave filter option undefined to not filter on option
     */
    public clearByFilter(filter: DiagnosticContextFilter) {

        const needToMatch = {
            tag: !(filter.tag === undefined),
            scope: !(filter.scope === undefined),
            file: !(filter.file === undefined),
            segment: !(filter.segment === undefined)
        };

        for (const [key, cachedData] of this.diagnosticsCache.entries()) {
            let removedContext = false;
            for (const context of cachedData.contexts.values()) {
                let isMatch = true;
                if (isMatch && needToMatch.tag) {
                    isMatch = !!context.tags?.includes(filter.tag);
                }
                if (isMatch && needToMatch.scope) {
                    isMatch = context.scope === filter.scope;
                }
                if (isMatch && needToMatch.file) {
                    isMatch = cachedData.diagnostic.file === filter.file;
                }
                if (isMatch && needToMatch.segment) {
                    isMatch = context.segment === filter.segment;
                }

                if (isMatch) {
                    cachedData.contexts.delete(context);
                    removedContext = true;
                }
            }
            if (removedContext && cachedData.contexts.size === 0) {
                // no more contexts for this diagnostic - remove diagnostic
                this.diagnosticsCache.delete(key);
            }
        }
    }


    private getDiagnosticKey(diagnostic: BsDiagnostic) {
        return `${diagnostic.file?.srcPath} - ${diagnostic.code} - ${diagnostic.message} - ${util.rangeToString(diagnostic.range)}`;
    }

    private mergeRelatedInformation(target: DiagnosticRelatedInformation[], source: DiagnosticRelatedInformation[]) {
        function getRiKey(relatedInfo: DiagnosticRelatedInformation) {
            return `${relatedInfo.message} - ${relatedInfo.location.uri} - ${util.rangeToString(relatedInfo.location.range)}`.toLowerCase();
        }

        const existingKeys = target.map(ri => getRiKey(ri));

        for (const ri of source) {
            const key = getRiKey(ri);
            if (!existingKeys.includes(key)) {
                target.push(ri);
            }
        }
    }

}

interface DiagnosticContextFilter {
    tag?: string;
    scope?: Scope;
    file?: BscFile;
    segment?: AstNode;
}

1	import type { DiagnosticContext, BsDiagnostic, DiagnosticContextPair } from './interfaces';
2	import { URI } from 'vscode-uri';	1✔
3	import type { AstNode } from './parser/AstNode';
4	import type { Scope } from './Scope';
5	import { util } from './util';	1✔
6	import { Cache } from './Cache';	1✔
7	import { isBsDiagnostic, isXmlScope } from './astUtils/reflection';	1✔
8	import type { BscFile } from './files/BscFile';
9	import type { DiagnosticRelatedInformation } from 'vscode-languageserver-protocol';
10	import { DiagnosticFilterer } from './DiagnosticFilterer';	1✔
11	import { DiagnosticSeverityAdjuster } from './DiagnosticSeverityAdjuster';	1✔
12	import type { FinalizedBsConfig } from './BsConfig';
13	import chalk from 'chalk';	1✔
14	import type { Logger } from './logging';
15	import { LogLevel, createLogger } from './logging';	1✔
16
17	/**
18	* Manages all diagnostics for a program.
19	* Diagnostics can be added specific to a certain file/range and optionally scope or an AST node
20	* and can be tagged with arbitrary keys.
21	* Diagnostics can be cleared based on file, scope, and/or AST node.
22	* If multiple diagnostics are added related to the same range of code, they will be consolidated as related information
23	*/
24	export class DiagnosticManager {	1✔
25
26	constructor(options?: { logger?: Logger }) {
27	this.logger = options?.logger ?? createLogger();	1,530!
28	}
29
30	private diagnosticsCache = new Cache<string, { diagnostic: BsDiagnostic; contexts: Set<DiagnosticContext> }>();	1,530✔
31
32	private diagnosticFilterer = new DiagnosticFilterer();	1,530✔
33
34	private diagnosticAdjuster = new DiagnosticSeverityAdjuster();	1,530✔
35
36	public logger: Logger;
37
38	public options: FinalizedBsConfig;
39
40	/**
41	* Registers a diagnostic (or multiple diagnostics) for a program.
42	* Diagnostics can optionally be associated with a context
43	*/
44	public register(diagnostic: BsDiagnostic, context?: DiagnosticContext);
45	public register(diagnostics: Array<BsDiagnostic>, context?: DiagnosticContext);
46	public register(diagnostics: Array<DiagnosticContextPair>);
47	public register(diagnosticArg: BsDiagnostic \| Array<BsDiagnostic \| DiagnosticContextPair>, context?: DiagnosticContext) {
48	const diagnostics = Array.isArray(diagnosticArg) ? diagnosticArg : [{ diagnostic: diagnosticArg, context: context }];	5,894✔
49	for (const diagnosticData of diagnostics) {	5,894✔
50	const diagnostic = isBsDiagnostic(diagnosticData) ? diagnosticData : diagnosticData.diagnostic;	1,231✔
51	const diagContext = (diagnosticData as DiagnosticContextPair)?.context ?? context;	1,231!
52	const key = this.getDiagnosticKey(diagnostic);	1,231✔
53	let fromCache = true;	1,231✔
54	const cacheData = this.diagnosticsCache.getOrAdd(key, () => {	1,231✔
55
56	if (!diagnostic.relatedInformation) {	943✔
57	diagnostic.relatedInformation = [];	872✔
58	}
59	fromCache = false;	943✔
60	return { diagnostic: diagnostic, contexts: new Set<DiagnosticContext>() };	943✔
61	});
62
63	const cachedDiagnostic = cacheData.diagnostic;	1,231✔
64	if (!fromCache && diagnostic.relatedInformation) {	1,231✔
65	this.mergeRelatedInformation(cachedDiagnostic.relatedInformation, diagnostic.relatedInformation);	943✔
66	}
67	const contexts = cacheData.contexts;	1,231✔
68	if (diagContext) {	1,231✔
69	contexts.add(diagContext);	862✔
70	}
71	}
72	}
73
74	/**
75	* Returns a list of all diagnostics, filtered by the in-file comment filters, filtered by BsConfig diagnostics and adjusted based on BsConfig
76	* If the same diagnostic is included in multiple contexts, they are included in a single diagnostic's relatedInformation
77	*/
78	public getDiagnostics() {
79	const doDiagnosticsGathering = () => {	1,138✔
80	const diagnostics = this.getNonSuppresedDiagnostics();	1,138✔
81	const filteredDiagnostics = this.logger?.time(LogLevel.debug, ['filter diagnostics'], () => {	1,138!
82	return this.filterDiagnostics(diagnostics);	1,138✔
83	}) ?? this.filterDiagnostics(diagnostics);	1,138!
84
85	this.logger?.time(LogLevel.debug, ['adjust diagnostics severity'], () => {	1,138!
86	this.diagnosticAdjuster?.adjust(this.options ?? {}, filteredDiagnostics);	1,138!
87	});
88
89	this.logger?.info(`diagnostic counts: total=${chalk.yellow(diagnostics.length.toString())}, after filter=${chalk.yellow(filteredDiagnostics.length.toString())}`);	1,138!
90	return filteredDiagnostics;	1,138✔
91	};
92
93	return this.logger?.time(LogLevel.info, ['DiagnosticsManager.getDiagnostics()'], doDiagnosticsGathering) ?? doDiagnosticsGathering();	1,138!
94	}
95
96	private getNonSuppresedDiagnostics() {
97	const results = [] as Array<BsDiagnostic>;	1,138✔
98	for (const cachedDiagnostic of this.diagnosticsCache.values()) {	1,138✔
99	const diagnostic = { ...cachedDiagnostic.diagnostic };	657✔
100	const relatedInformation = [...cachedDiagnostic.diagnostic.relatedInformation];	657✔
101	const affectedScopes = new Set<Scope>();	657✔
102	for (const context of cachedDiagnostic.contexts.values()) {	657✔
103	if (context.scope) {	772✔
104	affectedScopes.add(context.scope);	674✔
105	}
106	}
107	for (const scope of affectedScopes) {	657✔
108	if (isXmlScope(scope) && scope.xmlFile?.srcPath) {	428!
109	relatedInformation.push({	153✔
110	message: `In component scope '${scope?.xmlFile?.componentName?.text}'`,	1,377!
111	location: util.createLocation(
112	URI.file(scope.xmlFile.srcPath).toString(),
113	scope?.xmlFile?.ast?.componentElement?.getAttribute('name')?.tokens?.value?.range ?? util.createRange(0, 0, 0, 10)	3,672!
114	)
115	});
116	} else {
117	relatedInformation.push({	275✔
118	message: `In scope '${scope.name}'`,
119	location: util.createLocation(
120	URI.file(diagnostic.file.srcPath).toString(),
121	diagnostic.range
122	)
123	});
124	}
125
126	}
127	diagnostic.relatedInformation = relatedInformation;	657✔
128	results.push(diagnostic);	657✔
129	}
130	return results.filter((x) => {	1,138✔
131	return !util.diagnosticIsSuppressed(x);	657✔
132	});
133	}
134
135	private filterDiagnostics(diagnostics: BsDiagnostic[]) {
136	//filter out diagnostics based on our diagnostic filters
137	let filteredDiagnostics = this.diagnosticFilterer.filter({	1,138✔
138	...this.options ?? {},	3,414✔
139	rootDir: this.options?.rootDir	3,414✔
140	}, diagnostics);
141	return filteredDiagnostics;	1,138✔
142	}
143
144	public clear() {
145	this.diagnosticsCache.clear();	×
146	}
147
148	public clearForFile(fileSrcPath: string) {
149	const fileSrcPathLower = fileSrcPath.toLowerCase();	152✔
150	for (const [key, cachedData] of this.diagnosticsCache.entries()) {	152✔
151	if (cachedData.diagnostic.file.srcPath.toLowerCase() === fileSrcPathLower) {	43✔
152	this.diagnosticsCache.delete(key);	31✔
153	}
154	}
155	}
156
157	public clearForScope(scope: Scope) {
158	for (const [key, cachedData] of this.diagnosticsCache.entries()) {	×
159	let removedContext = false;	×
160	for (const context of cachedData.contexts.values()) {	×
161	if (context.scope === scope) {	×
162	cachedData.contexts.delete(context);	×
163	removedContext = true;	×
164	}
165	}
166	if (removedContext && cachedData.contexts.size === 0) {	×
167	// no more contexts for this diagnostic - remove diagnostic
168	this.diagnosticsCache.delete(key);	×
169	}
170	}
171	}
172
173	public clearForSegment(segment: AstNode) {
174	for (const [key, cachedData] of this.diagnosticsCache.entries()) {	×
175	let removedContext = false;	×
176	for (const context of cachedData.contexts.values()) {	×
177	if (context.segment === segment) {	×
178	cachedData.contexts.delete(context);	×
179	}
180	}
181	if (removedContext && cachedData.contexts.size === 0) {	×
182	// no more contexts for this diagnostic - remove diagnostic
183	this.diagnosticsCache.delete(key);	×
184	}
185	}
186	}
187
188	public clearForTag(tag: string) {
189	for (const [key, cachedData] of this.diagnosticsCache.entries()) {	1,212✔
190	for (const context of cachedData.contexts.values()) {	176✔
191	if (context.tags.includes(tag)) {	23!
192	this.diagnosticsCache.delete(key);	×
193	}
194	}
195	}
196	}
197
198	/**
199	* Clears all diagnostics that match all aspects of the filter provided
200	* Matches equality of tag, scope, file, segment filters. Leave filter option undefined to not filter on option
201	*/
202	public clearByFilter(filter: DiagnosticContextFilter) {
203
204	const needToMatch = {	7,703✔
205	tag: !(filter.tag === undefined),
206	scope: !(filter.scope === undefined),
207	file: !(filter.file === undefined),
208	segment: !(filter.segment === undefined)
209	};
210
211	for (const [key, cachedData] of this.diagnosticsCache.entries()) {	7,703✔
212	let removedContext = false;	33,234✔
213	for (const context of cachedData.contexts.values()) {	33,234✔
214	let isMatch = true;	47,216✔
215	if (isMatch && needToMatch.tag) {	47,216✔
216	isMatch = !!context.tags?.includes(filter.tag);	31,293!
217	}
218	if (isMatch && needToMatch.scope) {	47,216✔
219	isMatch = context.scope === filter.scope;	26,318✔
220	}
221	if (isMatch && needToMatch.file) {	47,216✔
222	isMatch = cachedData.diagnostic.file === filter.file;	837✔
223	}
224	if (isMatch && needToMatch.segment) {	47,216✔
225	isMatch = context.segment === filter.segment;	790✔
226	}
227
228	if (isMatch) {	47,216✔
229	cachedData.contexts.delete(context);	17✔
230	removedContext = true;	17✔
231	}
232	}
233	if (removedContext && cachedData.contexts.size === 0) {	33,234✔
234	// no more contexts for this diagnostic - remove diagnostic
235	this.diagnosticsCache.delete(key);	9✔
236	}
237	}
238	}
239
240
241	private getDiagnosticKey(diagnostic: BsDiagnostic) {
242	return `${diagnostic.file?.srcPath} - ${diagnostic.code} - ${diagnostic.message} - ${util.rangeToString(diagnostic.range)}`;	1,231!
243	}
244
245	private mergeRelatedInformation(target: DiagnosticRelatedInformation[], source: DiagnosticRelatedInformation[]) {
246	function getRiKey(relatedInfo: DiagnosticRelatedInformation) {
247	return `${relatedInfo.message} - ${relatedInfo.location.uri} - ${util.rangeToString(relatedInfo.location.range)}`.toLowerCase();	142✔
248	}
249
250	const existingKeys = target.map(ri => getRiKey(ri));	943✔
251
252	for (const ri of source) {	943✔
253	const key = getRiKey(ri);	71✔
254	if (!existingKeys.includes(key)) {	71!
UNCOV 255	target.push(ri);	×
256	}
257	}
258	}
259
260	}
261
262	interface DiagnosticContextFilter {
263	tag?: string;
264	scope?: Scope;
265	file?: BscFile;
266	segment?: AstNode;
267	}

rokucommunity / brighterscript / #12586

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