下面列出了怎么用org.eclipse.lsp4j.PublishDiagnosticsParams的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public void accept(PublishDiagnosticsParams publishDiagnosticsParams) {
ApplicationManager.getApplication().invokeLater(() -> {
VirtualFile file = null;
try {
file = LSPIJUtils.findResourceFor(new URI(publishDiagnosticsParams.getUri()));
} catch (URISyntaxException e) {
LOGGER.warn(e.getLocalizedMessage(), e);
}
if (file != null) {
Document document = FileDocumentManager.getInstance().getDocument(file);
if (document != null) {
Editor[] editors = LSPIJUtils.editorsForFile(file, document);
for(Editor editor : editors) {
cleanMarkers(editor);
createMarkers(editor, document, publishDiagnosticsParams.getDiagnostics());
}
}
}
});
}
public static void testPublishDiagnosticsFor(String xml, String fileURI, Consumer<XMLLanguageService> configuration,
PublishDiagnosticsParams... expected) {
List<PublishDiagnosticsParams> actual = new ArrayList<>();
XMLLanguageService xmlLanguageService = new XMLLanguageService();
if (configuration != null) {
xmlLanguageService.initializeIfNeeded();
configuration.accept(xmlLanguageService);
}
DOMDocument xmlDocument = DOMParser.getInstance().parse(xml, fileURI,
xmlLanguageService.getResolverExtensionManager());
xmlLanguageService.setDocumentProvider((uri) -> xmlDocument);
publishDiagnostics(xmlDocument, actual, xmlLanguageService);
assertEquals(expected.length, actual.size());
for (int i = 0; i < expected.length; i++) {
assertEquals(fileURI, actual.get(i).getUri());
assertDiagnostics(actual.get(i).getDiagnostics(), expected[i].getDiagnostics(), false);
}
}
public static void publishDiagnostics(DOMDocument xmlDocument, List<PublishDiagnosticsParams> actual,
XMLLanguageService languageService) {
CompletableFuture<Path> error = languageService.publishDiagnostics(xmlDocument, params -> {
actual.add(params);
}, (doc) -> {
// Retrigger validation
publishDiagnostics(xmlDocument, actual, languageService);
}, null, () -> {
});
if (error != null) {
try {
error.join();
// Wait for 500 ms to collect the last params
Thread.sleep(200);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
List<Diagnostic> issueList = diagnostics.getDiagnostics();
if (issueList.isEmpty()) {
return;
}
synchronized (this) {
N4jscConsole.println(issueSerializer.uri(diagnostics.getUri()));
for (Diagnostic diag : issueList) {
N4jscConsole.println(issueSerializer.diagnostics(diag));
switch (diag.getSeverity()) {
case Error:
errCount++;
break;
case Warning:
wrnCount++;
break;
default:
break;
}
}
}
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams pdp) {
try {
FileObject file = URLMapper.findFileObject(new URI(pdp.getUri()).toURL());
EditorCookie ec = file.getLookup().lookup(EditorCookie.class);
Document doc = ec != null ? ec.getDocument() : null;
if (doc == null)
return ; //ignore...
List<ErrorDescription> diags = pdp.getDiagnostics().stream().map(d -> {
LazyFixList fixList = allowCodeActions ? new DiagnosticFixList(pdp.getUri(), d) : ErrorDescriptionFactory.lazyListForFixes(Collections.emptyList());
return ErrorDescriptionFactory.createErrorDescription(severityMap.get(d.getSeverity()), d.getMessage(), fixList, file, Utils.getOffset(doc, d.getRange().getStart()), Utils.getOffset(doc, d.getRange().getEnd()));
}).collect(Collectors.toList());
HintsController.setErrors(doc, LanguageClientImpl.class.getName(), diags);
} catch (URISyntaxException | MalformedURLException ex) {
LOG.log(Level.FINE, null, ex);
}
}
@Test
public void testDidClose() throws Exception {
URI fileURI = openFile("maven/salut4", "src/main/java/java/TestSyntaxError.java");
Job.getJobManager().join(SyntaxDocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitor);
String fileUri = ResourceUtils.fixURI(fileURI);
TextDocumentIdentifier identifier = new TextDocumentIdentifier(fileUri);
server.didClose(new DidCloseTextDocumentParams(identifier));
Job.getJobManager().join(SyntaxDocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitor);
List<PublishDiagnosticsParams> diagnosticReports = getClientRequests("publishDiagnostics");
assertEquals(2, diagnosticReports.size());
PublishDiagnosticsParams params = diagnosticReports.get(1);
assertEquals(fileUri, params.getUri());
assertNotNull(params.getDiagnostics());
assertTrue(params.getDiagnostics().isEmpty());
}
@Test
public void testReconcile() throws Exception {
IJavaProject javaProject = newEmptyProject();
IPackageFragmentRoot sourceFolder = javaProject.getPackageFragmentRoot(javaProject.getProject().getFolder("src"));
IPackageFragment pack1 = sourceFolder.createPackageFragment("test1", false, null);
StringBuilder buf = new StringBuilder();
buf.append("package test1;\n");
buf.append("public class E123 {\n");
buf.append(" public void testing() {\n");
buf.append(" int someIntegerChanged = 5;\n");
buf.append(" int i = someInteger + 5\n");
buf.append(" }\n");
buf.append("}\n");
ICompilationUnit cu1 = pack1.createCompilationUnit("E123.java", buf.toString(), false, null);
openDocument(cu1, cu1.getSource(), 1);
assertEquals(true, cu1.isWorkingCopy());
assertEquals(false, cu1.hasUnsavedChanges());
List<PublishDiagnosticsParams> diagnosticsParams = getClientRequests("publishDiagnostics");
assertEquals(1, diagnosticsParams.size());
PublishDiagnosticsParams diagnosticsParam = diagnosticsParams.get(0);
List<Diagnostic> diagnostics = diagnosticsParam.getDiagnostics();
assertEquals(2, diagnostics.size());
diagnosticsParams.clear();
closeDocument(cu1);
}
@Test
public void testDidOpenStandaloneFile() throws Exception {
IJavaProject javaProject = newDefaultProject();
IPackageFragmentRoot sourceFolder = javaProject.getPackageFragmentRoot(javaProject.getProject().getFolder("src"));
IPackageFragment pack1 = sourceFolder.createPackageFragment("java", false, null);
// @formatter:off
String standaloneFileContent =
"package java;\n"+
"public class Foo extends UnknownType {"+
" public void method1(){\n"+
" super.whatever();"+
" }\n"+
"}";
// @formatter:on
ICompilationUnit cu1 = pack1.createCompilationUnit("Foo.java", standaloneFileContent, false, null);
openDocument(cu1, cu1.getSource(), 1);
List<PublishDiagnosticsParams> diagnosticReports = getClientRequests("publishDiagnostics");
assertEquals(1, diagnosticReports.size());
PublishDiagnosticsParams diagParam = diagnosticReports.get(0);
assertEquals(1, diagParam.getDiagnostics().size());
Diagnostic d = diagParam.getDiagnostics().get(0);
assertEquals("Foo.java is a non-project file, only syntax errors are reported", d.getMessage());
}
@Test
public void testDidOpenNotOnClasspath() throws Exception {
importProjects("eclipse/hello");
IProject project = WorkspaceHelper.getProject("hello");
URI uri = project.getFile("nopackage/Test2.java").getRawLocationURI();
ICompilationUnit cu = JDTUtils.resolveCompilationUnit(uri);
String source = FileUtils.readFileToString(FileUtils.toFile(uri.toURL()));
openDocument(cu, source, 1);
Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitor);
assertEquals(project, cu.getJavaProject().getProject());
assertEquals(source, cu.getSource());
List<PublishDiagnosticsParams> diagnosticReports = getClientRequests("publishDiagnostics");
assertEquals(1, diagnosticReports.size());
PublishDiagnosticsParams diagParam = diagnosticReports.get(0);
assertEquals(2, diagParam.getDiagnostics().size());
closeDocument(cu);
Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitor);
diagnosticReports = getClientRequests("publishDiagnostics");
assertEquals(2, diagnosticReports.size());
diagParam = diagnosticReports.get(1);
assertEquals(0, diagParam.getDiagnostics().size());
}
private void assertNewProblemReported(ExpectedProblemReport... expectedReports) {
List<PublishDiagnosticsParams> diags = getClientRequests("publishDiagnostics");
assertEquals(expectedReports.length, diags.size());
for (int i = 0; i < expectedReports.length; i++) {
PublishDiagnosticsParams diag = diags.get(i);
ExpectedProblemReport expected = expectedReports[i];
assertEquals(JDTUtils.toURI(expected.cu), diag.getUri());
if (expected.problemCount != diag.getDiagnostics().size()) {
String message = "";
for (Diagnostic d : diag.getDiagnostics()) {
message += d.getMessage() + ", ";
}
assertEquals(message, expected.problemCount, diag.getDiagnostics().size());
}
}
diags.clear();
}
@Test
public void testProjectLevelMarkers() throws Exception {
//import project
importProjects("maven/broken");
ArgumentCaptor<PublishDiagnosticsParams> captor = ArgumentCaptor.forClass(PublishDiagnosticsParams.class);
verify(connection, atLeastOnce()).publishDiagnostics(captor.capture());
List<PublishDiagnosticsParams> allCalls = captor.getAllValues();
Collections.reverse(allCalls);
projectsManager.setConnection(client);
Optional<PublishDiagnosticsParams> projectDiags = allCalls.stream().filter(p -> p.getUri().endsWith("maven/broken")).findFirst();
assertTrue("No maven/broken errors were found", projectDiags.isPresent());
List<Diagnostic> diags = projectDiags.get().getDiagnostics();
Collections.sort(diags, DIAGNOSTICS_COMPARATOR);
assertEquals(diags.toString(), 3, diags.size());
assertTrue(diags.get(2).getMessage().startsWith("The compiler compliance specified is 1.7 but a JRE 1.8 is used"));
Optional<PublishDiagnosticsParams> pomDiags = allCalls.stream().filter(p -> p.getUri().endsWith("pom.xml")).findFirst();
assertTrue("No pom.xml errors were found", pomDiags.isPresent());
diags = pomDiags.get().getDiagnostics();
Collections.sort(diags, DIAGNOSTICS_COMPARATOR);
assertEquals(diags.toString(), 1, diags.size());
assertTrue(diags.get(0).getMessage().startsWith("Project build error: "));
}
private void testDiagnostic(List<PublishDiagnosticsParams> allCalls) {
List<Diagnostic> projectDiags = new ArrayList<>();
List<Diagnostic> pomDiags = new ArrayList<>();
for (PublishDiagnosticsParams diag : allCalls) {
if (diag.getUri().endsWith("maven/salut")) {
projectDiags.addAll(diag.getDiagnostics());
} else if (diag.getUri().endsWith("pom.xml")) {
pomDiags.addAll(diag.getDiagnostics());
}
}
assertTrue("No maven/salut errors were found", projectDiags.size() > 0);
Optional<Diagnostic> projectDiag = projectDiags.stream().filter(p -> p.getMessage().contains("references non existing library")).findFirst();
assertTrue("No 'references non existing library' diagnostic", projectDiag.isPresent());
assertEquals(projectDiag.get().getSeverity(), DiagnosticSeverity.Error);
assertTrue("No pom.xml errors were found", pomDiags.size() > 0);
Optional<Diagnostic> pomDiag = pomDiags.stream().filter(p -> p.getMessage().startsWith("Missing artifact")).findFirst();
assertTrue("No 'missing artifact' diagnostic", pomDiag.isPresent());
assertTrue(pomDiag.get().getMessage().startsWith("Missing artifact"));
assertEquals(pomDiag.get().getRange().getStart().getLine(), 19);
assertEquals(pomDiag.get().getRange().getStart().getCharacter(), 3);
assertEquals(pomDiag.get().getRange().getEnd().getLine(), 19);
assertEquals(pomDiag.get().getRange().getEnd().getCharacter(), 14);
assertEquals(pomDiag.get().getSeverity(), DiagnosticSeverity.Error);
}
@Test
public void testDeletePackage() throws Exception {
importProjects("eclipse/unresolvedtype");
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject("unresolvedtype");
List<IMarker> markers = ResourceUtils.getErrorMarkers(project);
assertTrue("unresolved type in Foo.java", markers.stream().anyMatch((marker) -> marker.getResource() != null && ((IFile) marker.getResource()).getName().endsWith("Foo.java")));
reset(connection);
ArgumentCaptor<PublishDiagnosticsParams> captor = ArgumentCaptor.forClass(PublishDiagnosticsParams.class);
IFolder folder = project.getFolder("/src/pckg");
assertTrue(folder.exists());
folder.delete(true, new NullProgressMonitor());
waitForBackgroundJobs();
verify(connection, atLeastOnce()).publishDiagnostics(captor.capture());
List<PublishDiagnosticsParams> allCalls = captor.getAllValues();
List<PublishDiagnosticsParams> errors = allCalls.stream().filter((p) -> p.getUri().endsWith("Foo.java")).collect(Collectors.toList());
assertTrue("Should update the children's diagnostics of the deleted package", errors.size() == 1);
assertTrue("Should clean up the children's diagnostics of the deleted package", errors.get(0).getDiagnostics().isEmpty());
}
public void releaseStale()
{
//if any files have been removed, they will still appear in this set, so
//clear the errors so that they don't persist
for (URI uri : staleFilesWithProblems)
{
PublishDiagnosticsParams publish = new PublishDiagnosticsParams();
publish.setDiagnostics(new ArrayList<>());
publish.setUri(uri.toString());
if (languageClient != null)
{
languageClient.publishDiagnostics(publish);
}
}
staleFilesWithProblems.clear();
HashSet<URI> temp = newFilesWithProblems;
newFilesWithProblems = staleFilesWithProblems;
staleFilesWithProblems = temp;
}
protected Map<String, List<Diagnostic>> getDiagnostics() {
try {
final Function1<CancelIndicator, HashMap<String, List<Diagnostic>>> _function = (CancelIndicator it) -> {
final HashMap<String, List<Diagnostic>> result = CollectionLiterals.<String, List<Diagnostic>>newHashMap();
final Function1<Pair<String, Object>, Object> _function_1 = (Pair<String, Object> it_1) -> {
return it_1.getValue();
};
Iterable<PublishDiagnosticsParams> _filter = Iterables.<PublishDiagnosticsParams>filter(ListExtensions.<Pair<String, Object>, Object>map(this.notifications, _function_1), PublishDiagnosticsParams.class);
for (final PublishDiagnosticsParams diagnostic : _filter) {
result.put(diagnostic.getUri(), diagnostic.getDiagnostics());
}
return result;
};
return this.languageServer.getRequestManager().<HashMap<String, List<Diagnostic>>>runRead(_function).get();
} catch (Throwable _e) {
throw Exceptions.sneakyThrow(_e);
}
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams publishDiagnosticsParams) {
String uri = FileUtils.sanitizeURI(publishDiagnosticsParams.getUri());
List<Diagnostic> diagnostics = publishDiagnosticsParams.getDiagnostics();
EditorEventManager manager = EditorEventManagerBase.forUri(uri);
if (manager != null) {
manager.diagnostics(diagnostics);
}
}
@BeforeEach
void setup() {
workspaceRoot = Paths.get(System.getProperty("user.dir")).resolve(PATH_WORKSPACE);
srcRoot = workspaceRoot.resolve(PATH_SRC);
if (!Files.exists(srcRoot)) {
srcRoot.toFile().mkdirs();
}
services = new GroovyServices(new CompilationUnitFactory());
services.setWorkspaceRoot(workspaceRoot);
services.connect(new LanguageClient() {
@Override
public void telemetryEvent(Object object) {
}
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
return null;
}
@Override
public void showMessage(MessageParams messageParams) {
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
}
@Override
public void logMessage(MessageParams message) {
}
});
}
@BeforeEach
void setup() {
workspaceRoot = Paths.get(System.getProperty("user.dir")).resolve(PATH_WORKSPACE);
srcRoot = workspaceRoot.resolve(PATH_SRC);
if (!Files.exists(srcRoot)) {
srcRoot.toFile().mkdirs();
}
services = new GroovyServices(new CompilationUnitFactory());
services.setWorkspaceRoot(workspaceRoot);
services.connect(new LanguageClient() {
@Override
public void telemetryEvent(Object object) {
}
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
return null;
}
@Override
public void showMessage(MessageParams messageParams) {
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
}
@Override
public void logMessage(MessageParams message) {
}
});
}
@BeforeEach
void setup() {
workspaceRoot = Paths.get(System.getProperty("user.dir")).resolve(PATH_WORKSPACE);
srcRoot = workspaceRoot.resolve(PATH_SRC);
if (!Files.exists(srcRoot)) {
srcRoot.toFile().mkdirs();
}
services = new GroovyServices(new CompilationUnitFactory());
services.setWorkspaceRoot(workspaceRoot);
services.connect(new LanguageClient() {
@Override
public void telemetryEvent(Object object) {
}
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
return null;
}
@Override
public void showMessage(MessageParams messageParams) {
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
}
@Override
public void logMessage(MessageParams message) {
}
});
}
@BeforeEach
void setup() {
workspaceRoot = Paths.get(System.getProperty("user.dir")).resolve(PATH_WORKSPACE);
srcRoot = workspaceRoot.resolve(PATH_SRC);
if (!Files.exists(srcRoot)) {
srcRoot.toFile().mkdirs();
}
services = new GroovyServices(new CompilationUnitFactory());
services.setWorkspaceRoot(workspaceRoot);
services.connect(new LanguageClient() {
@Override
public void telemetryEvent(Object object) {
}
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
return null;
}
@Override
public void showMessage(MessageParams messageParams) {
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
}
@Override
public void logMessage(MessageParams message) {
}
});
}
public static void assertJavaDiagnostics(MicroProfileJavaDiagnosticsParams params, IPsiUtils utils,
Diagnostic... expected) {
List<PublishDiagnosticsParams> actual = PropertiesManagerForJava.getInstance().diagnostics(params, utils);
assertDiagnostics(
actual != null && actual.size() > 0 ? actual.get(0).getDiagnostics() : Collections.emptyList(),
expected);
}
@Override
public void didClose(DidCloseTextDocumentParams params) {
documents.onDidCloseTextDocument(params);
TextDocumentIdentifier document = params.getTextDocument();
String uri = document.getUri();
xmlLanguageServer.getLanguageClient()
.publishDiagnostics(new PublishDiagnosticsParams(uri, Collections.emptyList()));
getLimitExceededWarner().evictValue(uri);
}
private static void publishOneDiagnosticInRoot(DOMDocument document, String message, DiagnosticSeverity severity,
Consumer<PublishDiagnosticsParams> publishDiagnostics) {
String uri = document.getDocumentURI();
DOMElement documentElement = document.getDocumentElement();
Range range = XMLPositionUtility.selectStartTagName(documentElement);
List<Diagnostic> diagnostics = new ArrayList<>();
diagnostics.add(new Diagnostic(range, message, severity, "XML"));
publishDiagnostics.accept(new PublishDiagnosticsParams(uri, diagnostics));
}
private static XMLLanguageServer createServer(List<PublishDiagnosticsParams> actualDiagnostics) {
XMLLanguageServer languageServer = new XMLLanguageServer();
XMLLanguageClientAPI client = new XMLLanguageClientAPI() {
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
return null;
}
@Override
public void showMessage(MessageParams messageParams) {
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
actualDiagnostics.add(diagnostics);
}
@Override
public void logMessage(MessageParams message) {
}
@Override
public void telemetryEvent(Object object) {
}
@Override
public void actionableNotification(ActionableNotification notification) {
throw new UnsupportedOperationException();
}
};
languageServer.setClient(client);
return languageServer;
}
public void computeDiagnostics(String camelText, String uri) {
CompletableFuture.runAsync(() -> {
Map<CamelEndpointDetails, EndpointValidationResult> endpointErrors = endpointDiagnosticService.computeCamelEndpointErrors(camelText, uri);
TextDocumentItem openedDocument = camelLanguageServer.getTextDocumentService().getOpenedDocument(uri);
List<Diagnostic> diagnostics = endpointDiagnosticService.converToLSPDiagnostics(camelText, endpointErrors, openedDocument);
Map<String, ConfigurationPropertiesValidationResult> configurationPropertiesErrors = configurationPropertiesDiagnosticService.computeCamelConfigurationPropertiesErrors(camelText, uri);
diagnostics.addAll(configurationPropertiesDiagnosticService.converToLSPDiagnostics(configurationPropertiesErrors));
camelLanguageServer.getClient().publishDiagnostics(new PublishDiagnosticsParams(uri, diagnostics));
});
}
@Override
public void didClose(DidCloseTextDocumentParams params) {
// remove source from map
sourceTextMap.remove(params.getTextDocument().getUri());
// clear diagnostics
PublishDiagnosticsParams diagnostics = new PublishDiagnosticsParams();
diagnostics.setUri(params.getTextDocument().getUri());
diagnostics.setDiagnostics(new LinkedList<>());
this.client.publishDiagnostics(diagnostics);
// diagnostics
diagnostics(params.getTextDocument().getUri());
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
super.publishDiagnostics(diagnostics);
String uriString = issueSerializer.uri(diagnostics.getUri());
issues.removeAll(uriString);
errors.removeAll(uriString);
warnings.removeAll(uriString);
List<Diagnostic> issueList = diagnostics.getDiagnostics();
if (issueList.isEmpty()) {
return;
}
for (Diagnostic diag : issueList) {
String issueString = issueSerializer.diagnostics(diag);
issues.put(uriString, diag);
switch (diag.getSeverity()) {
case Error:
errors.put(uriString, issueString);
break;
case Warning:
warnings.put(uriString, issueString);
break;
default:
// ignore
break;
}
}
}
@Override
public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
URI uriRaw = URI.createURI(diagnostics.getUri());
if (N4Scheme.isN4Scheme(uriRaw)) {
return;
}
if (!uriRaw.isFile()) {
throw new IllegalArgumentException("not a file URI: " + uriRaw);
}
FileURI uri = new FileURI(uriRaw);
issues.removeAll(uri);
errors.removeAll(uri);
warnings.removeAll(uri);
List<Diagnostic> issueList = diagnostics.getDiagnostics();
if (issueList.isEmpty()) {
return;
}
for (Diagnostic diag : issueList) {
String issueString = getIssueString(diag);
issues.put(uri, diag);
switch (diag.getSeverity()) {
case Error:
errors.put(uri, issueString);
break;
case Warning:
warnings.put(uri, issueString);
break;
default:
// ignore
break;
}
}
}
/** Converts given issues to {@link Diagnostic}s and sends them to LSP client */
public void publishDiagnostics(URI uri, Iterable<? extends LSPIssue> issues) {
if (client != null) {
PublishDiagnosticsParams publishDiagnosticsParams = new PublishDiagnosticsParams();
publishDiagnosticsParams.setUri(uriExtensions.toUriString(uri));
List<Diagnostic> diags = toDiagnostics(issues);
publishDiagnosticsParams.setDiagnostics(diags);
client.publishDiagnostics(publishDiagnosticsParams);
}
}
@SuppressWarnings("FutureReturnValueIgnored")
private void doPublishDiagnostics(TextDocumentItem ddlDocument) {
List<Diagnostic> diagnostics = doBasicDiagnostics(ddlDocument.getText());
CompletableFuture.runAsync(() -> {
this.languageServer.getClient()
.publishDiagnostics(new PublishDiagnosticsParams(ddlDocument.getUri(), diagnostics));
});
}