Excavator: Format Java files

.baseline/checkstyle/checkstyle.xml

@@ -199,10 +199,6 @@
             <property name="separated" value="true"/>
             <property name="sortStaticImportsAlphabetically" value="true"/>
         </module>
-        <module name="Indentation"> <!-- Java Style Guide: Block indentation: +4 spaces -->
-            <property name="arrayInitIndent" value="8"/>
-            <property name="lineWrappingIndentation" value="8"/>
-        </module>
         <module name="InnerAssignment"/> <!-- Java Coding Guidelines: Inner assignments: Not used -->
         <module name="LeftCurly"/> <!-- Java Style Guide: Nonempty blocks: K & R style -->
         <module name="LineLength"> <!-- Java Style Guide: No line-wrapping -->

.gitignore

@@ -13,6 +13,5 @@
 .settings
 build
 out/
-gradle.properties
 docs/node_modules/
 generated_src

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CatchBlockLogException.java

@@ -57,14 +57,14 @@ public final class CatchBlockLogException extends BugChecker implements BugCheck
             .onDescendantOf("org.slf4j.Logger")
             .withNameMatching(Pattern.compile("trace|debug|info|warn|error"));
 
-    private static final Matcher<Tree> containslogMethod = Matchers.contains(
-            Matchers.toType(ExpressionTree.class, logMethod));
+    private static final Matcher<Tree> containslogMethod =
+            Matchers.contains(Matchers.toType(ExpressionTree.class, logMethod));
 
     private static final Matcher<ExpressionTree> logException = Matchers.methodInvocation(
             logMethod, ChildMultiMatcher.MatchType.LAST, Matchers.isSubtypeOf(Throwable.class));
 
-    private static final Matcher<Tree> containslogException = Matchers.contains(Matchers.toType(
-            ExpressionTree.class, logException));
+    private static final Matcher<Tree> containslogException =
+            Matchers.contains(Matchers.toType(ExpressionTree.class, logException));
 
     @Override
     public Description matchCatch(CatchTree tree, VisitorState state) {
@@ -91,17 +91,16 @@ private static Optional<SuggestedFix> attemptFix(CatchTree tree, VisitorState st
         // There are no valid log invocations without at least a single argument.
         ExpressionTree lastArgument = loggingArguments.get(loggingArguments.size() - 1);
         return Optional.of(SuggestedFix.builder()
-                .replace(lastArgument, lastArgument.accept(ThrowableFromArgVisitor.INSTANCE, state)
-                        .orElseGet(() -> state.getSourceForNode(lastArgument) + ", " + tree.getParameter().getName()))
+                .replace(lastArgument, lastArgument.accept(ThrowableFromArgVisitor.INSTANCE, state).orElseGet(() ->
+                        state.getSourceForNode(lastArgument) + ", " + tree.getParameter().getName()))
                 .build());
     }
 
     private static final class ThrowableFromArgVisitor extends SimpleTreeVisitor<Optional<String>, VisitorState> {
         private static final ThrowableFromArgVisitor INSTANCE = new ThrowableFromArgVisitor();
 
-        private static final Matcher<ExpressionTree> throwableMessageInvocation = Matchers.instanceMethod()
-                .onDescendantOf(Throwable.class.getName())
-                .named("getMessage");
+        private static final Matcher<ExpressionTree> throwableMessageInvocation =
+                Matchers.instanceMethod().onDescendantOf(Throwable.class.getName()).named("getMessage");
 
         ThrowableFromArgVisitor() {
             super(Optional.empty());
@@ -152,19 +151,15 @@ public List<MethodInvocationTree> visitCatch(CatchTree node, VisitorState state)
 
         @Override
         public List<MethodInvocationTree> reduce(
-                @Nullable List<MethodInvocationTree> left,
-                @Nullable List<MethodInvocationTree> right) {
+                @Nullable List<MethodInvocationTree> left, @Nullable List<MethodInvocationTree> right) {
             // Unfortunately there's no way to provide default initial values, so we must handle nulls.
             if (left == null) {
                 return right;
             }
             if (right == null) {
                 return left;
             }
-            return ImmutableList.<MethodInvocationTree>builder()
-                    .addAll(left)
-                    .addAll(right)
-                    .build();
+            return ImmutableList.<MethodInvocationTree>builder().addAll(left).addAll(right).build();
         }
     }
 }

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousCompletableFutureUsage.java

@@ -43,8 +43,8 @@
         linkType = BugPattern.LinkType.CUSTOM,
         severity = BugPattern.SeverityLevel.ERROR,
         summary = "Disallow CompletableFuture asynchronous operations without an Executor.")
