flatten AnnotationTree and replace Annotation with it in SymbolInformation

Author: Strum355

lsif-semanticdb/src/main/java/com/sourcegraph/lsif_semanticdb/SignatureFormatter.java

@@ -249,29 +249,32 @@ private String formatAnnotations(SymbolInformation symInfo) {
         .collect(Collectors.joining("\n"));
   }
 
-  private String formatAnnotation(Annotation annotation) {
+  private String formatAnnotation(AnnotationTree annotation) {
     StringBuilder b = new StringBuilder();
     b.append('@');
     b.append(formatType(annotation.getTpe()));
     if (annotation.getParametersCount() > 0) {
       b.append('(');
-      Annotation.ParameterPair firstParam = annotation.getParameters(0);
+      AssignTree firstParam = annotation.getParameters(0).getAssignTree();
       // if only 1 parameter, and its LHS is named 'value', we can omit the 'value = '
-      // docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.7.3
+      // https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.7.3
       if (annotation.getParametersCount() == 1
-          && SymbolDescriptor.parseFromSymbol(firstParam.getKey())
+          && SymbolDescriptor.parseFromSymbol(firstParam.getLhs().getIdTree().getSymbol())
               .descriptor
               .name
               .equals("value")) {
-        b.append(formatTree(firstParam.getValue()));
+        b.append(formatTree(firstParam.getRhs()));
       } else {
         String parameter =
             annotation.getParametersList().stream()
                 .map(
                     p ->
-                        SymbolDescriptor.parseFromSymbol(p.getKey()).descriptor.name
+                        SymbolDescriptor.parseFromSymbol(
+                                    p.getAssignTree().getLhs().getIdTree().getSymbol())
+                                .descriptor
+                                .name
                             + " = "
-                            + formatTree(p.getValue()))
+                            + formatTree(p.getAssignTree().getRhs()))
                 .collect(Collectors.joining(", "));
         b.append(parameter);
       }
@@ -292,7 +295,7 @@ private String formatTree(Tree tree) {
               .descriptor
               .name;
     } else if (tree.hasAnnotationTree()) {
-      return formatAnnotation(tree.getAnnotationTree().getAnnotation());
+      return formatAnnotation(tree.getAnnotationTree());
     } else if (tree.hasApplyTree()) {
       if (tree.getApplyTree().getFunction().hasIdTree()
           && tree.getApplyTree().getFunction().getIdTree().getSymbol().equals(ARRAY_SYMBOL)) {

semanticdb-java/src/main/protobuf/semanticdb.proto

@@ -103,24 +103,15 @@ message SymbolInformation {
   Kind kind = 3;
   int32 properties = 4;
   string display_name = 5;
-  repeated Annotation annotations = 13;
+  // -- OUT OF SPEC -- //
+  repeated AnnotationTree annotations = 13;
+  // -- OUT OF SPEC -- //
   Signature signature = 17;
   Access access = 18;
   repeated string overridden_symbols = 19;
   Documentation documentation = 20;
 }
 
-message Annotation {
-  Type tpe = 1;
-  // -- OUT OF SPEC -- //
-  message ParameterPair {
-    string key = 1;
-    Tree value = 2;
-  }
-  repeated ParameterPair parameters = 2;
-  // -- OUT OF SPEC -- //
-}
-
 message Access {
   oneof sealed_value {
     PrivateAccess private_access = 1;
@@ -200,7 +191,8 @@ message Tree {
     OriginalTree original_tree = 6;
     SelectTree select_tree = 7;
     // -- OUT OF SPEC -- //
-    AnnotationTree annotation_tree = 8;
+    AnnotationTree annotation_tree = 9;
+    AssignTree assign_tree = 10;
     // -- OUT OF SPEC -- //
   }
 }
@@ -227,9 +219,17 @@ message SelectTree {
   IdTree id = 2;
 }
 
+// -- OUT OF SPEC -- //
 message AnnotationTree {
-  Annotation annotation = 1;
+  Type tpe = 1;
+  repeated Tree parameters = 2;
+}
+
+message AssignTree {
+    Tree lhs = 1;
+    Tree rhs = 2;
 }
+// -- OUT OF SPEC -- //
 
 message Constant {
   oneof sealed_value {

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

@@ -13,8 +13,6 @@
 import com.sourcegraph.semanticdb_javac.Semanticdb.SymbolInformation.Property;
 import com.sourcegraph.semanticdb_javac.Semanticdb.SymbolOccurrence.Role;
 
-import javax.lang.model.type.PrimitiveType;
-import javax.lang.model.type.TypeKind;
 import javax.lang.model.util.Elements;
 import java.io.IOException;
 import java.nio.file.Path;
@@ -91,7 +89,7 @@ private void emitSymbolInformation(Symbol sym, JCTree tree) {
     if (documentation != null) builder.setDocumentation(documentation);
     Semanticdb.Signature signature = semanticdbSignature(sym);
     if (signature != null) builder.setSignature(signature);
-    List<Semanticdb.Annotation> annotations = semanticdbAnnotations(tree);
+    List<Semanticdb.AnnotationTree> annotations = semanticdbAnnotations(tree);
     if (annotations != null) builder.addAllAnnotations(annotations);
 
     builder
@@ -311,12 +309,12 @@ private String semanticdbMd5() {
     }
   }
 
-  private List<Semanticdb.Annotation> semanticdbAnnotations(JCTree node) {
+  private List<Semanticdb.AnnotationTree> semanticdbAnnotations(JCTree node) {
     if (!(node instanceof JCTree.JCClassDecl)
         && !(node instanceof JCTree.JCVariableDecl)
         && !(node instanceof JCTree.JCMethodDecl)) return null;
 
-    List<Semanticdb.Annotation> annotations = new ArrayList<>();
+    List<Semanticdb.AnnotationTree> annotations = new ArrayList<>();
 
     JCTree.JCModifiers mods;
     if (node instanceof JCTree.JCClassDecl) {
@@ -334,26 +332,31 @@ private List<Semanticdb.Annotation> semanticdbAnnotations(JCTree node) {
     return annotations;
   }
 
-  private Semanticdb.Annotation.Builder semanticdbAnnotation(JCTree.JCAnnotation annotation) {
-    Semanticdb.Annotation.Builder builder = Semanticdb.Annotation.newBuilder();
-    builder.setTpe(new SemanticdbTypeVisitor(globals, locals).visit(annotation.type));
+  private Semanticdb.AnnotationTree.Builder semanticdbAnnotation(JCTree.JCAnnotation annotation) {
+    Semanticdb.AnnotationTree.Builder annotationBuilder = Semanticdb.AnnotationTree.newBuilder();
+    annotationBuilder.setTpe(new SemanticdbTypeVisitor(globals, locals).visit(annotation.type));
 
     for (JCTree.JCExpression param : annotation.args) {
-      Semanticdb.Annotation.ParameterPair.Builder parameterBuilder =
-          Semanticdb.Annotation.ParameterPair.newBuilder();
+      Semanticdb.AssignTree.Builder parameterBuilder = Semanticdb.AssignTree.newBuilder();
 
       // anecdotally always JCAssign
       JCTree.JCAssign assign = (JCTree.JCAssign) param;
       JCTree.JCExpression assignValue = assign.rhs;
 
-      parameterBuilder.setKey(globals.semanticdbSymbol(((JCTree.JCIdent) assign.lhs).sym, locals));
+      parameterBuilder.setLhs(
+          Semanticdb.Tree.newBuilder()
+              .setIdTree(
+                  Semanticdb.IdTree.newBuilder()
+                      .setSymbol(
+                          globals.semanticdbSymbol(((JCTree.JCIdent) assign.lhs).sym, locals))
+                      .build()));
 
-      parameterBuilder.setValue(semanticdbAnnotationParameter(assignValue));
+      parameterBuilder.setRhs(semanticdbAnnotationParameter(assignValue));
 
-      builder.addParameters(parameterBuilder);
+      annotationBuilder.addParameters(Semanticdb.Tree.newBuilder().setAssignTree(parameterBuilder));
     }
 
-    return builder;
+    return annotationBuilder;
   }
 
   private Semanticdb.Tree.Builder semanticdbAnnotationParameter(JCTree.JCExpression expr) {
@@ -457,9 +460,7 @@ private Semanticdb.Tree.Builder semanticdbAnnotationParameter(JCTree.JCExpressio
       return Semanticdb.Tree.newBuilder().setLiteralTree(literalBuilder);
     } else if (expr instanceof JCTree.JCAnnotation) {
       return Semanticdb.Tree.newBuilder()
-          .setAnnotationTree(
-              Semanticdb.AnnotationTree.newBuilder()
-                  .setAnnotation(semanticdbAnnotation((JCTree.JCAnnotation) expr)));
+          .setAnnotationTree(semanticdbAnnotation((JCTree.JCAnnotation) expr));
     } else if (expr instanceof JCTree.JCIdent) {
       return Semanticdb.Tree.newBuilder()
           .setIdTree(

tests/snapshots/src/main/generated/minimized/Annotations.java

@@ -60,4 +60,4 @@
   String format() default "";
 //^^^^^^ reference java/lang/String#
 //       ^^^^^^ definition minimized/Annotations#format(). public abstract String format()
-}
+}