Java 类org.eclipse.lsp4j.Diagnostic 实例源码

static Optional<Diagnostic> convert(javax.tools.Diagnostic<? extends JavaFileObject> error) {
    if (error.getStartPosition() != javax.tools.Diagnostic.NOPOS) {
        Range range = position(error);
        Diagnostic diagnostic = new Diagnostic();
        DiagnosticSeverity severity = severity(error.getKind());

        diagnostic.setSeverity(severity);
        diagnostic.setRange(range);
        diagnostic.setCode(error.getCode());
        diagnostic.setMessage(error.getMessage(null));

        return Optional.of(diagnostic);
    } else {
        LOG.warning("Skipped " + error.getMessage(Locale.getDefault()));

        return Optional.empty();
    }
}

private static Range position(javax.tools.Diagnostic<? extends JavaFileObject> error) {
    if (error instanceof ClientCodeWrapper.DiagnosticSourceUnwrapper)
        error = ((ClientCodeWrapper.DiagnosticSourceUnwrapper) error).d;

    JCDiagnostic diagnostic = (JCDiagnostic) error;
    DiagnosticSource source = diagnostic.getDiagnosticSource();
    long start = error.getStartPosition(), end = error.getEndPosition();

    if (end == start) end = start + 1;

    return new Range(
            new Position(
                    source.getLineNumber((int) start) - 1,
                    source.getColumnNumber((int) start, true) - 1),
            new Position(
                    source.getLineNumber((int) end) - 1,
                    source.getColumnNumber((int) end, true) - 1));
}

private static void checkFileNameMatchesModule(final MixinDefinition def,
    final String fileName,
    final List<Diagnostic> diagnostics) {
  String moduleName = fileName;
  if (moduleName.contains(".")) {
    moduleName = moduleName.substring(0, moduleName.indexOf("."));
  }

  if (!moduleName.equals(def.getName().getString())) {

    diagnostics.add(new Diagnostic(
        toRange(def.getNameSourceSection()),
        "Module name '" + def.getName().getString() + "' does not match file name '"
            + fileName
            + "'.",
        DiagnosticSeverity.Information, LINT_NAME));
  }
}

private void loadWorkspaceAndLint(final File workspace) {
  Map<String, List<Diagnostic>> allDiagnostics = new HashMap<>();
  loadFolder(workspace, allDiagnostics);

  for (Entry<String, List<Diagnostic>> e : allDiagnostics.entrySet()) {
    try {
      lintSends(e.getKey(), e.getValue());
    } catch (URISyntaxException ex) {
      /*
       * at this point, there is nothing to be done anymore,
       * would have been problematic earlier
       */
    }

    reportDiagnostics(e.getValue(), e.getKey());
  }
}

private void loadFolder(final File folder,
    final Map<String, List<Diagnostic>> allDiagnostics) {
  for (File f : folder.listFiles()) {
    if (f.isDirectory()) {
      loadFolder(f, allDiagnostics);
    } else if (f.getName().endsWith(FILE_ENDING)) {
      try {
        byte[] content = Files.readAllBytes(f.toPath());
        String str = new String(content, StandardCharsets.UTF_8);
        String uri = f.toURI().toString();
        List<Diagnostic> diagnostics = parse(str, uri);
        allDiagnostics.put(uri, diagnostics);
      } catch (IOException | URISyntaxException e) {
        // if loading fails, we don't do anything, just move on to the next file
      }
    }
  }
}

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 testMavenMarkers() throws Exception {
    String msg1 = "Some dependency is missing";
    IMarker m1 = createMavenMarker(IMarker.SEVERITY_ERROR, msg1, 2, 95, 100);

    IDocument d = mock(IDocument.class);
    when(d.getLineOffset(1)).thenReturn(90);

    List<Diagnostic> diags = handler.toDiagnosticsArray(d, new IMarker[]{m1, null});
    assertEquals(1, diags.size());

    Range r;
    Diagnostic d1 = diags.get(0);
    assertEquals(msg1, d1.getMessage());
    assertEquals(DiagnosticSeverity.Error, d1.getSeverity());
    r = d1.getRange();
    assertEquals(1, r.getStart().getLine());
    assertEquals(95, r.getStart().getCharacter());
    assertEquals(1, r.getEnd().getLine());
    assertEquals(100, r.getEnd().getCharacter());
}

