Spotless: properly format test files (#1421)

Author: wmdietl

build.gradle

@@ -331,19 +331,10 @@ allprojects { currentProj ->
                 googleJavaFormat(versions.googleJavaFormat) // the formatter to apply to Java files
             }
             formatAnnotations().addTypeAnnotation("PolyInitialized").addTypeAnnotation("PolyVP").addTypeAnnotation("ReceiverDependentQual")
-        }
-
-        java {
-            if (currentProj != currentProj.rootProject) {
-                // not the root project; format all .java files in the sub-project src folders
-                target 'src/**/*.java'
-            }
-            targetExclude doNotFormat
 
-            // This really just removes the wildcard imports - they are not expanded.
-            // That is fine for src files, which should then be manually fixed.
             // There are currently many tests with wildcard imports, so do not enable this for tests.
-            removeWildcardImports()
+            // TODO: Spotless has no easy way to only enable this for a subset of the target.
+            // forbidWildcardImports()
         }
 
         // Only define a groovyGradle task on the root project, for simplicity in setting the target pattern

checker/jtreg/nullness/ToArrayHeuristic/ToArrayHeuristic-notrust.out

@@ -1,10 +1,10 @@
-ToArrayHeuristic.java:45:25: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
+ToArrayHeuristic.java:46:25: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
 type of expression: @Nullable String @NonNull []
 method return type: @NonNull String @NonNull []
-ToArrayHeuristic.java:45:25: compiler.warn.proc.messager: [toarray.nullable.elements.not.newarray] call of toArray on collection of non-null elements yields an array of possibly-null elements; omit the argument to toArray or make it an explicit array constructor
-ToArrayHeuristic.java:49:25: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
+ToArrayHeuristic.java:46:25: compiler.warn.proc.messager: [toarray.nullable.elements.not.newarray] call of toArray on collection of non-null elements yields an array of possibly-null elements; omit the argument to toArray or make it an explicit array constructor
+ToArrayHeuristic.java:50:25: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
 type of expression: @Nullable String @NonNull []
 method return type: @NonNull String @NonNull []
-ToArrayHeuristic.java:49:25: compiler.warn.proc.messager: [toarray.nullable.elements.not.newarray] call of toArray on collection of non-null elements yields an array of possibly-null elements; omit the argument to toArray or make it an explicit array constructor
+ToArrayHeuristic.java:50:25: compiler.warn.proc.messager: [toarray.nullable.elements.not.newarray] call of toArray on collection of non-null elements yields an array of possibly-null elements; omit the argument to toArray or make it an explicit array constructor
 2 errors
 2 warnings

checker/jtreg/nullness/ToArrayHeuristic/ToArrayHeuristic-trust.out

@@ -1,6 +1,6 @@
-ToArrayHeuristic.java:45:25: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
+ToArrayHeuristic.java:46:25: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
 type of expression: @Nullable String @NonNull []
 method return type: @NonNull String @NonNull []
-ToArrayHeuristic.java:45:25: compiler.warn.proc.messager: [toarray.nullable.elements.not.newarray] call of toArray on collection of non-null elements yields an array of possibly-null elements; omit the argument to toArray or make it an explicit array constructor
+ToArrayHeuristic.java:46:25: compiler.warn.proc.messager: [toarray.nullable.elements.not.newarray] call of toArray on collection of non-null elements yields an array of possibly-null elements; omit the argument to toArray or make it an explicit array constructor
 1 error
 1 warning

checker/jtreg/nullness/ToArrayHeuristic/ToArrayHeuristic.java

@@ -8,14 +8,15 @@
  */
 
 import org.checkerframework.common.value.qual.ArrayLen;
