Implement Java compiler plugin that generates SemanticDB.

Author: olafurpg

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/CompilerRange.java

@@ -0,0 +1,42 @@
+package com.sourcegraph.semanticdb_javac;
+
+/**
+ * Describes how to convert a compiler position into SemanticDB Range.
+ *
+ * <p>A Java compiler position has tree parts: "start", "point" and "end".
+ *
+ * <pre>
+ *     public static void main(String[] args) { }
+ *     ^ start
+ *                        ^ point (aka. "preferred position")
+ *                                              ^ end
+ * </pre>
+ *
+ * A SemanticDB range has four parts: "startLine", "startCharacter", "endLine", "endCharacter".
+ */
+public enum CompilerRange {
+  /** Map the compiler start/end positions to SemanticDB start/end positions. */
+  FROM_START_TO_END,
+
+  /**
+   * Map the compiler point position to SemanticDB start and use (point + symbol name length) for
+   * the SemanticDB end position.
+   */
+  FROM_POINT_TO_SYMBOL_NAME,
+
+  /**
+   * Map the compiler (point + 1) position to SemanticDB start and use (point + symbol name length +
+   * 1) for the SemanticDB end position.
+   */
+  FROM_POINT_TO_SYMBOL_NAME_PLUS_ONE;
+
+  public boolean isFromPoint() {
+    switch (this) {
+      case FROM_POINT_TO_SYMBOL_NAME:
+      case FROM_POINT_TO_SYMBOL_NAME_PLUS_ONE:
+        return true;
+      default:
+        return false;
+    }
+  }
+}

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/Debugging.java

@@ -0,0 +1,12 @@
+package com.sourcegraph.semanticdb_javac;
+
+/** Utility methods for debugging purposes. */
+public final class Debugging {
+  public static void pprint(Object any) {
+    StackTraceElement trace = new Exception().getStackTrace()[1];
+    if (any instanceof String) {
+      any = String.format("\"%s\"", any);
+    }
+    System.out.printf("%s:%s %s%n", trace.getFileName(), trace.getLineNumber(), any);
+  }
+}

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/EmptyEndPosTable.java

@@ -0,0 +1,22 @@
+package com.sourcegraph.semanticdb_javac;
+
+import com.sun.tools.javac.tree.EndPosTable;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.util.Position;
+
+/** A fallback implementation of EndPosTable when it's missing from the compiler. */
+public final class EmptyEndPosTable implements EndPosTable {
+
+  @Override
+  public int getEndPos(JCTree tree) {
+    return Position.NOPOS;
+  }
+
+  @Override
+  public void storeEnd(JCTree tree, int endpos) {}
+
+  @Override
+  public int replaceTree(JCTree oldtree, JCTree newtree) {
+    return Position.NOPOS;
+  }
+}

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/GlobalSymbolsCache.java