@Test
public void testInitializeBuildWithError() {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("type Test {");
  _builder.newLine();
  _builder.append("    ");
  _builder.append("NonExisting foo");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  this.writeFile("MyType1.testlang", _builder);
  this.initialize();
  Diagnostic _head = IterableExtensions.<Diagnostic>head(IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values()));
  String _message = null;
  if (_head!=null) {
    _message=_head.getMessage();
  }
  this.assertEquals("Couldn\'t resolve reference to TypeDeclaration \'NonExisting\'.", _message);
  Assert.assertEquals(1, IterableExtensions.<Diagnostic>head(IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values())).getRange().getStart().getLine());
  Assert.assertEquals(4, IterableExtensions.<Diagnostic>head(IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values())).getRange().getStart().getCharacter());
  Assert.assertEquals(1, IterableExtensions.<Diagnostic>head(IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values())).getRange().getEnd().getLine());
  Assert.assertEquals(15, IterableExtensions.<Diagnostic>head(IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values())).getRange().getEnd().getCharacter());
}

@Override
public List<? extends Command> getCodeActions(final Document document, final XtextResource resource, final CodeActionParams params, final CancelIndicator indicator) {
  final ArrayList<Command> commands = CollectionLiterals.<Command>newArrayList();
  List<Diagnostic> _diagnostics = params.getContext().getDiagnostics();
  for (final Diagnostic d : _diagnostics) {
    String _code = d.getCode();
    if (_code != null) {
      switch (_code) {
        case TestLanguageValidator.INVALID_NAME:
          Command _fixInvalidName = this.fixInvalidName(d, document, resource, params);
          commands.add(_fixInvalidName);
          break;
        case TestLanguageValidator.UNSORTED_MEMBERS:
          Command _fixUnsortedMembers = this.fixUnsortedMembers(d, document, resource, params);
          commands.add(_fixUnsortedMembers);
          break;
      }
    }
  }
  return commands;
}

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);
  }
}

public void processDiagnostics(ExtendedPublishDiagnosticsParams diagnosticsMessage) {
  EditorPartPresenter openedEditor =
      editorAgent.getOpenedEditor(new Path(diagnosticsMessage.getParams().getUri()));
  // TODO add markers
  if (openedEditor == null) {
    return;
  }

  if (openedEditor instanceof TextEditor) {
    TextEditorConfiguration editorConfiguration = ((TextEditor) openedEditor).getConfiguration();
    AnnotationModel annotationModel = editorConfiguration.getAnnotationModel();
    if (annotationModel != null && annotationModel instanceof DiagnosticCollector) {
      DiagnosticCollector collector = (DiagnosticCollector) annotationModel;
      String languageServerId = diagnosticsMessage.getLanguageServerId();
      collector.beginReporting(languageServerId);
      try {
        for (Diagnostic diagnostic : diagnosticsMessage.getParams().getDiagnostics()) {
          collector.acceptDiagnostic(languageServerId, diagnostic);
        }
      } finally {
        collector.endReporting(languageServerId);
      }
    }
  }
}

private Stream<Command> codeActionsFor(Diagnostic diagnostic) {
    if (diagnostic.getCode().equals("compiler.err.cant.resolve.location")) {
        return cannotFindSymbolClassName(diagnostic.getMessage())
                .map(Stream::of)
                .orElseGet(Stream::empty)
                .flatMap(this::addImportActions);
    } else return Stream.empty();
}

private static DiagnosticSeverity severity(javax.tools.Diagnostic.Kind kind) {
    switch (kind) {
        case ERROR:
            return DiagnosticSeverity.Error;
        case WARNING:
        case MANDATORY_WARNING:
            return DiagnosticSeverity.Warning;
        case NOTE:
        case OTHER:
        default:
            return DiagnosticSeverity.Information;
    }
}

