Formatting

Author: antonsviridov-src

scip-semanticdb/src/main/java/com/sourcegraph/scip_semanticdb/SignatureFormatter.java

@@ -471,7 +471,11 @@ private String formatTree(Tree tree) {
     } else if (tree.hasUnaryopTree()) {
       return formatUnaryOperation(tree.getUnaryopTree());
     } else if (tree.hasCastTree()) {
-      return "(" + formatType(tree.getCastTree().getTpe()) + ")" + " " + formatTree(tree.getCastTree().getValue());
+      return "("
+          + formatType(tree.getCastTree().getTpe())
+          + ")"
+          + " "
+          + formatTree(tree.getCastTree().getValue());
     }
 
     throw new IllegalArgumentException("tree was of unexpected type " + tree);

semanticdb-java/src/main/java/com/sourcegraph/semanticdb_javac/SemanticdbBuilders.java

@@ -154,7 +154,6 @@ public static Semanticdb.Tree tree(Semanticdb.CastTree castTree) {
     return Semanticdb.Tree.newBuilder().setCastTree(castTree).build();
   }
 
-
   public static Semanticdb.UnaryOperatorTree unaryOpTree(
       Semanticdb.UnaryOperator operator, Semanticdb.Tree rhs) {
     return Semanticdb.UnaryOperatorTree.newBuilder().setOp(operator).setTree(rhs).build();
@@ -168,13 +167,11 @@ public static Semanticdb.AssignTree assignTree(Semanticdb.Tree lhs, Semanticdb.T
     return Semanticdb.AssignTree.newBuilder().setLhs(lhs).setRhs(rhs).build();
   }
 
-  public static Semanticdb.CastTree castTree(
-      Semanticdb.Type type, Semanticdb.Tree value) {
+  public static Semanticdb.CastTree castTree(Semanticdb.Type type, Semanticdb.Tree value) {
     return Semanticdb.CastTree.newBuilder().setTpe(type).setValue(value).build();
   }
   // SemanticDB Constants
 
-
   public static Semanticdb.AnnotationTree annotationTree(
       Semanticdb.Type type, Iterable<Semanticdb.Tree> parameters) {
     return Semanticdb.AnnotationTree.newBuilder().setTpe(type).addAllParameters(parameters).build();

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

@@ -89,15 +89,14 @@ public Semanticdb.AnnotationTree annotationBuilder(AnnotationTree annotation) {
     TreePath annotationTreePath = nodes.get(annotation);
     Element annotationSym = trees.getElement(annotationTreePath);
 
-    Semanticdb.Type type =
-        typeVisitor.semanticdbType(annotationSym.asType());
+    Semanticdb.Type type = typeVisitor.semanticdbType(annotationSym.asType());
     return annotationTree(type, params);
   }
 
   private TypeMirror getTreeType(Tree tree) {
     TreePath path = nodes.get(tree);
     return trees.getTypeMirror(path);
-  } 
+  }
 
   private Semanticdb.Tree annotationParameter(ExpressionTree expr) {
     if (expr instanceof MemberSelectTree) {
@@ -160,14 +159,17 @@ private Semanticdb.Tree annotationParameter(ExpressionTree expr) {
       return annotationParameter(parenExpr.getExpression());
     } else if (expr instanceof TypeCastTree) {
       TypeCastTree tree = (TypeCastTree) expr;
-      return tree(castTree(typeVisitor.semanticdbType(getTreeType(tree.getType())), annotationParameter(tree.getExpression())));
+      return tree(
+          castTree(
+              typeVisitor.semanticdbType(getTreeType(tree.getType())),
+              annotationParameter(tree.getExpression())));
     } else {
-    throw new IllegalArgumentException(
-        semanticdbUri
-            + ": annotation parameter rhs was of unexpected tree node type "
-            + expr.getClass()
-            + "\n"
-            + expr);
+      throw new IllegalArgumentException(
+          semanticdbUri
+              + ": annotation parameter rhs was of unexpected tree node type "
+              + expr.getClass()
+              + "\n"
+              + expr);
     }
   }
 

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

@@ -224,7 +224,7 @@ void resolveNodes() {
           resolveMemberSelectTree((MemberSelectTree) node, entry.getValue());
         } else if (node instanceof NewClassTree) {
           resolveNewClassTree((NewClassTree) node, entry.getValue());
-        } 
+        }
       }
     }
   }
@@ -338,7 +338,6 @@ private void resolveMemberSelectTree(MemberSelectTree node, TreePath treePath) {
     }
   }
 
-
   private void resolveNewClassTree(NewClassTree node, TreePath treePath) {
     // ignore anonymous classes - otherwise there will be a local reference to itself
     if (node.getIdentifier() != null && node.getClassBody() == null) {