+
 import java.util.Collection;
 
 public class ToArrayHeuristic {
     private final String[] EMPTY_STRING_ARRAY_LITERAL = new String[0];
     private final String[] EMPTY_STRING_ARRAY_BRACES = {};
     private final String[] NON_EMPTY_STRING_ARRAY = new String[1];
     String @ArrayLen(0) [] EMPTY_STRING_ARRAY_TRUSTED = {};
-    String [] EMPTY_STRING_ARRAY_MISSING_MODIFIERS = {};
+    String[] EMPTY_STRING_ARRAY_MISSING_MODIFIERS = {};
 
     String[] literalZero(Collection<String> c) {
         return c.toArray(new String[0]);
@@ -54,6 +55,6 @@ String[] argWithParens(Collection<String> c) {
     }
 
     String[] receiverSizeWithParens(Collection<String> c) {
-	return (c).toArray(new String[((c)).size()]);
+        return (c).toArray(new String[((c)).size()]);
     }
 }

checker/jtreg/nullness/onlyannotatedfor/AnnotatedForWithUse.java

@@ -12,15 +12,19 @@
 public class AnnotatedForWithUse {
     class Unannotated {
         Object o;
-        Object get() { return null; }
+
+        Object get() {
+            return null;
+        }
+
         void set(Object of) {}
     }
 
     @AnnotatedFor("nullness")
     class AnnotatedUse {
         void use(Unannotated u) {
             // 1: OK, 2: OK, 3: Err
-            @NonNull Object obj =  u.o;
+            @NonNull Object obj = u.o;
             // 1. Err, 2: Err, TODO want OK, 3:  OK, TODO want Err
             u.o = null;
             // 1: OK, 2: OK, 3: Err

checker/jtreg/nullness/onlyannotatedfor/AnnotatedForWithUseConservativeDefault.out

@@ -1,14 +1,14 @@
-AnnotatedForWithUse.java:23:37: compiler.err.proc.messager: [assignment.type.incompatible] incompatible types in assignment.
+AnnotatedForWithUse.java:27:36: compiler.err.proc.messager: [assignment.type.incompatible] incompatible types in assignment.
 found   : @Nullable Object
 required: @NonNull Object
-AnnotatedForWithUse.java:27:18: compiler.err.proc.messager: [dereference.of.nullable] dereference of possibly-null reference u.get()
-AnnotatedForWithUse.java:27:29: compiler.err.proc.messager: [method.invocation.invalid] call to toString() not allowed on the given receiver.
+AnnotatedForWithUse.java:31:18: compiler.err.proc.messager: [dereference.of.nullable] dereference of possibly-null reference u.get()
+AnnotatedForWithUse.java:31:29: compiler.err.proc.messager: [method.invocation.invalid] call to toString() not allowed on the given receiver.
 found   : @UnknownInitialization Object
 required: @Initialized Object
-AnnotatedForWithUse.java:29:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
+AnnotatedForWithUse.java:33:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
 found   : @UnknownKeyFor NullType
 required: @KeyForBottom Object
-AnnotatedForWithUse.java:29:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
+AnnotatedForWithUse.java:33:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
 found   : @Nullable NullType
 required: @NonNull Object
 5 errors

checker/jtreg/nullness/onlyannotatedfor/AnnotatedForWithUseNoFlag.out

@@ -1,11 +1,11 @@
 AnnotatedForWithUse.java:14:16: compiler.err.proc.messager: [initialization.field.uninitialized] the default constructor does not initialize field o
-AnnotatedForWithUse.java:15:31: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
+AnnotatedForWithUse.java:17:20: compiler.err.proc.messager: [return.type.incompatible] incompatible types in return.
 type of expression: @Nullable NullType
 method return type: @NonNull Object
-AnnotatedForWithUse.java:25:19: compiler.err.proc.messager: [assignment.type.incompatible] incompatible types in assignment.
+AnnotatedForWithUse.java:29:19: compiler.err.proc.messager: [assignment.type.incompatible] incompatible types in assignment.
 found   : @Nullable NullType
 required: @NonNull Object
-AnnotatedForWithUse.java:29:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
+AnnotatedForWithUse.java:33:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
 found   : @Nullable NullType
 required: @NonNull Object
 4 errors

checker/jtreg/nullness/onlyannotatedfor/AnnotatedForWithUseOnlyAnnotatedFor.out

@@ -1,7 +1,7 @@
-AnnotatedForWithUse.java:25:19: compiler.err.proc.messager: [assignment.type.incompatible] incompatible types in assignment.
+AnnotatedForWithUse.java:29:19: compiler.err.proc.messager: [assignment.type.incompatible] incompatible types in assignment.
 found   : @Nullable NullType
 required: @NonNull Object
-AnnotatedForWithUse.java:29:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
+AnnotatedForWithUse.java:33:19: compiler.err.proc.messager: [argument.type.incompatible] incompatible argument for parameter of of Unannotated.set.
 found   : @Nullable NullType
 required: @NonNull Object
 2 errors

checker/tests/nullness/ToArrayFromField.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 // Related jtreg test: checker/jtreg/nullness/ToArrayHeuristic/ToArrayHeuristic.java
 public class ToArrayFromField {
 

framework/tests/all-systems/Issue6078.java

@@ -2,8 +2,8 @@
 
 /**
  * For signature polymorphic methods, javac sometimes does not include the corresponding vararg
- * parameter in the method type. This seems to happen for no-arg invocations and invocations with
- * a single argument of a primitive type.
+ * parameter in the method type. This seems to happen for no-arg invocations and invocations with a
+ * single argument of a primitive type.
  *
  * <p>We work around this issue in TreeUtils.isVarargsCall() and TreeUtils.isSignaturePolymorphic.
  */