private void parseDocument(final String documentUri, final String text) {
  try {
    List<Diagnostic> diagnostics = som.parse(text, documentUri);
    som.lintSends(documentUri, diagnostics);
    som.reportDiagnostics(diagnostics, documentUri);
  } catch (URISyntaxException ex) {
    ex.printStackTrace(ServerLauncher.errWriter());
  }
}

public static void checkModuleName(final String filepath, final MixinDefinition def,
    final List<Diagnostic> diagnostics) {
  File f = new File(filepath);
  String name = f.getName();
  checkFileEnding(name, diagnostics);

  checkFileNameMatchesModule(def, name, diagnostics);
}

public static void checkSends(final Map<String, SomStructures> structuralProbes,
    final SomStructures newProbe, final List<Diagnostic> diagnostics) {
  Collection<SomStructures> probes;
  synchronized (structuralProbes) {
    probes = new ArrayList<>(structuralProbes.values());
  }

  List<Call> calls = newProbe.getCalls();
  for (Call c : calls) {
    if (newProbe.defines(c.selector)) {
      continue;
    }

    boolean defined = false;
    for (SomStructures p : probes) {
      if (p.defines(c.selector)) {
        defined = true;
        break;
      }
    }

    if (!defined) {
      Range r = new Range(pos(c.sections[0].getStartLine(), c.sections[0].getStartColumn()),
          pos(c.sections[c.sections.length - 1].getEndLine(),
              c.sections[c.sections.length - 1].getEndColumn() + 1));
      diagnostics.add(new Diagnostic(r,
          "No " + c.selector.getString() + " defined. Might cause run time error.",
          DiagnosticSeverity.Warning, LINT_NAME));
    }
  }
}

public void lintSends(final String docUri, final List<Diagnostic> diagnostics)
    throws URISyntaxException {
  SomStructures probe;
  synchronized (structuralProbes) {
    probe = structuralProbes.get(docUriToNormalizedPath(docUri));
  }
  SomLint.checkSends(structuralProbes, probe, diagnostics);
}

private List<Diagnostic> toDiagnostics(final ParseError e,
    final List<Diagnostic> diagnostics) {
  Diagnostic d = new Diagnostic();
  d.setSeverity(DiagnosticSeverity.Error);

  SourceCoordinate coord = e.getSourceCoordinate();
  d.setRange(toRangeMax(coord));
  d.setMessage(e.getMessage());
  d.setSource("Parser");

  diagnostics.add(d);
  return diagnostics;
}

private List<Diagnostic> toDiagnostics(final SemanticDefinitionError e,
    final List<Diagnostic> diagnostics) {
  SourceSection source = e.getSourceSection();

  Diagnostic d = new Diagnostic();
  d.setSeverity(DiagnosticSeverity.Error);
  d.setRange(toRange(source));
  d.setMessage(e.getMessage());
  d.setSource("Parser");

  diagnostics.add(d);
  return diagnostics;
}

private List<Diagnostic> toDiagnostics(final String msg,
    final List<Diagnostic> diagnostics) {
  Diagnostic d = new Diagnostic();
  d.setSeverity(DiagnosticSeverity.Error);

  d.setMessage(msg);
  d.setSource("Parser");

  diagnostics.add(d);
  return diagnostics;
}

public void reportDiagnostics(final List<Diagnostic> diagnostics,
    final String documentUri) {
  if (diagnostics != null) {
    PublishDiagnosticsParams result = new PublishDiagnosticsParams();
    result.setDiagnostics(diagnostics);
    result.setUri(documentUri);
    client.publishDiagnostics(result);
  }
}