-public final class DangerousCompletableFutureUsage
-        extends BugChecker implements BugChecker.MethodInvocationTreeMatcher {
+public final class DangerousCompletableFutureUsage extends BugChecker
+        implements BugChecker.MethodInvocationTreeMatcher {
     private static final long serialVersionUID = 1L;
 
     private static final String ERROR_MESSAGE = "Should not use CompletableFuture methods without specifying a "

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousJsonTypeInfoUsage.java

@@ -35,21 +35,19 @@
         link = "https://github.com/palantir/gradle-baseline#baseline-error-prone-checks",
         linkType = BugPattern.LinkType.CUSTOM,
         severity = SeverityLevel.ERROR,
-        summary = "Disallow usage of Jackson's JsonTypeInfo.Id.CLASS annotation for security reasons, "
-                + "cf. https://github.com/FasterXML/jackson-databind/issues/1599")
+        summary =
+                "Disallow usage of Jackson's JsonTypeInfo.Id.CLASS annotation for security reasons, "
+                        + "cf. https://github.com/FasterXML/jackson-databind/issues/1599")
 public final class DangerousJsonTypeInfoUsage extends BugChecker implements BugChecker.AnnotationTreeMatcher {
 
     private static final long serialVersionUID = 1L;
 
-    private static final Matcher<AnnotationTree> matcher = new AnnotationHasArgumentWithValue("use",
-            Matchers.allOf(
-                    new IsSameType<>("com.fasterxml.jackson.annotation.JsonTypeInfo$Id"),
-                    Matchers.anyOf(
-                            treeEqualsStringMatcher("JsonTypeInfo.Id.CLASS"),
-                            treeEqualsStringMatcher("JsonTypeInfo.Id.MINIMAL_CLASS"),
-                            treeEqualsStringMatcher("com.fasterxml.jackson.annotation.JsonTypeInfo.Id.CLASS"),
-                            treeEqualsStringMatcher("com.fasterxml.jackson.annotation.JsonTypeInfo.Id.MINIMAL_CLASS")
-                    )));
+    private static final Matcher<AnnotationTree> matcher = new AnnotationHasArgumentWithValue(
+            "use", Matchers.allOf(new IsSameType<>("com.fasterxml.jackson.annotation.JsonTypeInfo$Id"), Matchers.anyOf(
+                    treeEqualsStringMatcher("JsonTypeInfo.Id.CLASS"),
+                    treeEqualsStringMatcher("JsonTypeInfo.Id.MINIMAL_CLASS"),
+                    treeEqualsStringMatcher("com.fasterxml.jackson.annotation.JsonTypeInfo.Id.CLASS"),
+                    treeEqualsStringMatcher("com.fasterxml.jackson.annotation.JsonTypeInfo.Id.MINIMAL_CLASS"))));
 
     private static Matcher<ExpressionTree> treeEqualsStringMatcher(String value) {
         return (expressionTree, state) -> state.getSourceForNode(expressionTree).equals(value);

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousParallelStreamUsage.java

@@ -40,7 +40,9 @@ public final class DangerousParallelStreamUsage extends BugChecker implements Bu
             + "blob/1.9.1/src/main/java/com/palantir/common/streams/MoreStreams.java#L53";
     private static final String ERROR_MESSAGE = "Should not use .parallel() on a Java stream. "
             + "Doing so has very subtle and potentially severe performance implications, so in general you're better "
-            + "off using " + MORE_STREAMS_URL + " which allows you to provide your own executor service and "
+            + "off using "
+            + MORE_STREAMS_URL
+            + " which allows you to provide your own executor service and "
             + "specify the desired parallelism (i.e. the max number of concurrent tasks that will be submitted).\n"
             + "On the contrary the implementation of Java parallel streams uses a globally shared ForkJoinPool and "
             + "does not allow you to provide your own pool. Fork/join pools implement work-stealing, where any thread "
@@ -56,9 +58,7 @@ public final class DangerousParallelStreamUsage extends BugChecker implements Bu
             + "You can find more info here: https://stackoverflow.com/a/54581148/7182570";
 
     private static final Matcher<ExpressionTree> PARALLEL_CALL_ON_JAVA_STREAM_MATCHER =
-            MethodMatchers.instanceMethod()
-                    .onDescendantOf("java.util.stream.Stream")
-                    .named("parallel");
+            MethodMatchers.instanceMethod().onDescendantOf("java.util.stream.Stream").named("parallel");
 
     @Override
     public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousStringInternUsage.java

@@ -54,17 +54,12 @@ public final class DangerousStringInternUsage extends BugChecker implements BugC
     private static final long serialVersionUID = 1L;
 
     private static final Matcher<ExpressionTree> STRING_INTERN_METHOD_MATCHER =
-            MethodMatchers.instanceMethod()
-                    .onExactClass(String.class.getName())
-                    .named("intern")
-                    .withParameters();
+            MethodMatchers.instanceMethod().onExactClass(String.class.getName()).named("intern").withParameters();
 
     @Override
     public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
         if (STRING_INTERN_METHOD_MATCHER.matches(tree, state)) {
-            return buildDescription(tree)
-                    .setMessage(MESSAGE)
-                    .build();
+            return buildDescription(tree).setMessage(MESSAGE).build();
         }
         return Description.NO_MATCH;
     }

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousThrowableMessageSafeArg.java

@@ -41,13 +41,11 @@ public final class DangerousThrowableMessageSafeArg extends BugChecker
 
     private static final long serialVersionUID = 1L;
 
-    private static final Matcher<ExpressionTree> SAFEARG_FACTORY_METHOD = MethodMatchers.staticMethod()
-            .onClass("com.palantir.logsafe.SafeArg")
-            .named("of");
+    private static final Matcher<ExpressionTree> SAFEARG_FACTORY_METHOD =
+            MethodMatchers.staticMethod().onClass("com.palantir.logsafe.SafeArg").named("of");
 
-    private static final Matcher<ExpressionTree> THROWABLE_MESSAGE_METHOD = MethodMatchers.instanceMethod()
-            .onDescendantOf(Throwable.class.getName())
-            .named("getMessage");
+    private static final Matcher<ExpressionTree> THROWABLE_MESSAGE_METHOD =
+            MethodMatchers.instanceMethod().onDescendantOf(Throwable.class.getName()).named("getMessage");
 
     @Override
     public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java

@@ -36,10 +36,11 @@
         linkType = BugPattern.LinkType.CUSTOM,
         providesFix = BugPattern.ProvidesFix.REQUIRES_HUMAN_ATTENTION,
         severity = BugPattern.SeverityLevel.ERROR,
-        summary = "Uncaught exceptions from ExecutorService.submit are not logged by the uncaught exception handler "
-                + "because it is assumed that the returned future is used to watch for failures.\n"
-                + "When the returned future is ignored, using ExecutorService.execute is preferred because "
-                + "failures are recorded.")
+        summary =
+                "Uncaught exceptions from ExecutorService.submit are not logged by the uncaught exception handler "
+                        + "because it is assumed that the returned future is used to watch for failures.\n"
+                        + "When the returned future is ignored, using ExecutorService.execute is preferred because "
+                        + "failures are recorded.")
 public final class ExecutorSubmitRunnableFutureIgnored extends AbstractReturnValueIgnored {
 
     private static final Matcher<ExpressionTree> MATCHER = MethodMatchers.instanceMethod()

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/GuavaPreconditionsMessageFormat.java

@@ -53,7 +53,8 @@ protected Description matchMessageFormat(MethodInvocationTree tree, String messa
             return Description.NO_MATCH;
         }
 
-        return buildDescription(tree).setMessage(
-                "Use printf-style formatting in Guava Preconditions, not '{}' style formatting.").build();
+        return buildDescription(tree)
+                .setMessage("Use printf-style formatting in Guava Preconditions, not '{}' style formatting.")
+                .build();
     }
 }

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/JUnit5RuleUsage.java

