Keep the space between a unary minus and a negative literal

javac folds a minus in front of a decimal literal into the literal
itself, so "- -1" parses as one unary minus applied to the literal
"-1". The check that keeps a space between two prefix operators only
looked for a nested unary expression, so the output was "--1": the
decrement operator on a literal, which does not compile. "- -x" was
fine, the literal case was not.

This ports google/google-java-format#576 by Liam Miller-Cushon: a
literal whose source starts with "-" counts as a unary minus in that
check. The golden B183431894 comes from upstream, with the expected
output in this project's style.

The 15,747 files of the JDK 21 sources format exactly as before.

Author: cushon

open-java-format/src/main/java/com/palantir/javaformat/java/JavaInputAstVisitor.java

@@ -1663,18 +1663,22 @@ public Void visitMemberSelect(MemberSelectTree node, Void unused) {
     public Void visitLiteral(LiteralTree node, Void unused) {
         sync(node);
         String sourceForNode = getSourceForNode(node, getCurrentPath());
-        // A negative numeric literal -n is usually represented as unary minus on n,
-        // but that doesn't work for integer or long MIN_VALUE. The parser works
-        // around that by representing it directly as a signed literal (with no
-        // unary minus), but the lexer still expects two tokens.
-        if (sourceForNode.startsWith("-")) {
+        if (isUnaryMinusLiteral(sourceForNode)) {
             token("-");
             sourceForNode = sourceForNode.substring(1).trim();
         }
         token(sourceForNode);
         return null;
     }
 
+    // A negative numeric literal -n is usually represented as unary minus on n,
+    // but that doesn't work for integer or long MIN_VALUE. The parser works
+    // around that by representing it directly as a signed literal (with no
+    // unary minus), but the lexer still expects two tokens.
+    private static boolean isUnaryMinusLiteral(String literalTreeSource) {
+        return literalTreeSource.startsWith("-");
+    }
+
     private void visitPackage(ExpressionTree packageName, List<? extends AnnotationTree> packageAnnotations) {
         if (!packageAnnotations.isEmpty()) {
             for (AnnotationTree annotation : packageAnnotations) {
@@ -1759,10 +1763,10 @@ private boolean ambiguousUnaryOperator(UnaryTree node, String operatorName) {
             default:
                 return false;
         }
-        if (!(node.getExpression() instanceof UnaryTree)) {
+        JCTree.Tag tag = unaryTag(node.getExpression());
+        if (tag == null) {
             return false;
         }
-        JCTree.Tag tag = ((JCTree) node.getExpression()).getTag();
         if (tag.isPostUnaryOp()) {
             return false;
         }
@@ -1772,6 +1776,17 @@ private boolean ambiguousUnaryOperator(UnaryTree node, String operatorName) {
         return true;
     }
 
+    private JCTree.Tag unaryTag(ExpressionTree expression) {
+        if (expression instanceof UnaryTree) {
+            return ((JCTree) expression).getTag();
+        }
+        if (expression instanceof LiteralTree
+                && isUnaryMinusLiteral(getSourceForNode(expression, getCurrentPath()))) {
+            return JCTree.Tag.MINUS;
+        }
+        return null;
+    }
+
     @Override
     public Void visitPrimitiveType(PrimitiveTypeTree node, Void unused) {
         sync(node);

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/B183431894.input

@@ -0,0 +1,4 @@
+class B183431894 {
+  int a = - -1;
+  int d = + +1;
+}

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/B183431894.output

@@ -0,0 +1,4 @@
+class B183431894 {
+    int a = - -1;
+    int d = + +1;
+}