TypeScript DiagnosticCollection.set方法代码示例

export function addUniqueDiagnostic(diagnostic: FileDiagnostic, diagnostics: DiagnosticCollection): void {
    const uri = Uri.file(diagnostic.filePath);

    const fileDiagnostics = diagnostics.get(uri);

    if (!fileDiagnostics) {
        // No diagnostics for the file
        // The diagnostic is unique
        diagnostics.set(uri, [diagnostic.diagnostic]);
    } else if (isUniqueDiagnostic(diagnostic.diagnostic, fileDiagnostics)) {
        const newFileDiagnostics = fileDiagnostics.concat([diagnostic.diagnostic]);
        diagnostics.set(uri, newFileDiagnostics);
    }
}

	public semanticDiagnosticsReceived(file: string, diagnostics: Diagnostic[]): void {
		let syntaxMarkers = this.syntaxDiagnostics[file];
		if (syntaxMarkers) {
			delete this.syntaxDiagnostics[file];
			diagnostics = syntaxMarkers.concat(diagnostics);
		}
		this.currentDiagnostics.set(Uri.file(file), diagnostics);
	}

	private handleErrors(notification: as.AnalysisErrorsNotification) {
		let errors = notification.errors;
		if (!config.showTodos)
			errors = errors.filter((error) => error.type != "TODO");
		this.diagnostics.set(
			Uri.file(notification.file), 
			errors.map(e => this.createDiagnostic(e))
		);
	}

	/* internal */ semanticDiagnosticsReceived(event: Proto.DiagnosticEvent): void {
		let body = event.body;
		if (body.diagnostics) {
			let diagnostics = this.createMarkerDatas(body.diagnostics);
			let syntaxMarkers = this.syntaxDiagnostics[body.file];
			if (syntaxMarkers) {
				delete this.syntaxDiagnostics[body.file];
				diagnostics = syntaxMarkers.concat(diagnostics);
			}
			this.currentDiagnostics.set(Uri.file(body.file), diagnostics);
		}
	}

async function doValidate(document: TextDocument) {
	let report = null;

	let documentWasClosed = false; // track whether the document was closed while getInstalledModules/'npm ls' runs
	const listener = workspace.onDidCloseTextDocument(doc => {
		if (doc.uri === document.uri) {
			documentWasClosed = true;
		}
	});

	try {
		report = await getInstalledModules(path.dirname(document.fileName));
	} catch (e) {
		listener.dispose();
		return;
	}
	try {
		diagnosticCollection.clear();

		if (report.invalid && report.invalid === true) {
			return;
		}
		if (!anyModuleErrors(report)) {
			return;
		}
		if (documentWasClosed || !document.getText()) {
			return;
		}
		const sourceRanges = parseSourceRanges(document.getText());
		const dependencies = report.dependencies;
		const diagnostics: Diagnostic[] = [];

		for (var moduleName in dependencies) {
			if (dependencies.hasOwnProperty(moduleName)) {
				const diagnostic = getDiagnostic(document, report, moduleName, sourceRanges);
				if (diagnostic) {
					diagnostic.source = 'npm';
					diagnostics.push(diagnostic);
				}
			}
		}
		//console.log("diagnostic count ", diagnostics.length, " ", document.uri.fsPath);
		diagnosticCollection.set(document.uri, diagnostics);
	} catch (e) {
		window.showInformationMessage(`[npm-script-runner] Cannot validate the package.json ` + e);
		console.log(`npm-script-runner: 'error while validating package.json stacktrace: ${e.stack}`);
	}
}

	public configFileDiagnosticsReceived(file: string, diagnostics: Diagnostic[]): void {
		this.currentDiagnostics.set(Uri.file(file), diagnostics);
	}

 diagnosticMap.forEach((diags, file) => {
     diagnosticCollection.set(Uri.parse(file), diags);
 });

    public async checkVariables(document: TextDocument) {
        if (document.languageId !== 'http' || document.uri.scheme !== 'file') {
            return;
        }

        const diagnostics: Diagnostic[] = [];

        const allAvailableVariables = await VariableProcessor.getAllVariablesDefinitions(document);
        const variableReferences = this.findVariableReferences(document);

        // Variable not found
        [...variableReferences.entries()]
            .filter(([name]) => !allAvailableVariables.has(name))
            .forEach(([, variables]) => {
                variables.forEach(v => {
                    diagnostics.push(
                        new Diagnostic(
                            new Range(new Position(v.lineNumber, v.startIndex), new Position(v.lineNumber, v.endIndex)),
                            `${v.variableName} is not found`,
                            DiagnosticSeverity.Error));
                });
            });

        // Request variable not active
        [...variableReferences.entries()]
            .filter(([name]) =>
                allAvailableVariables.has(name)
                && allAvailableVariables.get(name)[0] === VariableType.Request
                && !RequestVariableCache.has(new RequestVariableCacheKey(name, document.uri.toString())))
            .forEach(([, variables]) => {
                variables.forEach(v => {
                    diagnostics.push(
                        new Diagnostic(
                            new Range(new Position(v.lineNumber, v.startIndex), new Position(v.lineNumber, v.endIndex)),
                            `Request '${v.variableName}' has not been sent`,
                            DiagnosticSeverity.Information));
                });
            });

        // Request variable resolve with warning or error
        [...variableReferences.entries()]
            .filter(([name]) =>
                allAvailableVariables.has(name)
                && allAvailableVariables.get(name)[0] === VariableType.Request
                && RequestVariableCache.has(new RequestVariableCacheKey(name, document.uri.toString())))
            .forEach(([name, variables]) => {
                const value = RequestVariableCache.get(new RequestVariableCacheKey(name, document.uri.toString()));
                variables.forEach(v => {
                    const path = v.variableValue.replace(/^\{{2}\s*/, '').replace(/\s*\}{2}$/, '');
                    const result = RequestVariableCacheValueProcessor.resolveRequestVariable(value, path);
                    if (result.state !== ResolveState.Success) {
                        diagnostics.push(
                            new Diagnostic(
                                new Range(new Position(v.lineNumber, v.startIndex), new Position(v.lineNumber, v.endIndex)),
                                result.message,
                                result.state === ResolveState.Error ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning));
                    }
                });
            });

        this.httpDiagnosticCollection.set(document.uri, diagnostics);
    }

	public syntaxDiagnosticsReceived(file: string, diagnostics: Diagnostic[]): void {
		this.syntaxDiagnostics[file] = diagnostics;
		this.currentDiagnostics.set(Uri.file(file), diagnostics);
	}

	private flushResults(notification: as.AnalysisFlushResultsNotification) {
		let entries = notification.files.map<[Uri, Diagnostic[]]>(file => [Uri.file(file), undefined]);
		this.diagnostics.set(entries);
	}