@@ -53,18 +53,16 @@ public Description matchClass(ClassTree tree, VisitorState state) {
         if (!hasMigrationSupport.matches(tree, state)
                 && hasJunit5TestCases.matches(tree, state)
                 && hasJunit4Rules.matches(tree, state)) {
-            return buildDescription(tree)
-                    .setMessage("Do not use Rule/ClassRule with junit-jupiter")
-                    .build();
+            return buildDescription(tree).setMessage("Do not use Rule/ClassRule with junit-jupiter").build();
         }
 
         return Description.NO_MATCH;
     }
 
     static Matcher<ClassTree> hasVariable(Matcher<VariableTree> matcher) {
-        return (classTree, state) -> classTree.getMembers().stream()
-                .filter(tree -> tree instanceof VariableTree)
-                .anyMatch(tree -> matcher.matches((VariableTree) tree, state));
+        return (classTree, state) ->
+                classTree.getMembers().stream().filter(tree -> tree instanceof VariableTree).anyMatch(tree ->
+                        matcher.matches((VariableTree) tree, state));
     }
 
     static Matcher<VariableTree> hasAnnotationOnVariable(String annotation) {

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/JUnit5SuiteMisuse.java

@@ -110,8 +110,6 @@ private static List<Type> getReferencedClasses(AnnotationTree tree, VisitorState
         }
 
         throw new UnsupportedOperationException(String.format(
-                "Unable to get referenced classes for %s of type %s",
-                state.getSourceForNode(tree),
-                value.getClass()));
+                "Unable to get referenced classes for %s of type %s", state.getSourceForNode(tree), value.getClass()));
     }
 }

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LambdaMethodReference.java