private void publishDiagnostics(List<IMarker> markers) {
    Map<IResource, List<IMarker>> map = markers.stream().collect(Collectors.groupingBy(IMarker::getResource));
    for (Map.Entry<IResource, List<IMarker>> entry : map.entrySet()) {
        IResource resource = entry.getKey();
        // ignore problems caused by standalone files
        if (JavaLanguageServerPlugin.getProjectsManager().getDefaultProject().equals(resource.getProject())) {
            continue;
        }
        IFile file = resource.getAdapter(IFile.class);
        if (file == null) {
            continue;
        }
        IDocument document = null;
        String uri = JDTUtils.getFileURI(resource);
        if (JavaCore.isJavaLikeFileName(file.getName())) {
            ICompilationUnit cu = JDTUtils.resolveCompilationUnit(uri);
            try {
                document = JsonRpcHelpers.toDocument(cu.getBuffer());
            } catch (JavaModelException e) {
                logException("Failed to publish diagnostics.", e);
            }
        }
        else if (projectsManager.isBuildFile(file)) {
            document = JsonRpcHelpers.toDocument(file);
        }

        if (document != null) {
            List<Diagnostic> diagnostics = WorkspaceDiagnosticsHandler.toDiagnosticsArray(document, entry.getValue().toArray(new IMarker[0]));
            connection.publishDiagnostics(new PublishDiagnosticsParams(ResourceUtils.toClientUri(uri), diagnostics));
        }
    }
}

public static List<Diagnostic> toDiagnosticsArray(List<IProblem> problems) {
    List<Diagnostic> array = new ArrayList<>(problems.size());
    for (IProblem problem : problems) {
        Diagnostic diag = new Diagnostic();
        diag.setSource(JavaLanguageServerPlugin.SERVER_SOURCE_ID);
        diag.setMessage(problem.getMessage());
        diag.setCode(Integer.toString(problem.getID()));
        diag.setSeverity(convertSeverity(problem));
        diag.setRange(convertRange(problem));
        array.add(diag);
    }
    return array;
}

/**
 * Transforms {@link IMarker}s of a {@link IDocument} into a list of {@link Diagnostic}s.
 *
 * @param document
 * @param markers
 * @return a list of {@link Diagnostic}s
 */
public static List<Diagnostic> toDiagnosticsArray(IDocument document, IMarker[] markers) {
    List<Diagnostic> diagnostics = Stream.of(markers)
            .map(m -> toDiagnostic(document, m))
            .filter(d -> d != null)
            .collect(Collectors.toList());
    return diagnostics;
}

private static Diagnostic toDiagnostic(IDocument document, IMarker marker) {
    if (marker == null || !marker.exists()) {
        return null;
    }
    Diagnostic d = new Diagnostic();
    d.setSource(JavaLanguageServerPlugin.SERVER_SOURCE_ID);
    d.setMessage(marker.getAttribute(IMarker.MESSAGE, ""));
    d.setCode(String.valueOf(marker.getAttribute(IJavaModelMarker.ID, 0)));
    d.setSeverity(convertSeverity(marker.getAttribute(IMarker.SEVERITY, -1)));
    d.setRange(convertRange(document, marker));
    return d;
}

private IProblemLocation[] getProblemLocations(ICompilationUnit unit, List<Diagnostic> diagnostics) {
    IProblemLocation[] locations = new IProblemLocation[diagnostics.size()];
    for (int i = 0; i < diagnostics.size(); i++) {
        Diagnostic diagnostic = diagnostics.get(i);
        int problemId = getProblemId(diagnostic);
        int start = DiagnosticsHelper.getStartOffset(unit, diagnostic.getRange());
        int end = DiagnosticsHelper.getEndOffset(unit, diagnostic.getRange());
        boolean isError = diagnostic.getSeverity() == DiagnosticSeverity.Error;
        locations[i] = new ProblemLocation(start, end - start, problemId, isError);
    }
    return locations;
}

private int getProblemId(Diagnostic diagnostic) {
    int $ = 0;
    try {
        $ = Integer.parseInt(diagnostic.getCode());
    } catch (NumberFormatException e) {
        // return 0
    }
    return $;
}