@@ -0,0 +1,125 @@
+package com.sourcegraph.semanticdb_javac;
+
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Scope;
+import com.sun.tools.javac.code.Symbol;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+
+import static com.sourcegraph.semanticdb_javac.Debugging.pprint;
+
+/** Cache of SemanticDB symbols that can be referenced between files. */
+public final class GlobalSymbolsCache {
+
+  private final IdentityHashMap<Symbol, String> globals = new IdentityHashMap<>();
+  private final SemanticdbOptions options;
+
+  public GlobalSymbolsCache(SemanticdbOptions options) {
+    this.options = options;
+  }
+
+  public String semanticdbSymbol(Symbol sym, LocalSymbolsCache locals) {
+    String result = globals.get(sym);
+    if (result != null) return result;
+    String localResult = locals.get(sym);
+    if (localResult != null) return localResult;
+    result = uncachedSemanticdbSymbol(sym, locals);
+    if (SemanticdbSymbols.isGlobal(result)) {
+      globals.put(sym, result);
+    }
+    return result;
+  }
+
+  public boolean isNone(Symbol sym) {
+    return sym == null || sym.kind == Kinds.NIL || (sym.kind & Kinds.ERRONEOUS) != 0;
+  }
+
+  private String uncachedSemanticdbSymbol(Symbol sym, LocalSymbolsCache locals) {
+    if (isNone(sym)) return SemanticdbSymbols.NONE;
+    String owner = semanticdbSymbol(sym.owner, locals);
+    if (owner.equals(SemanticdbSymbols.NONE)) {
+      return SemanticdbSymbols.ROOT_PACKAGE;
+    } else if (sym instanceof Symbol.VarSymbol && sym.isLocal()) {
+      return locals.put(sym);
+    }
+    SemanticdbSymbols.Descriptor desc = semanticdbDescriptor(sym);
+    if (options.verboseEnabled && desc.kind == SemanticdbSymbols.Descriptor.Kind.None) {
+      pprint(sym.name.toString());
+      pprint(sym.kind);
+      pprint(
+          String.format(
+              "sym: %s (%s - superclass %s)", sym, sym.getClass(), sym.getClass().getSuperclass()));
+    }
+    return SemanticdbSymbols.global(owner, desc);
+  }
+
+  private SemanticdbSymbols.Descriptor semanticdbDescriptor(Symbol sym) {
+    if (sym instanceof Symbol.ClassSymbol) {
+      return new SemanticdbSymbols.Descriptor(
+          SemanticdbSymbols.Descriptor.Kind.Type, sym.name.toString());
+    } else if (sym instanceof Symbol.MethodSymbol) {
+      return new SemanticdbSymbols.Descriptor(
+          SemanticdbSymbols.Descriptor.Kind.Method,
+          sym.name.toString(),
+          methodDisambiguator((Symbol.MethodSymbol) sym));
+    } else if (sym instanceof Symbol.PackageSymbol) {
+      return new SemanticdbSymbols.Descriptor(
+          SemanticdbSymbols.Descriptor.Kind.Package, sym.name.toString());
+    } else if (sym instanceof Symbol.TypeVariableSymbol) {
+      return new SemanticdbSymbols.Descriptor(
+          SemanticdbSymbols.Descriptor.Kind.TypeParameter, sym.name.toString());
+    } else if (sym instanceof Symbol.VarSymbol) {
+      return new SemanticdbSymbols.Descriptor(
+          SemanticdbSymbols.Descriptor.Kind.Term, sym.name.toString());
+    } else {
+      return SemanticdbSymbols.Descriptor.NONE;
+    }
+  }
+
+  /**
+   * Computes the method "disambiguator" according to the SemanticDB spec.
+   *
+   * <p><quote> Concatenation of a left parenthesis ("("), a tag and a right parenthesis (")"). If
+   * the definition is not overloaded, the tag is empty. If the definition is overloaded, the tag is
+   * computed depending on where the definition appears in the following order:
+   *
+   * <ul>
+   *   <li>non-static overloads first, following the same order as they appear in the original
+   *       source,
+   *   <li>static overloads secondly, following the same order as they appear in the original source
+   * </ul>
+   *
+   * </quote>
+   *
+   * <p><a href="https://scalameta.org/docs/semanticdb/specification.html#symbol-2">Link to
+   * SemanticDB spec</a>.
+   */
+  private String methodDisambiguator(Symbol.MethodSymbol sym) {
+    Scope.Entry lookup =
+        sym.owner.members().lookup(sym.name, s -> s instanceof Symbol.MethodSymbol);
+    ArrayList<Symbol> peers = new ArrayList<>();
+    while (lookup != null) {
+      if (lookup.sym != null) {
+        peers.add(lookup.sym);
+      }
+      lookup = lookup.next();
+    }
+    // NOTE(olafur): reverse the iteration from `Scope.Entry` to get order in which the symbols are
+    // defined in source.
+    Collections.reverse(peers);
+    // NOTE(olafur): sort static methods last, according to the spec. Historical note: this
+    // requirement is
+    // part of the SemanticDB spec because static methods and non-static methods have a different
+    // "owner" symbol.
+    // There is no way to recover the definition order for a mix of static nnon-static method
+    // definitions.
+    // In practice, it's unusual to mix static and non-static methods so this shouldn't be a big
+    // issue.
+    peers.sort((a, b) -> Boolean.compare(a.isStatic(), b.isStatic()));
+    int index = peers.indexOf(sym);
+    if (index == 0) return "()";
+    return String.format("(+%d)", index);
+  }
+}

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/LocalSymbolsCache.java