@@ -88,8 +88,7 @@ public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState
 
     private Description checkMethodInvocation(
             MethodInvocationTree methodInvocation, LambdaExpressionTree root, VisitorState state) {
-        if (!methodInvocation.getArguments().isEmpty()
-                || !methodInvocation.getTypeArguments().isEmpty()) {
+        if (!methodInvocation.getArguments().isEmpty() || !methodInvocation.getTypeArguments().isEmpty()) {
             return Description.NO_MATCH;
         }
         Symbol.MethodSymbol methodSymbol = ASTHelpers.getSymbol(methodInvocation);
@@ -104,16 +103,11 @@ private Description checkMethodInvocation(
             // which executes 'doWork' eagerly, even when the supplier is not used.
             return Description.NO_MATCH;
         }
-        return buildDescription(root)
-                .setMessage(MESSAGE)
-                .addFix(buildFix(methodSymbol, root, state))
-                .build();
+        return buildDescription(root).setMessage(MESSAGE).addFix(buildFix(methodSymbol, root, state)).build();
     }
 
     private static Optional<SuggestedFix> buildFix(
-            Symbol.MethodSymbol symbol,
-            LambdaExpressionTree root,
-            VisitorState state) {
+            Symbol.MethodSymbol symbol, LambdaExpressionTree root, VisitorState state) {
         SuggestedFix.Builder builder = SuggestedFix.builder();
         return toMethodReference(SuggestedFixes.qualifyType(state, builder, symbol))
                 .map(qualified -> builder.replace(root, qualified).build());
@@ -122,8 +116,8 @@ private static Optional<SuggestedFix> buildFix(
     private static Optional<String> toMethodReference(String qualifiedMethodName) {
         int index = qualifiedMethodName.lastIndexOf('.');
         if (index > 0) {
-            return Optional.of(qualifiedMethodName.substring(0, index)
-                    + "::" + qualifiedMethodName.substring(index + 1));
+            return Optional.of(
+                    qualifiedMethodName.substring(0, index) + "::" + qualifiedMethodName.substring(index + 1));
         }
         return Optional.empty();
     }

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/NonComparableStreamSort.java

@@ -42,10 +42,7 @@ public final class NonComparableStreamSort extends BugChecker implements BugChec
     private static final long serialVersionUID = 1L;
 
     private static final Matcher<ExpressionTree> SORTED_CALL_ON_JAVA_STREAM_MATCHER =
-            MethodMatchers.instanceMethod()
-                    .onDescendantOf(Stream.class.getName())
-                    .named("sorted")
-                    .withParameters();
+            MethodMatchers.instanceMethod().onDescendantOf(Stream.class.getName()).named("sorted").withParameters();
 
     @Override
     public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseMethodInvocation.java

@@ -43,9 +43,8 @@ public final class OptionalOrElseMethodInvocation extends BugChecker implements
 
     private static final long serialVersionUID = 1L;
 
-    private static final Matcher<ExpressionTree> OR_ELSE_METHOD = MethodMatchers.instanceMethod()
-            .onExactClass("java.util.Optional")
-            .named("orElse");
+    private static final Matcher<ExpressionTree> OR_ELSE_METHOD =
+            MethodMatchers.instanceMethod().onExactClass("java.util.Optional").named("orElse");
 
     private static final Matcher<ExpressionTree> METHOD_INVOCATIONS = Matchers.anyOf(
             MethodInvocationMatcher.INSTANCE,
@@ -73,14 +72,12 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState
     }
 
     private enum MethodInvocationMatcher implements Matcher<ExpressionTree> {
-
         INSTANCE;
 
         @Override
         public boolean matches(ExpressionTree tree, VisitorState state) {
             Kind kind = tree.getKind();
-            return kind == Kind.NEW_CLASS
-                    || kind == Kind.METHOD_INVOCATION;
+            return kind == Kind.NEW_CLASS || kind == Kind.METHOD_INVOCATION;
         }
     }
 }

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseThrowThrows.java

@@ -54,8 +54,7 @@ public final class OptionalOrElseThrowThrows extends BugChecker implements BugCh
                     Optional.class.getName(),
                     OptionalDouble.class.getName(),
                     OptionalInt.class.getName(),
-                    OptionalLong.class.getName()
-            )))
+                    OptionalLong.class.getName())))
             .named("orElseThrow")
             .withParameters(Supplier.class.getName());
 

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreconditionsConstantMessage.java