private Diagnostic getDiagnostic(String code, Range range){
    Diagnostic $ = new Diagnostic();
    $.setCode(code);
    $.setRange(range);
    $.setSeverity(DiagnosticSeverity.Error);
    $.setMessage("Test Diagnostic");
    return $;
}

@Test
public void testDidOpenStandaloneFileWithSyntaxError() 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 {\n"+
            "   public void method1(){\n"+
            "       super.whatever()\n"+
            "   }\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("Unexpected number of errors " + diagParam.getDiagnostics(), 1, diagParam.getDiagnostics().size());
    Diagnostic d = diagParam.getDiagnostics().get(0);
    assertEquals("Syntax error, insert \";\" to complete BlockStatements", d.getMessage());
    assertRange(3, 17, 18, d.getRange());
}

@Test
public void testDidOpenStandaloneFileWithNonSyntaxErrors() 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 {\n"+
            "   public static void notThis(){\n"+
            "       System.out.println(this);\n"+
            "   }\n"+
            "   public void method1(){\n"+
            "   }\n"+
            "   public void method1(){\n"+
            "   }\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("Unexpected number of errors " + diagParam.getDiagnostics(), 3, diagParam.getDiagnostics().size());
    Diagnostic d = diagParam.getDiagnostics().get(0);
    assertEquals("Cannot use this in a static context", d.getMessage());
    assertRange(3, 21, 25, d.getRange());

    d = diagParam.getDiagnostics().get(1);
    assertEquals("Duplicate method method1() in type Foo", d.getMessage());
    assertRange(5, 13, 22, d.getRange());

    d = diagParam.getDiagnostics().get(2);
    assertEquals("Duplicate method method1() in type Foo", d.getMessage());
    assertRange(7, 13, 22, d.getRange());
}

@Test
public void testMarkerListening() throws Exception {
    InitHandler initHandler = new InitHandler(projectsManager, preferenceManager, connection);
    initHandler.addWorkspaceDiagnosticsHandler();
    //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> fooDiags = allCalls.stream().filter(p -> p.getUri().endsWith("Foo.java")).findFirst();
    assertTrue("No Foo.java errors were found", fooDiags.isPresent());
    List<Diagnostic> diags = fooDiags.get().getDiagnostics();
    Comparator<Diagnostic> comparator = (Diagnostic d1, Diagnostic d2) -> {
        int diff = d1.getRange().getStart().getLine() - d2.getRange().getStart().getLine();
        if (diff == 0) {
            diff = d1.getMessage().compareTo(d2.getMessage());
        }
        return diff;
    };
    Collections.sort(diags, comparator );
    assertEquals(diags.toString(), 2, diags.size());
    assertEquals("The import org cannot be resolved", diags.get(0).getMessage());
    assertEquals("StringUtils cannot be resolved", diags.get(1).getMessage());

    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, comparator);
    assertEquals(diags.toString(), 3, diags.size());
    assertTrue(diags.get(0).getMessage()
            .startsWith("For artifact {org.apache.commons:commons-lang3:null:jar}: The version cannot be empty. (org.apache.maven.plugins:maven-resources-plugin:2.6:resources:default-resources:process-resources)"));
    assertTrue(diags.get(1).getMessage()
            .startsWith("For artifact {org.apache.commons:commons-lang3:null:jar}: The version cannot be empty. (org.apache.maven.plugins:maven-resources-plugin:2.6:testResources:default-testResources:process-test-resources)"));
    assertEquals("Project build error: 'dependencies.dependency.version' for org.apache.commons:commons-lang3:jar is missing.", diags.get(2).getMessage());
}