@@ -0,0 +1,23 @@
+package com.sourcegraph.semanticdb_javac;
+
+import com.sun.tools.javac.code.Symbol;
+
+import java.util.IdentityHashMap;
+
+/** Cache of SemanticDB symbols that are local to a single file. */
+public final class LocalSymbolsCache {
+
+  private final IdentityHashMap<Symbol, String> symbols = new IdentityHashMap<>();
+  private int localsCounter = -1;
+
+  public String get(Symbol sym) {
+    return symbols.get(sym);
+  }
+
+  public String put(Symbol sym) {
+    localsCounter++;
+    String result = SemanticdbSymbols.local(localsCounter);
+    symbols.put(sym, result);
+    return result;
+  }
+}

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/MD5.java

@@ -0,0 +1,35 @@
+package com.sourcegraph.semanticdb_javac;
+
+import java.nio.CharBuffer;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/** Utility to compute MD5 checksums of strings. */
+public final class MD5 {
+  private static final char[] HEX_ARRAY;
+
+  static {
+    HEX_ARRAY = "0123456789ABCDEF".toCharArray();
+  }
+
+  private static String bytesToHex(byte[] bytes) {
+    char[] hexChars = new char[bytes.length * 2];
+    int j = 0;
+    while (j < bytes.length) {
+      int v = bytes[j] & 0xFF;
+      hexChars[j * 2] = HEX_ARRAY[v >>> 4];
+      hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
+      j += 1;
+    }
+    return new String(hexChars);
+  }
+
+  public static String digest(CharSequence chars) throws NoSuchAlgorithmException {
+    CharBuffer buf = CharBuffer.wrap(chars);
+    byte[] bytes = StandardCharsets.UTF_8.encode(buf).array();
+    MessageDigest md5 = MessageDigest.getInstance("MD5");
+    md5.digest(bytes);
+    return bytesToHex(md5.digest());
+  }
+}

semanticdb-javac/src/main/java/com/sourcegraph/semanticdb_javac/Result.java

@@ -0,0 +1,107 @@
+package com.sourcegraph.semanticdb_javac;
+
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * A Java implementation of Rust's <code>Result[T, E]</code> type, or Scala's <code>Either[A, B]
+ * </code>.
+ *
+ * @param <T> The type of a successful value.
+ * @param <E> The type of the error value.
+ */
+public final class Result<T, E> {
+  private enum Kind {
+    Ok,
+    Error;
+  }
+
+  private Kind kind;
+  private final T ok;
+  private final E error;
+
+  private Result(Kind kind, T ok, E error) {
+    if (kind == Kind.Ok && ok == null)
+      throw new IllegalArgumentException("ok must not be null when kind == Kind.Ok");
+    if (kind == Kind.Error && error == null)
+      throw new IllegalArgumentException("error must not be null when kind == Kind.Error");
+    this.kind = kind;
+    this.error = error;
+    this.ok = ok;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Result<?, ?> result = (Result<?, ?>) o;
+    return kind == result.kind
+        && Objects.equals(error, result.error)
+        && Objects.equals(ok, result.ok);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(kind, error, ok);
+  }
+
+  @Override
+  public String toString() {
+    switch (kind) {
+      case Ok:
+        return "Error(" + error + ")";
+      case Error:
+        return "Ok(" + ok + ")";
+      default:
+        return "Result{" + "kind=" + kind + ", error=" + error + ", ok=" + ok + '}';
+    }
+  }
+
+  public <C> C fold(Function<T, C> onOk, Function<E, C> onError) {
+    switch (kind) {
+      case Ok:
+        return onOk.apply(ok);
+      case Error:
+        return onError.apply(error);
+      default:
+        throw new IllegalArgumentException(this.toString());
+    }
+  }
+
+  public <C> Result<C, E> map(Function<T, C> fn) {
+    return this.fold(left -> Result.ok(fn.apply(left)), Result::error);
+  }
+
+  public boolean isOk() {
+    return kind == Kind.Ok;
+  }
+
+  public boolean isError() {
+    return kind == Kind.Error;
+  }
+
+  public T getOrThrow() {
+    if (kind == Kind.Ok) {
+      return ok;
+    } else {
+      throw new NoSuchElementException("no left value on " + this.toString());
+    }
+  }
+
+  public E getErrorOrThrow() {
+    if (kind == Kind.Error) {
+      return error;
+    } else {
+      throw new NoSuchElementException("no left value on " + this.toString());
+    }
+  }
+
+  public static <T, E> Result<T, E> ok(T value) {
+    return new Result<>(Kind.Ok, value, null);
+  }
+
+  public static <T, E> Result<T, E> error(E value) {
+    return new Result<>(Kind.Error, null, value);
+  }
+}