@@ -41,10 +41,9 @@ public final class PreconditionsConstantMessage extends BugChecker implements Bu
 
     private static final long serialVersionUID = 1L;
 
-    private static final Matcher<ExpressionTree> PRECONDITIONS_METHOD =
-            MethodMatchers.staticMethod()
-                    .onClass("com.google.common.base.Preconditions")
-                    .withNameMatching(Pattern.compile("checkArgument|checkState|checkNotNull"));
+    private static final Matcher<ExpressionTree> PRECONDITIONS_METHOD = MethodMatchers.staticMethod()
+            .onClass("com.google.common.base.Preconditions")
+            .withNameMatching(Pattern.compile("checkArgument|checkState|checkNotNull"));
 
     private final Matcher<ExpressionTree> compileTimeConstExpressionMatcher =
             new CompileTimeConstantExpressionMatcher();
@@ -66,8 +65,9 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState
             return Description.NO_MATCH;
         }
 
-        return buildDescription(tree).setMessage(
-                "Preconditions.checkX() statement uses a non-constant message. "
-                        + "Consider using a template string with '%s'.").build();
+        return buildDescription(tree)
+                .setMessage("Preconditions.checkX() statement uses a non-constant message. "
+                        + "Consider using a template string with '%s'.")
+                .build();
     }
 }