@Test
public void testOpenedDocumentShadowsPersistedFile() {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("type Test {");
  _builder.newLine();
  _builder.append("    ");
  _builder.append("NonExisting foo");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  final String firstFile = this.writeFile("MyType1.testlang", _builder);
  this.initialize();
  this.assertEquals("Couldn\'t resolve reference to TypeDeclaration \'NonExisting\'.", IterableExtensions.<Diagnostic>head(this.getDiagnostics().get(firstFile)).getMessage());
  StringConcatenation _builder_1 = new StringConcatenation();
  _builder_1.append("type Foo {");
  _builder_1.newLine();
  _builder_1.append("}");
  _builder_1.newLine();
  final String path = this.writeFile("MyType2.testlang", _builder_1);
  WorkspaceService _workspaceService = this.languageServer.getWorkspaceService();
  FileEvent _fileEvent = new FileEvent(path, FileChangeType.Created);
  DidChangeWatchedFilesParams _didChangeWatchedFilesParams = new DidChangeWatchedFilesParams(
    Collections.<FileEvent>unmodifiableList(CollectionLiterals.<FileEvent>newArrayList(_fileEvent)));
  _workspaceService.didChangeWatchedFiles(_didChangeWatchedFilesParams);
  this.assertEquals("Couldn\'t resolve reference to TypeDeclaration \'NonExisting\'.", IterableExtensions.<Diagnostic>head(this.getDiagnostics().get(firstFile)).getMessage());
  StringConcatenation _builder_2 = new StringConcatenation();
  _builder_2.append("type NonExisting {");
  _builder_2.newLine();
  _builder_2.append("}");
  _builder_2.newLine();
  this.open(path, _builder_2.toString());
  Assert.assertNull(IterableExtensions.<Diagnostic>head(this.getDiagnostics().get(firstFile)));
  this.close(path);
  this.assertEquals("Couldn\'t resolve reference to TypeDeclaration \'NonExisting\'.", IterableExtensions.<Diagnostic>head(this.getDiagnostics().get(firstFile)).getMessage());
}

@Test
public void testInitializeBuild() {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("type Test {");
  _builder.newLine();
  _builder.append("    ");
  _builder.append("string foo");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  this.writeFile("MyType1.testlang", _builder);
  this.initialize();
  Assert.assertTrue(IterableExtensions.join(this.getDiagnostics().entrySet(), ","), IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values()).isEmpty());
}

@Test
public void testIncrementalBuildWithError() {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("type Test {");
  _builder.newLine();
  _builder.append("    ");
  _builder.append("NonExisting foo");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  this.writeFile("MyType1.testlang", _builder);
  this.initialize();
  this.assertEquals("Couldn\'t resolve reference to TypeDeclaration \'NonExisting\'.", IterableExtensions.<Diagnostic>head(IterableExtensions.<List<Diagnostic>>head(this.getDiagnostics().values())).getMessage());
  StringConcatenation _builder_1 = new StringConcatenation();
  _builder_1.append("type NonExisting {");
  _builder_1.newLine();
  _builder_1.append("}");
  _builder_1.newLine();
  final String path = this.writeFile("MyType2.testlang", _builder_1);
  WorkspaceService _workspaceService = this.languageServer.getWorkspaceService();
  FileEvent _fileEvent = new FileEvent(path, FileChangeType.Created);
  DidChangeWatchedFilesParams _didChangeWatchedFilesParams = new DidChangeWatchedFilesParams(Collections.<FileEvent>unmodifiableList(CollectionLiterals.<FileEvent>newArrayList(_fileEvent)));
  _workspaceService.didChangeWatchedFiles(_didChangeWatchedFilesParams);
  Assert.assertNotNull(this.getDiagnostics().get(path));
  final Function1<List<Diagnostic>, Boolean> _function = (List<Diagnostic> it) -> {
    return Boolean.valueOf(it.isEmpty());
  };
  Assert.assertTrue(IterableExtensions.join(this.getDiagnostics().values(), ","), IterableExtensions.<List<Diagnostic>>forall(this.getDiagnostics().values(), _function));
}

public DiagnosticAnnotation(Diagnostic diagnostic) {

    this.diagnostic = diagnostic;

    DiagnosticSeverity severity = diagnostic.getSeverity();
    if (severity == null) {
      layer = ERROR_LAYER;
      setType(ERROR_ANNOTATION_TYPE);
    } else {
      switch (severity) {
        case Error:
          layer = ERROR_LAYER;
          setType(ERROR_ANNOTATION_TYPE);
          break;
        case Warning:
          layer = WARNING_LAYER;
          setType(WARNING_ANNOTATION_TYPE);
          break;
        case Information:
          layer = INFO_LAYER;
          setType(INFO_ANNOTATION_TYPE);
          break;
        case Hint:
          layer = HINT_LAYER;
          setType(HINT_ANNOTATION_TYPE);
          break;
        default:
          layer = ERROR_LAYER;
          setType(ERROR_ANNOTATION_TYPE);
          break;
      }
    }
  }

protected Position createPositionFromDiagnostic(final Diagnostic diagnostic) {
  DocumentHandle documentHandle = getDocumentHandle();
  Document document = documentHandle.getDocument();
  Range range = diagnostic.getRange();
  int start =
      document.getIndexFromPosition(
          new TextPosition(range.getStart().getLine(), range.getStart().getCharacter()));
  int end =
      document.getIndexFromPosition(
          new TextPosition(range.getEnd().getLine(), range.getEnd().getCharacter()));

  if (start == -1 && end == -1) {
    return new Position(0);
  }

  if (start == -1) {
    return new Position(end);
  }

  if (end == -1) {
    return new Position(start);
  }

  int length = end - start;
  if (length < 0) {
    return null;
  }
  return new Position(start, length);
}

public void reconcilePath(String fileLocation, String projectPath) {
  String fileName = new Path(fileLocation).lastSegment();
  if (!POM_FILE_NAME.equals(fileName)) {
    return;
  }

  EditorWorkingCopy workingCopy = editorWorkingCopyManager.getWorkingCopy(fileLocation);
  if (workingCopy == null) {
    return;
  }

  String newPomContent = workingCopy.getContentAsString();
  if (isNullOrEmpty(newPomContent)) {
    return;
  }

  List<Problem> problems;
  try {
    problems = reconcile(fileLocation, projectPath, newPomContent);
    List<Diagnostic> diagnostics = convertProblems(newPomContent, problems);
    client.publishDiagnostics(
        new PublishDiagnosticsParams(LanguageServiceUtils.prefixURI(fileLocation), diagnostics));
  } catch (ServerException | NotFoundException e) {
    LOG.error(e.getMessage(), e);
    client.showMessage(new MessageParams(MessageType.Error, "Error reconciling " + fileLocation));
  }
}

public void reconcileUri(String uri, String text) {
  try {
    String pomPath = LanguageServiceUtils.removePrefixUri(uri);
    List<Problem> problems = reconcile(pomPath, new File(pomPath).getParent(), text);
    List<Diagnostic> diagnostics = convertProblems(text, problems);
    client.publishDiagnostics(new PublishDiagnosticsParams(uri, diagnostics));
  } catch (ServerException | NotFoundException e) {
    LOG.error("Error reconciling content: " + uri, e);
    client.showMessage(new MessageParams(MessageType.Error, "Error reconciling " + uri));
  }
}

private static List<Diagnostic> convertProblems(String text, List<Problem> problems) {
  Map<Integer, Position> positions = mapPositions(text, problems);
  List<Diagnostic> diagnostics =
      problems
          .stream()
          .map((Problem p) -> convertProblem(positions, p))
          .filter(o -> o != null)
          .collect(Collectors.toList());
  return diagnostics;
}

private static Diagnostic convertProblem(Map<Integer, Position> positionMap, Problem problem) {
  Diagnostic result = new Diagnostic();
  Position start = positionMap.get(problem.getSourceStart());
  Position end = positionMap.get(problem.getSourceEnd());
  if (start == null || end == null) {
    LOG.error("Could not map problem range: " + problem);
    return null;
  }
  result.setRange(new Range(start, end));
  result.setMessage(problem.getMessage());
  result.setSeverity(problem.isError() ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning);
  return result;
}