From fcc6f2f52c011654c07ce073549a19b8fedf4237 Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Mon, 5 May 2025 17:03:52 -0400 Subject: [PATCH 1/7] Fix compatibility with errorprone 2.38.0 --- .../baseline/errorprone/DangerousIdentityKey.java | 2 +- .../ExecutorSubmitRunnableFutureIgnored.java | 6 ++++++ .../errorprone/IllegalSafeLoggingArgument.java | 4 ++-- .../errorprone/ReadReturnValueIgnored.java | 6 ++++++ .../errorprone/UnsafeGaugeRegistration.java | 6 ++++++ versions.lock | 15 +++++++-------- versions.props | 2 +- 7 files changed, 29 insertions(+), 12 deletions(-) diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousIdentityKey.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousIdentityKey.java index 65c6190bc..0b899f383 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousIdentityKey.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousIdentityKey.java @@ -64,7 +64,7 @@ private static boolean implementsMethod(Types types, Type type, Name methodName, MethodSymbol equals = (MethodSymbol) state.getSymtab().objectType.tsym.members().findFirst(methodName); - return !Iterables.isEmpty(ASTHelpers.scope(types.membersClosure(type, false)) + return !Iterables.isEmpty(types.membersClosure(type, false) .getSymbolsByName(methodName, m -> m != equals && m.overrides(equals, type.tsym, types, false))); } } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java index 9bc18025a..96892e792 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java @@ -18,9 +18,11 @@ import com.google.auto.service.AutoService; import com.google.errorprone.BugPattern; +import com.google.errorprone.ErrorProneFlags; import com.google.errorprone.VisitorState; import com.google.errorprone.bugpatterns.AbstractReturnValueIgnored; import com.google.errorprone.bugpatterns.BugChecker; +import com.google.errorprone.bugpatterns.threadsafety.ConstantExpressions; import com.google.errorprone.fixes.SuggestedFixes; import com.google.errorprone.matchers.Description; import com.google.errorprone.matchers.Matcher; @@ -45,6 +47,10 @@ public final class ExecutorSubmitRunnableFutureIgnored extends AbstractReturnVal .named("submit") .withParameters(Runnable.class.getName()); + public ExecutorSubmitRunnableFutureIgnored() { + super(ConstantExpressions.fromFlags(ErrorProneFlags.empty())); + } + @Override public Matcher specializedMatcher() { return MATCHER; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java index 03affa189..304917699 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java @@ -26,7 +26,7 @@ import com.google.errorprone.matchers.Matcher; import com.google.errorprone.matchers.method.MethodMatchers; import com.google.errorprone.util.ASTHelpers; -import com.google.errorprone.util.ASTHelpers.TargetType; +import com.google.errorprone.util.TargetType; import com.palantir.baseline.errorprone.safety.Safety; import com.palantir.baseline.errorprone.safety.SafetyAnalysis; import com.palantir.baseline.errorprone.safety.SafetyAnnotations; @@ -493,7 +493,7 @@ public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState } private Safety getLambdaRequiredReturnSafety(LambdaExpressionTree tree, VisitorState state) { - TargetType returnType = ASTHelpers.targetType(state.withPath(new TreePath(state.getPath(), tree))); + TargetType returnType = TargetType.targetType(state.withPath(new TreePath(state.getPath(), tree))); if (returnType == null) { return Safety.UNKNOWN; } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java index 203f0bf6b..22d22885f 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java @@ -21,9 +21,11 @@ import com.google.common.io.ByteStreams; import com.google.common.io.CharStreams; import com.google.errorprone.BugPattern; +import com.google.errorprone.ErrorProneFlags; import com.google.errorprone.VisitorState; import com.google.errorprone.bugpatterns.AbstractReturnValueIgnored; import com.google.errorprone.bugpatterns.BugChecker; +import com.google.errorprone.bugpatterns.threadsafety.ConstantExpressions; import com.google.errorprone.fixes.SuggestedFix; import com.google.errorprone.fixes.SuggestedFixes; import com.google.errorprone.matchers.Description; @@ -48,6 +50,10 @@ + "of bytes have been consumed.") public final class ReadReturnValueIgnored extends AbstractReturnValueIgnored { + public ReadReturnValueIgnored() { + super(ConstantExpressions.fromFlags(ErrorProneFlags.empty())); + } + // MethodMatchers does not support matching arrays private static final Matcher INPUT_STREAM_BUFFER_READ_MATCHER = Matchers.allOf( MethodMatchers.instanceMethod() diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java index fb1727db0..c3765f0f2 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java @@ -18,9 +18,11 @@ import com.google.auto.service.AutoService; import com.google.errorprone.BugPattern; +import com.google.errorprone.ErrorProneFlags; import com.google.errorprone.VisitorState; import com.google.errorprone.bugpatterns.AbstractReturnValueIgnored; import com.google.errorprone.bugpatterns.BugChecker; +import com.google.errorprone.bugpatterns.threadsafety.ConstantExpressions; import com.google.errorprone.fixes.SuggestedFixes; import com.google.errorprone.matchers.Description; import com.google.errorprone.matchers.Matcher; @@ -54,6 +56,10 @@ public final class UnsafeGaugeRegistration extends AbstractReturnValueIgnored { private static final Supplier TAGGED_METRIC_REGISTRY = VisitorState.memoize(state -> state.getSymbolFromString(TAGGED_REGISTRY)); + public UnsafeGaugeRegistration() { + super(ConstantExpressions.fromFlags(ErrorProneFlags.empty())); + } + @Override public Matcher specializedMatcher() { return MATCHER; diff --git a/versions.lock b/versions.lock index 183f7592a..c2da9b306 100644 --- a/versions.lock +++ b/versions.lock @@ -13,14 +13,13 @@ com.google.auto.service:auto-service:1.1.1 (1 constraints: 0505f435) com.google.auto.service:auto-service-annotations:1.1.1 (2 constraints: 8a20341c) com.google.auto.value:auto-value-annotations:1.10.4 (3 constraints: ac2df2f5) com.google.code.findbugs:jsr305:3.0.2 (2 constraints: 9e14e59e) -com.google.errorprone:error_prone_annotation:2.36.0 (3 constraints: cd3899ef) -com.google.errorprone:error_prone_annotations:2.36.0 (13 constraints: 81cdd84b) -com.google.errorprone:error_prone_check_api:2.36.0 (2 constraints: b825d4ff) -com.google.errorprone:error_prone_core:2.36.0 (1 constraints: 38053a3b) -com.google.errorprone:error_prone_type_annotations:2.36.0 (1 constraints: 28115cc9) -com.google.googlejavaformat:google-java-format:1.19.1 (2 constraints: ba251300) +com.google.errorprone:error_prone_annotation:2.38.0 (3 constraints: d338ebf0) +com.google.errorprone:error_prone_annotations:2.38.0 (13 constraints: 87cd3c56) +com.google.errorprone:error_prone_check_api:2.38.0 (2 constraints: bc255f00) +com.google.errorprone:error_prone_core:2.38.0 (1 constraints: 3f054f3b) +com.google.googlejavaformat:google-java-format:1.24.0 (2 constraints: b025d4fe) com.google.guava:failureaccess:1.0.3 (2 constraints: f3154f13) -com.google.guava:guava:33.4.8-jre (20 constraints: 056ce29d) +com.google.guava:guava:33.4.8-jre (20 constraints: 176cced4) com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava (1 constraints: bd17c918) com.google.inject:guice:5.1.0 (1 constraints: e20b61f3) com.google.j2objc:j2objc-annotations:3.0.0 (1 constraints: 150aeab4) @@ -90,7 +89,7 @@ com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.18.3 (1 constraints: ea13 com.fasterxml.jackson.module:jackson-module-afterburner:2.18.3 (1 constraints: 40054a3b) com.github.stefanbirkner:system-rules:1.19.0 (1 constraints: 3d05443b) com.google.auto.value:auto-value:1.10 (1 constraints: e711f8e8) -com.google.errorprone:error_prone_test_helpers:2.36.0 (1 constraints: 38053a3b) +com.google.errorprone:error_prone_test_helpers:2.38.0 (1 constraints: 3f054f3b) com.google.jimfs:jimfs:1.3.0 (1 constraints: 5a141061) com.google.testing.compile:compile-testing:0.21.0 (1 constraints: 89149575) com.google.truth:truth:1.4.0 (2 constraints: 72265a6a) diff --git a/versions.props b/versions.props index aaaf6e66b..e7f9de055 100644 --- a/versions.props +++ b/versions.props @@ -14,7 +14,7 @@ org.slf4j:* = 1.7.36 org.immutables:* = 2.10.1 org.ow2.asm:asm = 9.8 com.google.code.findbugs:jsr305 = 3.0.2 -com.google.errorprone:error_prone_* = 2.31.0 +com.google.errorprone:error_prone_* = 2.38.0 com.googlecode.java-diff-utils:diffutils = 1.3.0 com.puppycrawl.tools:checkstyle = 10.23.1 com.palantir.gradle.utils:* = 0.10.0 From d2a02892e7dec06c07480b35cfe09221fd0aa7c4 Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Mon, 5 May 2025 17:47:28 -0400 Subject: [PATCH 2/7] Disable errorprone temporarily so this can merge --- build.gradle | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/build.gradle b/build.gradle index ee5655534..22ef8facd 100644 --- a/build.gradle +++ b/build.gradle @@ -50,6 +50,10 @@ allprojects { tasks.withType(JavaCompile) { options.compilerArgs += ['-Werror', '-Xlint:deprecation'] options.errorprone { + // Temporarily disable errorprone, because it cannot pass due to the issue that is being fixed + // in #3101. Remove this line after a new version has been released. + getDisableAllChecks().set(true) + disable("Slf4jLogsafeArgs") disable("PreferSafeLoggableExceptions") disable("PreferSafeLogger") From bf7023c75d481fe80e434c0ce2b365d91e10b7c1 Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Tue, 6 May 2025 13:08:40 -0400 Subject: [PATCH 3/7] Only disable affected error prone checks and fix all error prone warnings --- .../errorprone/CardinalityEqualsZero.java | 24 ++++------ .../baseline/errorprone/CatchSpecificity.java | 8 ++-- .../errorprone/DangerousRecordArrayField.java | 8 +--- .../errorprone/ForbidJavaxParameterType.java | 14 +++--- .../IllegalSafeLoggingArgument.java | 9 ++-- ...mmutablesBuilderMissingInitialization.java | 13 +++--- .../baseline/errorprone/ImmutablesStyle.java | 10 ++--- .../errorprone/JUnit5SuiteMisuse.java | 8 ++-- .../errorprone/LambdaMethodReference.java | 24 +++++----- .../errorprone/LoggerEnclosingClass.java | 3 +- .../baseline/errorprone/LogsafeArgName.java | 4 +- .../baseline/errorprone/MoreASTHelpers.java | 7 ++- .../baseline/errorprone/MoreMatchers.java | 16 +++---- .../errorprone/OptionalFlatMapOfNullable.java | 13 +++--- .../errorprone/OptionalOrElseGetValue.java | 3 +- .../errorprone/OptionalOrElseThrowThrows.java | 3 +- .../PreconditionsMessageFormat.java | 6 +-- .../PreferInputStreamTransferTo.java | 33 +++++++------- .../errorprone/ProxyNonConstantType.java | 7 ++- .../errorprone/ReadReturnValueIgnored.java | 3 +- .../errorprone/RedundantMethodReference.java | 3 +- .../SafeLoggingExceptionMessageFormat.java | 6 +-- .../errorprone/SafeLoggingPropagation.java | 30 +++++-------- .../StrictCollectionIncompatibleType.java | 3 +- .../errorprone/StrictUnusedVariable.java | 44 ++++++++----------- .../baseline/errorprone/TestCheckUtils.java | 2 +- .../baseline/errorprone/ThrowError.java | 3 +- .../errorprone/UnsafeGaugeRegistration.java | 6 +-- .../errorprone/ZeroWarmupRateLimiter.java | 3 +- .../errorprone/safety/SafetyAnnotations.java | 29 ++++++------ .../safety/SafetyPropagationTransfer.java | 34 +++++++------- build.gradle | 12 +++-- .../plugins/BaselineExactDependencies.java | 3 +- .../baseline/plugins/BaselineImmutables.java | 4 +- .../plugins/BaselineModuleJvmArgs.java | 9 ++-- .../tasks/CheckClassUniquenessLockTask.java | 8 ++-- 36 files changed, 187 insertions(+), 228 deletions(-) diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CardinalityEqualsZero.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CardinalityEqualsZero.java index 0507c5f5a..437eca688 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CardinalityEqualsZero.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CardinalityEqualsZero.java @@ -83,27 +83,21 @@ public Description matchBinary(BinaryTree tree, VisitorState state) { } private static boolean isExpressionThis(ExpressionTree tree) { - switch (tree.getKind()) { - case IDENTIFIER: - return ((IdentifierTree) tree).getName().contentEquals("this"); - case MEMBER_SELECT: - return ((MemberSelectTree) tree).getIdentifier().contentEquals("this"); - default: - return false; - } + return switch (tree.getKind()) { + case IDENTIFIER -> ((IdentifierTree) tree).getName().contentEquals("this"); + case MEMBER_SELECT -> ((MemberSelectTree) tree).getIdentifier().contentEquals("this"); + default -> false; + }; } private static Optional getEqualsZeroExpression(BinaryTree tree, VisitorState state) { ExpressionType ret; switch (tree.getKind()) { - case EQUAL_TO: - ret = ExpressionType.EQ; - break; - case NOT_EQUAL_TO: - ret = ExpressionType.NEQ; - break; - default: + case EQUAL_TO -> ret = ExpressionType.EQ; + case NOT_EQUAL_TO -> ret = ExpressionType.NEQ; + default -> { return Optional.empty(); + } } ExpressionTree leftOperand = tree.getLeftOperand(); ExpressionTree rightOperand = tree.getRightOperand(); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CatchSpecificity.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CatchSpecificity.java index f1fc1f47d..52e8d6bc4 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CatchSpecificity.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/CatchSpecificity.java @@ -229,8 +229,8 @@ public Void visitInstanceOf(InstanceOfTree node, VisitorState state) { private boolean matchesInstanceOf(InstanceOfTree instanceOfNode, VisitorState state) { ExpressionTree expression = instanceOfNode.getExpression(); - return expression instanceof IdentifierTree - && ((IdentifierTree) expression).getName().contentEquals(exceptionName) + return expression instanceof IdentifierTree identifierTree + && identifierTree.getName().contentEquals(exceptionName) && !isTypeValid(ASTHelpers.getType(instanceOfNode.getType()), state); } @@ -282,8 +282,8 @@ private static final class AssignmentScanner extends TreeScanner { @Override public Void visitAssignment(AssignmentTree node, Void state) { ExpressionTree expression = node.getVariable(); - if (expression instanceof IdentifierTree - && ((IdentifierTree) expression).getName().contentEquals(exceptionName)) { + if (expression instanceof IdentifierTree identifierTree + && identifierTree.getName().contentEquals(exceptionName)) { variableWasAssigned = true; } return super.visitAssignment(node, null); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousRecordArrayField.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousRecordArrayField.java index 4202345c0..85302856c 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousRecordArrayField.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/DangerousRecordArrayField.java @@ -64,9 +64,7 @@ public Description matchClass(ClassTree classTree, VisitorState state) { private static boolean hasArrayField(ClassTree classTree, VisitorState state) { for (Tree member : classTree.getMembers()) { - if (member instanceof VariableTree) { - VariableTree variableTree = (VariableTree) member; - + if (member instanceof VariableTree variableTree) { if (IS_ARRAY_VARIABLE.matches(variableTree, state)) { return true; } @@ -80,9 +78,7 @@ private static boolean hasNonTrivialEqualsAndHashCode(ClassTree classTree, Visit boolean hasEquals = false; boolean hasHashCode = false; for (Tree member : classTree.getMembers()) { - if (member instanceof MethodTree) { - MethodTree methodTree = (MethodTree) member; - + if (member instanceof MethodTree methodTree) { // We want to check if the equals & hashCode methods have actually been overridden (i.e. don't just // call Object.equals) hasEquals = hasEquals || EQUALS_MATCHER.matches(methodTree, state); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ForbidJavaxParameterType.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ForbidJavaxParameterType.java index 8d78a7806..1cba51d3c 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ForbidJavaxParameterType.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ForbidJavaxParameterType.java @@ -41,10 +41,13 @@ link = "https://github.com/palantir/gradle-baseline#baseline-error-prone-checks", linkType = BugPattern.LinkType.CUSTOM, severity = BugPattern.SeverityLevel.ERROR, - summary = "Supplying an object which uses legacy javax types, such as javax.ws.rs to a\n" - + "method which requires newer jakarta types is a runtime error. This check ensures\n" - + "that you only supply proper types to these methods which generally just take an\n" - + "untyped Object. There is no auto-fix for this check, you must fix it manually") + summary = + """ + Supplying an object which uses legacy javax types, such as javax.ws.rs to a + method which requires newer jakarta types is a runtime error. This check ensures + that you only supply proper types to these methods which generally just take an + untyped Object. There is no auto-fix for this check, you must fix it manually + """) public final class ForbidJavaxParameterType extends BugChecker implements BugChecker.MethodInvocationTreeMatcher { private static final String FORBID_JAVAX_TYPE = "com.palantir.errorprone.ForbidJavax"; @@ -102,8 +105,7 @@ private boolean hasJavaxInclusions(Type resultType, VisitorState state) { } private boolean hasJavaxInclusionsOnType(TypeSymbol symbol, VisitorState state) { - if (symbol instanceof ClassSymbol) { - ClassSymbol classType = (ClassSymbol) symbol; + if (symbol instanceof ClassSymbol classType) { if (IMPLEMENTS_FEATURE.apply(classType.type, state)) { return true; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java index 304917699..54c198526 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/IllegalSafeLoggingArgument.java @@ -92,8 +92,7 @@ public final class IllegalSafeLoggingArgument extends BugChecker private static Type resolveParameterType(Type input, ExpressionTree tree, VisitorState state) { // Important not to call getReceiver/getReceiverType on a NewClassTree, which throws. - if (input instanceof TypeVar && tree instanceof MethodInvocationTree) { - TypeVar typeVar = (TypeVar) input; + if (input instanceof TypeVar typeVar && tree instanceof MethodInvocationTree) { Type receiver = ASTHelpers.getReceiverType(tree); if (receiver == null) { @@ -472,13 +471,13 @@ public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState Safety resultSafety = Safety.UNKNOWN; switch (tree.getBodyKind()) { - case EXPRESSION: + case EXPRESSION -> resultSafety = SafetyAnalysis.of(state.withPath(new TreePath(state.getPath(), tree.getBody()))); - break; - case STATEMENT: + case STATEMENT -> { // Shortcut - statement lambdas get their return type checked in the return statement matcher // This also allows us to indicate which return statement is bad (if any) rather than the lambda itself return Description.NO_MATCH; + } } if (requiredReturnSafety.allowsValueWith(resultSafety)) { diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesBuilderMissingInitialization.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesBuilderMissingInitialization.java index ae1f7bf4a..55e2a7b19 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesBuilderMissingInitialization.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesBuilderMissingInitialization.java @@ -165,8 +165,8 @@ private Set checkInitialization( if (uninitializedFields.isEmpty()) { return ImmutableSet.of(); } - if (tree instanceof MethodInvocationTree) { - MethodSymbol methodSymbol = ASTHelpers.getSymbol((MethodInvocationTree) tree); + if (tree instanceof MethodInvocationTree methodInvocationTree) { + MethodSymbol methodSymbol = ASTHelpers.getSymbol(methodInvocationTree); if (!Objects.equals(methodSymbol.enclClass(), builderClass)) { // This method belongs to a class other than the builder, so we are at the end of the chain // If the only thing this method does is construct and return the builder, we continue and require @@ -190,8 +190,7 @@ private Set checkInitialization( builderClass, immutableClass, interfaceClass); - } else if (tree instanceof NewClassTree) { - NewClassTree newClassTree = (NewClassTree) tree; + } else if (tree instanceof NewClassTree newClassTree) { if (newClassTree.getArguments().isEmpty()) { // The constructor returned the builder (otherwise we would have bailed out in a previous iteration), so // we should have seen all the field initializations @@ -253,12 +252,10 @@ private boolean methodJustConstructsBuilder( .flatMap(filterByType(ReturnTree.class)) .map(ReturnTree::getExpression) .map(expressionTree -> { - if (expressionTree instanceof NewClassTree) { + if (expressionTree instanceof NewClassTree newClassTree) { // To have got here, the return type must be compatible with ImmutableType, so we don't need // to check the class being constructed - return ((NewClassTree) expressionTree) - .getArguments() - .isEmpty(); + return newClassTree.getArguments().isEmpty(); } else if (expressionTree instanceof MethodInvocationTree) { return Optional.ofNullable(ASTHelpers.getSymbol(expressionTree)) .flatMap(filterByType(MethodSymbol.class)) diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesStyle.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesStyle.java index 24d7c53d4..4ffff07ca 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesStyle.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ImmutablesStyle.java @@ -59,13 +59,13 @@ public final class ImmutablesStyle extends BugChecker implements BugChecker.Clas public Description matchClass(ClassTree tree, VisitorState state) { if (STYLE_ANNOTATION.matches(tree, state)) { switch (tree.getKind()) { - case CLASS: - case INTERFACE: + case CLASS, INTERFACE -> { return matchStyleAnnotatedType(tree, state); - case ANNOTATION_TYPE: + } + case ANNOTATION_TYPE -> { return matchStyleMetaAnnotation(tree, state); - default: - break; + } + default -> {} } } return Description.NO_MATCH; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/JUnit5SuiteMisuse.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/JUnit5SuiteMisuse.java index 249cdf833..a5b72f790 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/JUnit5SuiteMisuse.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/JUnit5SuiteMisuse.java @@ -96,13 +96,13 @@ private static List getReferencedClasses(AnnotationTree tree, VisitorState return Collections.emptyList(); } - if (value instanceof JCTree.JCFieldAccess) { - return Collections.singletonList(((JCTree.JCFieldAccess) value).selected.type); + if (value instanceof JCTree.JCFieldAccess jcFieldAccess) { + return Collections.singletonList(jcFieldAccess.selected.type); } - if (value instanceof JCTree.JCNewArray) { + if (value instanceof JCTree.JCNewArray jcNewArray) { ImmutableList.Builder list = ImmutableList.builder(); - for (JCTree.JCExpression elem : ((JCTree.JCNewArray) value).elems) { + for (JCTree.JCExpression elem : jcNewArray.elems) { list.add(((JCTree.JCFieldAccess) elem).selected.type); } return list.build(); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LambdaMethodReference.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LambdaMethodReference.java index 83f0b208d..34d7d284d 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LambdaMethodReference.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LambdaMethodReference.java @@ -65,29 +65,29 @@ public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState // that we can fix the most basic problems correctly, not to take risks and produce code // that may not compile. switch (bodyKind) { - case EXPRESSION: - if (!(body instanceof MethodInvocationTree)) { + case EXPRESSION -> { + if (!(body instanceof MethodInvocationTree methodInvocationTree)) { return Description.NO_MATCH; } - return checkMethodInvocation((MethodInvocationTree) body, tree, state); - case STATEMENT: - if (!(body instanceof BlockTree)) { + return checkMethodInvocation(methodInvocationTree, tree, state); + } + case STATEMENT -> { + if (!(body instanceof BlockTree block)) { return Description.NO_MATCH; } - BlockTree block = (BlockTree) body; if (block.getStatements().size() != 1) { return Description.NO_MATCH; } StatementTree statement = block.getStatements().get(0); - if (!(statement instanceof ReturnTree)) { + if (!(statement instanceof ReturnTree returnStatement)) { return Description.NO_MATCH; } - ReturnTree returnStatement = (ReturnTree) statement; ExpressionTree returnExpression = returnStatement.getExpression(); - if (!(returnExpression instanceof MethodInvocationTree)) { + if (!(returnExpression instanceof MethodInvocationTree methodInvocationTree)) { return Description.NO_MATCH; } - return checkMethodInvocation((MethodInvocationTree) returnExpression, tree, state); + return checkMethodInvocation(methodInvocationTree, tree, state); + } } throw new IllegalStateException("Unexpected BodyKind: " + bodyKind); } @@ -291,8 +291,8 @@ private static Optional toMethodReference(String qualifiedMethodName) { private static boolean isLocal(MethodInvocationTree methodInvocationTree) { ExpressionTree receiver = ASTHelpers.getReceiver(methodInvocationTree); return receiver == null - || (receiver instanceof IdentifierTree - && "this".equals(((IdentifierTree) receiver).getName().toString())); + || (receiver instanceof IdentifierTree identifierTree + && "this".equals(identifierTree.getName().toString())); } private static boolean isFinal(Symbol symbol) { diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LoggerEnclosingClass.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LoggerEnclosingClass.java index f881204a7..1422a7fa1 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LoggerEnclosingClass.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LoggerEnclosingClass.java @@ -68,10 +68,9 @@ public Description matchVariable(VariableTree tree, VisitorState state) { MethodInvocationTree getLoggerInvocation = (MethodInvocationTree) tree.getInitializer(); ExpressionTree classArgument = getLoggerInvocation.getArguments().get(0); - if (!(classArgument instanceof MemberSelectTree)) { + if (!(classArgument instanceof MemberSelectTree memberSelectTree)) { return Description.NO_MATCH; } - MemberSelectTree memberSelectTree = (MemberSelectTree) classArgument; if (!memberSelectTree.getIdentifier().contentEquals("class") || memberSelectTree.getExpression().getKind() != Tree.Kind.IDENTIFIER) { return Description.NO_MATCH; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogsafeArgName.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogsafeArgName.java index 95a23ef47..69fb234b6 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogsafeArgName.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogsafeArgName.java @@ -68,8 +68,8 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState List args = tree.getArguments(); ExpressionTree argNameExpression = args.get(0); - if (argNameExpression instanceof JCTree.JCLiteral) { - String argName = (String) ((JCTree.JCLiteral) argNameExpression).getValue(); + if (argNameExpression instanceof JCTree.JCLiteral jCLiteral) { + String argName = (String) jCLiteral.getValue(); if (unsafeParamNames.stream().anyMatch(unsafeArgName -> unsafeArgName.equalsIgnoreCase(argName))) { SuggestedFix.Builder builder = SuggestedFix.builder(); String unsafeArg = SuggestedFixes.qualifyType(state, builder, "com.palantir.logsafe.UnsafeArg"); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreASTHelpers.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreASTHelpers.java index 91751b392..751d40a96 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreASTHelpers.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreASTHelpers.java @@ -121,8 +121,8 @@ static ImmutableList expandUnion(@Nullable Type type) { } public static Type getResultType(Tree tree) { - return tree instanceof ExpressionTree - ? ASTHelpers.getResultType((ExpressionTree) tree) + return tree instanceof ExpressionTree expressionTree + ? ASTHelpers.getResultType(expressionTree) : ASTHelpers.getType(tree); } @@ -130,8 +130,7 @@ public static List unwrapArray(@Nullable ExpressionTre if (expressionTree == null) { return Collections.emptyList(); } - if (expressionTree instanceof NewArrayTree) { - NewArrayTree tree = (NewArrayTree) expressionTree; + if (expressionTree instanceof NewArrayTree tree) { return tree.getInitializers(); } return Collections.singletonList(expressionTree); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreMatchers.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreMatchers.java index 6bfcf166e..d55129037 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreMatchers.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/MoreMatchers.java @@ -63,8 +63,8 @@ static Matcher classEnclosingClass(Matcher m TreePath currentPath = state.getPath().getParentPath(); while (currentPath != null) { Tree leaf = currentPath.getLeaf(); - if (leaf instanceof ClassTree) { - return matcher.matches((ClassTree) leaf, state); + if (leaf instanceof ClassTree leafClassTree) { + return matcher.matches(leafClassTree, state); } currentPath = currentPath.getParentPath(); } @@ -79,14 +79,14 @@ static Matcher classEnclosingClass(Matcher m */ static Matcher hasExplicitModifier(Modifier modifier) { return (Matcher) (tree, state) -> { - if (tree instanceof ClassTree) { - return containsModifier(((ClassTree) tree).getModifiers(), state, modifier); + if (tree instanceof ClassTree classTree) { + return containsModifier(classTree.getModifiers(), state, modifier); } - if (tree instanceof MethodTree) { - return containsModifier(((MethodTree) tree).getModifiers(), state, modifier); + if (tree instanceof MethodTree methodTree) { + return containsModifier(methodTree.getModifiers(), state, modifier); } - if (tree instanceof VariableTree) { - return containsModifier(((VariableTree) tree).getModifiers(), state, modifier); + if (tree instanceof VariableTree variableTree) { + return containsModifier(variableTree.getModifiers(), state, modifier); } return false; }; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalFlatMapOfNullable.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalFlatMapOfNullable.java index 73f17052d..3b0b73a7b 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalFlatMapOfNullable.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalFlatMapOfNullable.java @@ -86,21 +86,20 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState private Optional finalExpression(LambdaExpressionTree lambdaExpressionTree) { Tree body = lambdaExpressionTree.getBody(); switch (lambdaExpressionTree.getBodyKind()) { - case EXPRESSION: + case EXPRESSION -> { return Optional.of((ExpressionTree) body); - case STATEMENT: - if (body instanceof BlockTree) { - BlockTree block = (BlockTree) body; + } + case STATEMENT -> { + if (body instanceof BlockTree block) { List statements = block.getStatements(); if (!statements.isEmpty()) { StatementTree finalStatement = statements.get(statements.size() - 1); - if (finalStatement instanceof ReturnTree) { - ReturnTree returnTree = (ReturnTree) finalStatement; + if (finalStatement instanceof ReturnTree returnTree) { return Optional.ofNullable(returnTree.getExpression()); } } } - break; + } } // Don't break compilation when new language features are introduced. return Optional.empty(); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseGetValue.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseGetValue.java index 5ed29551f..f7b956c50 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseGetValue.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseGetValue.java @@ -85,6 +85,7 @@ private static boolean isTrivialExpression(ExpressionTree tree) { } private static boolean isTrivialSelect(ExpressionTree tree) { - return tree instanceof MemberSelectTree && isTrivialExpression(((MemberSelectTree) tree).getExpression()); + return tree instanceof MemberSelectTree memberSelectTree + && isTrivialExpression(memberSelectTree.getExpression()); } } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseThrowThrows.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseThrowThrows.java index 94817cb8f..89fa955f1 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseThrowThrows.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/OptionalOrElseThrowThrows.java @@ -63,10 +63,9 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState return Description.NO_MATCH; } ExpressionTree argument = Iterables.getOnlyElement(tree.getArguments()); - if (!(argument instanceof LambdaExpressionTree)) { + if (!(argument instanceof LambdaExpressionTree lambdaArgument)) { return Description.NO_MATCH; } - LambdaExpressionTree lambdaArgument = (LambdaExpressionTree) argument; if (!lambdaArgument.getBody().accept(ThrowsPredicateVisitor.INSTANCE, null)) { return Description.NO_MATCH; } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreconditionsMessageFormat.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreconditionsMessageFormat.java index 8964acdc0..aae4809d5 100755 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreconditionsMessageFormat.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreconditionsMessageFormat.java @@ -52,17 +52,15 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState return Description.NO_MATCH; } - if (!(messageArg instanceof LiteralTree)) { + if (!(messageArg instanceof LiteralTree literalTreeMessageArg)) { return Description.NO_MATCH; } - LiteralTree literalTreeMessageArg = (LiteralTree) messageArg; Object value = literalTreeMessageArg.getValue(); - if (!(value instanceof String)) { + if (!(value instanceof String message)) { return Description.NO_MATCH; } - String message = (String) value; return matchMessageFormat(tree, message, state); } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferInputStreamTransferTo.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferInputStreamTransferTo.java index 095eff9d5..0e46506e4 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferInputStreamTransferTo.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferInputStreamTransferTo.java @@ -43,20 +43,21 @@ + "`org.apache.commons.io.IOUtils.copyLong(InputStream, OutputStream)` " + "see: https://github.com/palantir/gradle-baseline/issues/2615 ", explanation = "Allow for optimization when underlying input stream (such as `ByteArrayInputStream`," - + " `ChannelInputStream`) overrides `long transferTo(OutputStream)` to avoid extra array allocations and" - + " copy larger chunks at a time (e.g. allowing 16KiB chunks via" - + " `ApacheHttpClientBlockingChannel.ModulatingOutputStream` from #1790).\n\n" - + "When running on JDK 21+, this also enables 16KiB byte chunk copies via" - + " `InputStream.transferTo(OutputStream)` per [JDK-8299336](https://bugs.openjdk.org/browse/JDK-8299336)," - + " where as on JDK < 21 and when using Guava `ByteStreams.copy` 8KiB byte chunk copies are used. \n\n" - + "References:\n\n" - + " * https://github.com/palantir/hadoop-crypto/pull/586\n" - + " * https://bugs.openjdk.org/browse/JDK-8299336\n" - + " * https://bugs.openjdk.org/browse/JDK-8067661\n" - + " * https://bugs.openjdk.org/browse/JDK-8265891\n" - + " * https://bugs.openjdk.org/browse/JDK-8273038\n" - + " * https://bugs.openjdk.org/browse/JDK-8279283\n" - + " * https://bugs.openjdk.org/browse/JDK-8296431\n") + + " `ChannelInputStream`) overrides `long transferTo(OutputStream)` to avoid extra array allocations" + + " and copy larger chunks at a time (e.g. allowing 16KiB chunks via" + + " `ApacheHttpClientBlockingChannel.ModulatingOutputStream` from #1790).\n\n" + + "When running on JDK 21+, this also enables 16KiB byte chunk copies via" + + " `InputStream.transferTo(OutputStream)` per" + + "[JDK-8299336](https://bugs.openjdk.org/browse/JDK-8299336)," + + " where as on JDK < 21 and when using Guava `ByteStreams.copy` 8KiB byte chunk copies are used. \n\n" + + "References:\n\n" + + " * https://github.com/palantir/hadoop-crypto/pull/586\n" + + " * https://bugs.openjdk.org/browse/JDK-8299336\n" + + " * https://bugs.openjdk.org/browse/JDK-8067661\n" + + " * https://bugs.openjdk.org/browse/JDK-8265891\n" + + " * https://bugs.openjdk.org/browse/JDK-8273038\n" + + " * https://bugs.openjdk.org/browse/JDK-8279283\n" + + " * https://bugs.openjdk.org/browse/JDK-8296431\n") public final class PreferInputStreamTransferTo extends BugChecker implements BugChecker.MethodInvocationTreeMatcher { private static final long serialVersionUID = 1L; @@ -103,8 +104,8 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState } // Avoid possible infinite recursion replacing with `this.transferTo(outputStream)` - if (maybeInputStreamArg instanceof IdentifierTree - && ((IdentifierTree) maybeInputStreamArg).getName().contentEquals("this")) { + if (maybeInputStreamArg instanceof IdentifierTree identifierTree + && identifierTree.getName().contentEquals("this")) { inputStreamArg = "super"; } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ProxyNonConstantType.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ProxyNonConstantType.java index dbf80a11b..523a062b2 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ProxyNonConstantType.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ProxyNonConstantType.java @@ -64,8 +64,7 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState } if (NEW_PROXY_INSTANCE_MATCHER.matches(tree, state)) { ExpressionTree interfaces = tree.getArguments().get(1); - if (interfaces instanceof NewArrayTree) { - NewArrayTree newArrayTree = (NewArrayTree) interfaces; + if (interfaces instanceof NewArrayTree newArrayTree) { for (ExpressionTree element : newArrayTree.getInitializers()) { if (!isDirectClassAccess(element) && !TestCheckUtils.isTestCode(state)) { return describeMatchWithFix(interfaces, state); @@ -84,7 +83,7 @@ private Description describeMatchWithFix(Tree tree, VisitorState state) { } private static boolean isDirectClassAccess(ExpressionTree expressionTree) { - return expressionTree instanceof MemberSelectTree - && ((MemberSelectTree) expressionTree).getIdentifier().contentEquals("class"); + return expressionTree instanceof MemberSelectTree memberSelectTree + && memberSelectTree.getIdentifier().contentEquals("class"); } } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java index 22d22885f..b421b26fb 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java @@ -135,14 +135,13 @@ public Description describeReturnValueIgnored(MethodInvocationTree methodInvocat private static SuggestedFix replaceWithStatic( MethodInvocationTree tree, VisitorState state, String fullyQualifiedReplacement) { Tree methodSelect = tree.getMethodSelect(); - if (!(methodSelect instanceof MemberSelectTree)) { + if (!(methodSelect instanceof MemberSelectTree memberSelectTree)) { return SuggestedFix.emptyFix(); } CharSequence sourceCode = state.getSourceCode(); if (sourceCode == null) { return SuggestedFix.emptyFix(); } - MemberSelectTree memberSelectTree = (MemberSelectTree) methodSelect; SuggestedFix.Builder fix = SuggestedFix.builder(); String qualifiedReference = SuggestedFixes.qualifyType(state, fix, fullyQualifiedReplacement); CharSequence args = sourceCode.subSequence( diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/RedundantMethodReference.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/RedundantMethodReference.java index 96e88eba5..7d40c743e 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/RedundantMethodReference.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/RedundantMethodReference.java @@ -44,10 +44,9 @@ public Description matchMemberReference(MemberReferenceTree tree, VisitorState s if (tree.getMode() != MemberReferenceTree.ReferenceMode.INVOKE) { return Description.NO_MATCH; } - if (!(tree instanceof JCTree.JCMemberReference)) { + if (!(tree instanceof JCTree.JCMemberReference jcMemberReference)) { return Description.NO_MATCH; } - JCTree.JCMemberReference jcMemberReference = (JCTree.JCMemberReference) tree; // Only support expression::method, not static method references or unbound method references (e.g. List::add) if (jcMemberReference.kind != JCTree.JCMemberReference.ReferenceKind.BOUND) { return Description.NO_MATCH; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingExceptionMessageFormat.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingExceptionMessageFormat.java index 7faeabf31..70c796e2e 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingExceptionMessageFormat.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingExceptionMessageFormat.java @@ -64,17 +64,15 @@ public Description matchNewClass(NewClassTree tree, VisitorState state) { return Description.NO_MATCH; } - if (!(messageArg instanceof LiteralTree)) { + if (!(messageArg instanceof LiteralTree literalTreeMessageArg)) { return Description.NO_MATCH; } - LiteralTree literalTreeMessageArg = (LiteralTree) messageArg; Object value = literalTreeMessageArg.getValue(); - if (!(value instanceof String)) { + if (!(value instanceof String message)) { return Description.NO_MATCH; } - String message = (String) value; if (message.contains("{}")) { return buildDescription(tree) diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPropagation.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPropagation.java index bbd5c77b8..2cc98618e 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPropagation.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPropagation.java @@ -196,8 +196,7 @@ private static boolean isGetterMethod(ClassSymbol enclosingClass, MethodSymbol m private static Safety scanSymbolMethods(ClassSymbol begin, VisitorState state, boolean usesJackson) { Safety safety = Safety.UNKNOWN; for (Symbol enclosed : ASTHelpers.getEnclosedElements(begin)) { - if (enclosed instanceof MethodSymbol) { - MethodSymbol methodSymbol = (MethodSymbol) enclosed; + if (enclosed instanceof MethodSymbol methodSymbol) { if (isGetterMethod(begin, methodSymbol, state)) { boolean redacted = ASTHelpers.hasAnnotation(methodSymbol, "org.immutables.value.Value.Redacted", state); @@ -224,14 +223,12 @@ private static Safety scanSymbolMethods(ClassSymbol begin, VisitorState state, b } } Type superClassType = begin.getSuperclass(); - if (superClassType != null && superClassType.tsym instanceof ClassSymbol) { - ClassSymbol superClassSym = (ClassSymbol) superClassType.tsym; + if (superClassType != null && superClassType.tsym instanceof ClassSymbol superClassSym) { Safety superClassMethodSafety = scanSymbolMethods(superClassSym, state, usesJackson); safety = Safety.mergeAssumingUnknownIsSame(safety, superClassMethodSafety); } for (Type superIface : begin.getInterfaces()) { - if (superIface.tsym instanceof ClassSymbol) { - ClassSymbol superIfaceClassSymbol = (ClassSymbol) superIface.tsym; + if (superIface.tsym instanceof ClassSymbol superIfaceClassSymbol) { Safety superClassMethodSafety = scanSymbolMethods(superIfaceClassSymbol, state, usesJackson); safety = Safety.mergeAssumingUnknownIsSame(safety, superClassMethodSafety); } @@ -275,19 +272,14 @@ private Description handleSafety( // Do not suggest promotion, this check is not exhaustive. return Description.NO_MATCH; } - switch (computedSafety) { - case UNKNOWN: - // Nothing to do - return Description.NO_MATCH; - case SAFE: - // Do not suggest promotion to safe, this check is not exhaustive. - return Description.NO_MATCH; - case DO_NOT_LOG: - return annotate(tree, treeModifiers, state, SafetyAnnotations.DO_NOT_LOG); - case UNSAFE: - return annotate(tree, treeModifiers, state, SafetyAnnotations.UNSAFE); - } - return Description.NO_MATCH; + return switch (computedSafety) { + // Nothing to do + case UNKNOWN -> Description.NO_MATCH; + // Do not suggest promotion to safe, this check is not exhaustive. + case SAFE -> Description.NO_MATCH; + case DO_NOT_LOG -> annotate(tree, treeModifiers, state, SafetyAnnotations.DO_NOT_LOG); + case UNSAFE -> annotate(tree, treeModifiers, state, SafetyAnnotations.UNSAFE); + }; } private Description annotate(Tree tree, ModifiersTree treeModifiers, VisitorState state, String annotationName) { diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictCollectionIncompatibleType.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictCollectionIncompatibleType.java index 7493a7e8f..2c8f9eac0 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictCollectionIncompatibleType.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictCollectionIncompatibleType.java @@ -157,8 +157,7 @@ private static Type getTargetTypeAsSuper(MemberReferenceTree tree, String superT @Nullable private static Type getTargetType(MethodInvocationTree tree) { ExpressionTree methodSelect = tree.getMethodSelect(); - if (methodSelect instanceof MemberSelectTree) { - MemberSelectTree memberSelectTree = (MemberSelectTree) methodSelect; + if (methodSelect instanceof MemberSelectTree memberSelectTree) { return ASTHelpers.getResultType(memberSelectTree.getExpression()); } return null; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictUnusedVariable.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictUnusedVariable.java index 787365a68..fa6a6138b 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictUnusedVariable.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/StrictUnusedVariable.java @@ -385,16 +385,12 @@ private static SuggestedFix makeAssignmentDeclaration( } private static String describeVariable(Symbol.VarSymbol symbol) { - switch (symbol.getKind()) { - case FIELD: - return "field"; - case LOCAL_VARIABLE: - return "local variable"; - case PARAMETER: - return "parameter"; - default: - return "variable"; - } + return switch (symbol.getKind()) { + case FIELD -> "field"; + case LOCAL_VARIABLE -> "local variable"; + case PARAMETER -> "parameter"; + default -> "variable"; + }; } private static boolean hasNativeMethods(CompilationUnitTree tree) { @@ -498,8 +494,8 @@ private static ImmutableList buildUnusedVarFixes( } else if (statement.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { JCTree tree = (JCTree) ((ExpressionStatementTree) statement).getExpression(); - if (tree instanceof CompoundAssignmentTree) { - if (hasSideEffect(((CompoundAssignmentTree) tree).getExpression())) { + if (tree instanceof CompoundAssignmentTree compoundAssignmentTree) { + if (hasSideEffect(compoundAssignmentTree.getExpression())) { // If it's a compound assignment, there's no reason we'd want to remove the expression, // so don't set `encounteredSideEffects` based on this usage. SuggestedFix replacement = SuggestedFix.replace( @@ -509,8 +505,8 @@ private static ImmutableList buildUnusedVarFixes( fix.merge(replacement); continue; } - } else if (tree instanceof AssignmentTree) { - if (hasSideEffect(((AssignmentTree) tree).getExpression())) { + } else if (tree instanceof AssignmentTree assignmentTree) { + if (hasSideEffect(assignmentTree.getExpression())) { fix.replace( tree.getStartPosition(), ((JCTree.JCAssign) tree).getExpression().getStartPosition(), @@ -531,11 +527,10 @@ private static ImmutableList buildUnusedLambdaParameterFix( for (UnusedSpec unusedSpec : values) { Tree leaf = unusedSpec.variableTree().getLeaf(); - if (!(leaf instanceof VariableTree)) { + if (!(leaf instanceof VariableTree tree)) { continue; } - VariableTree tree = (VariableTree) leaf; if (state.getEndPosition(tree.getType()) == -1) { fix.replace(tree, "_" + tree.getName()); } else { @@ -659,7 +654,7 @@ private void renameByIndex(List trees) { private static boolean isEnhancedForLoopVar(TreePath variablePath) { Tree tree = variablePath.getLeaf(); Tree parent = variablePath.getParentPath().getLeaf(); - return parent instanceof EnhancedForLoopTree && ((EnhancedForLoopTree) parent).getVariable() == tree; + return parent instanceof EnhancedForLoopTree enhancedForLoopTree && enhancedForLoopTree.getVariable() == tree; } /** @@ -722,18 +717,18 @@ public Void visitVariable(VariableTree variableTree, Void unused) { return null; } switch (symbol.getKind()) { - case FIELD: + case FIELD -> { // We are only interested in private fields and those which are not special. if (isFieldEligibleForChecking(variableTree, symbol)) { unusedElements.put(symbol, getCurrentPath()); usageSites.put(symbol, getCurrentPath()); } - break; - case LOCAL_VARIABLE: + } + case LOCAL_VARIABLE -> { unusedElements.put(symbol, getCurrentPath()); usageSites.put(symbol, getCurrentPath()); - break; - case PARAMETER: + } + case PARAMETER -> { // ignore the receiver parameter if (variableTree.getName().contentEquals("this")) { return null; @@ -742,9 +737,8 @@ public Void visitVariable(VariableTree variableTree, Void unused) { if (!isParameterSubjectToAnalysis(symbol)) { onlyCheckForReassignments.add(symbol); } - break; - default: - break; + } + default -> {} } return null; } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/TestCheckUtils.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/TestCheckUtils.java index 8af0e7923..51669271e 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/TestCheckUtils.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/TestCheckUtils.java @@ -38,7 +38,7 @@ static boolean isTestCode(VisitorState state) { } TreePath path = state.getPath(); for (Tree ancestor : path) { - if (ancestor instanceof ClassTree && hasTestCases.matches((ClassTree) ancestor, state)) { + if (ancestor instanceof ClassTree classTree && hasTestCases.matches(classTree, state)) { return true; } } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ThrowError.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ThrowError.java index 50a2daa1f..c527ecb7a 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ThrowError.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ThrowError.java @@ -56,10 +56,9 @@ public final class ThrowError extends BugChecker implements BugChecker.ThrowTree @Override public Description matchThrow(ThrowTree tree, VisitorState state) { ExpressionTree expression = tree.getExpression(); - if (!(expression instanceof NewClassTree)) { + if (!(expression instanceof NewClassTree newClassTree)) { return Description.NO_MATCH; } - NewClassTree newClassTree = (NewClassTree) expression; if (!ERROR.matches(newClassTree.getIdentifier(), state) // Don't discourage developers from testing edge cases involving Errors. // It's also fine for tests throw AssertionError internally in test objects. diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java index c3765f0f2..96597ffca 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java @@ -82,13 +82,11 @@ public Description matchMethodInvocation(MethodInvocationTree methodInvocationTr /** TaggedMetricRegistry.registerWithReplacement was added in Tritium 0.16.1, avoid flagging older versions. */ private static boolean hasRegisterWithReplacement(VisitorState state) { Symbol symbol = TAGGED_METRIC_REGISTRY.get(state); - if (!(symbol instanceof Symbol.ClassSymbol)) { + if (!(symbol instanceof Symbol.ClassSymbol classSymbol)) { return false; } - Symbol.ClassSymbol classSymbol = (Symbol.ClassSymbol) symbol; for (Symbol enclosed : ASTHelpers.getEnclosedElements(classSymbol)) { - if (enclosed instanceof Symbol.MethodSymbol) { - Symbol.MethodSymbol enclosedMethod = (Symbol.MethodSymbol) enclosed; + if (enclosed instanceof Symbol.MethodSymbol enclosedMethod) { if (enclosedMethod.name.contentEquals(REGISTER_WITH_REPLACEMENT)) { return true; } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ZeroWarmupRateLimiter.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ZeroWarmupRateLimiter.java index 46dfdf8b2..4c1db3c3e 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ZeroWarmupRateLimiter.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ZeroWarmupRateLimiter.java @@ -81,8 +81,7 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState */ private static boolean isDurationZero(ExpressionTree expressionTree, VisitorState state) { Symbol symbol = ASTHelpers.getSymbol(expressionTree); - if (symbol != null && ASTHelpers.isStatic(symbol) && symbol instanceof VarSymbol) { - VarSymbol varSymbol = (VarSymbol) symbol; + if (symbol != null && ASTHelpers.isStatic(symbol) && symbol instanceof VarSymbol varSymbol) { return varSymbol.name.contentEquals("ZERO") && state.getTypes() .isSameType(varSymbol.owner.type, state.getTypeFromString(Duration.class.getName())); diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/safety/SafetyAnnotations.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/safety/SafetyAnnotations.java index b90aa3c15..fb205ecc1 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/safety/SafetyAnnotations.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/safety/SafetyAnnotations.java @@ -101,8 +101,8 @@ public static Safety getSafety(Tree tree, VisitorState state) { // Check the symbol itself: Symbol treeSymbol = ASTHelpers.getSymbol(tree); Safety symbolSafety = getSafety(treeSymbol, state); - Type treeType = tree instanceof ExpressionTree - ? ASTHelpers.getResultType((ExpressionTree) tree) + Type treeType = tree instanceof ExpressionTree expressionTree + ? ASTHelpers.getResultType(expressionTree) : ASTHelpers.getType(tree); Safety treeTypeSafety = treeType == null ? Safety.UNKNOWN @@ -124,18 +124,16 @@ public static Safety getSafety(@Nullable Symbol symbol, VisitorState state) { return direct; } // Check super-methods - if (symbol instanceof MethodSymbol) { - return getSuperMethodSafety((MethodSymbol) symbol, state); + if (symbol instanceof MethodSymbol methodSymbol) { + return getSuperMethodSafety(methodSymbol, state); } - if (symbol instanceof TypeVariableSymbol) { - return getTypeVariableSymbolSafety((TypeVariableSymbol) symbol); + if (symbol instanceof TypeVariableSymbol typeVariableSymbol) { + return getTypeVariableSymbolSafety(typeVariableSymbol); } - if (symbol instanceof VarSymbol) { - VarSymbol varSymbol = (VarSymbol) symbol; + if (symbol instanceof VarSymbol varSymbol) { return getSuperMethodParameterSafety(varSymbol, state); } - if (symbol instanceof ClassSymbol) { - ClassSymbol classSymbol = (ClassSymbol) symbol; + if (symbol instanceof ClassSymbol classSymbol) { Safety safety = getSafety(classSymbol.getSuperclass().tsym, state); for (Type type : classSymbol.getInterfaces()) { safety = Safety.mergeAssumingUnknownIsSame(safety, getSafety(type.tsym, state)); @@ -181,8 +179,8 @@ public static Safety getTypeSafetyFromKnownSubtypes(ClassTree classTree, Visitor } else if (JSON_SUBTYPES_MATCHER.matches(annotationTree, state)) { ExpressionTree tree = AnnotationMatcherUtils.getArgument(annotationTree, "value"); for (ExpressionTree subtype : MoreASTHelpers.unwrapArray(tree)) { - if (subtype instanceof AnnotationTree) { - ExpressionTree value = AnnotationMatcherUtils.getArgument((AnnotationTree) subtype, "value"); + if (subtype instanceof AnnotationTree annotationTreeSubtype) { + ExpressionTree value = AnnotationMatcherUtils.getArgument(annotationTreeSubtype, "value"); if (value != null) { Safety subtypeSafety = SafetyAnnotations.getSafety(ASTHelpers.getReceiver(value), state); safety = Safety.mergeAssumingUnknownIsSame(safety, subtypeSafety); @@ -252,9 +250,9 @@ private static Safety getSafetyInternal(Type type, VisitorState state, SetNullnessPropagationTransfer */ +@SuppressWarnings("PatternMatchingInstanceof") public final class SafetyPropagationTransfer implements ForwardTransferFunction> { private static final Matcher THROWABLE_SUBTYPE = Matchers.isSubtypeOf(Throwable.class); @@ -549,12 +550,12 @@ interface Updates { void set(AccessPath path, Safety value); default void trySet(Node node, Safety value) { - if (node instanceof LocalVariableNode) { - set((LocalVariableNode) node, value); - } else if (node instanceof FieldAccessNode) { - set((FieldAccessNode) node, value); - } else if (node instanceof VariableDeclarationNode) { - set((VariableDeclarationNode) node, value); + if (node instanceof LocalVariableNode localVariableNode) { + set(localVariableNode, value); + } else if (node instanceof FieldAccessNode fieldAccessNode) { + set(fieldAccessNode, value); + } else if (node instanceof VariableDeclarationNode variableDeclarationNode) { + set(variableDeclarationNode, value); } } @@ -877,13 +878,12 @@ public TransferResult> visitAssignment( Node target = node.getTarget(); if (target instanceof LocalVariableNode) { updates.trySet(target, safety); - } else if (target instanceof ArrayAccessNode) { - Node arrayNode = ((ArrayAccessNode) target).getArray(); + } else if (target instanceof ArrayAccessNode arrayAccessNode) { + Node arrayNode = arrayAccessNode.getArray(); Safety arrayNodeSafety = getValueOfSubNode(input, arrayNode); safety = arrayNodeSafety == null ? safety : arrayNodeSafety.leastUpperBound(safety); updates.trySet(arrayNode, safety); - } else if (target instanceof FieldAccessNode) { - FieldAccessNode fieldAccess = (FieldAccessNode) target; + } else if (target instanceof FieldAccessNode fieldAccess) { updates.set(fieldAccess, safety); } else { throw new UnsupportedOperationException( @@ -933,10 +933,9 @@ private static boolean isElementKind(LocalVariableNode node, ElementKind element private Safety getCapturedLocalVariableSafety(LocalVariableNode node) { Symbol symbol = ASTHelpers.getSymbol(node.getTree()); - if (!(symbol instanceof VarSymbol)) { + if (!(symbol instanceof VarSymbol variableSymbol)) { return Safety.UNKNOWN; } - VarSymbol variableSymbol = (VarSymbol) symbol; JavacProcessingEnvironment javacEnv = JavacProcessingEnvironment.instance(state.context); TreePath variableDefinition = Trees.instance(javacEnv).getPath(variableSymbol); if (variableDefinition == null) { @@ -967,12 +966,12 @@ private Safety getCapturedLocalVariableSafety(LocalVariableNode node) { private static UnderlyingAST createAst(TreePath path) { Tree tree = path.getLeaf(); ClassTree enclosingClass = TreePathUtil.enclosingClass(path); - if (tree instanceof MethodTree) { - return new UnderlyingAST.CFGMethod((MethodTree) tree, enclosingClass); + if (tree instanceof MethodTree methodTree) { + return new UnderlyingAST.CFGMethod(methodTree, enclosingClass); } - if (tree instanceof LambdaExpressionTree) { + if (tree instanceof LambdaExpressionTree lambdaExpressionTree) { return new UnderlyingAST.CFGLambda( - (LambdaExpressionTree) tree, enclosingClass, TreePathUtil.enclosingMethod(path)); + lambdaExpressionTree, enclosingClass, TreePathUtil.enclosingMethod(path)); } return new CFGStatement(tree, enclosingClass); } @@ -1382,8 +1381,7 @@ public TransferResult> visitExpressionStatement( public TransferResult> visitDeconstructorPattern( DeconstructorPatternNode node, TransferInput> input) { TypeMirror type = node.getType(); - if (type instanceof ClassType) { - ClassType classType = (ClassType) type; + if (type instanceof ClassType classType) { ClassSymbol symbol = (ClassSymbol) classType.tsym; if (symbol != null && symbol.isRecord()) { List recordComponents = symbol.getRecordComponents(); diff --git a/build.gradle b/build.gradle index 22ef8facd..9ae2993b4 100644 --- a/build.gradle +++ b/build.gradle @@ -50,9 +50,15 @@ allprojects { tasks.withType(JavaCompile) { options.compilerArgs += ['-Werror', '-Xlint:deprecation'] options.errorprone { - // Temporarily disable errorprone, because it cannot pass due to the issue that is being fixed - // in #3101. Remove this line after a new version has been released. - getDisableAllChecks().set(true) + // Temporarily disable some checks which cannot pass due to the issue that is being fixed + // in #3101. Remove these line after a new version has been released. + disable("DangerousIdentityKey") + disable("ExecutorSubmitRunnableFutureIgnored") + disable("IllegalSafeLoggingArgument") + disable("ReadReturnValueIgnored") + disable("UnsafeGaugeRegistration") + disable("VarUsage") + // End temporary disabled checks disable("Slf4jLogsafeArgs") disable("PreferSafeLoggableExceptions") diff --git a/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineExactDependencies.java b/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineExactDependencies.java index 5075718fb..2a45b65bd 100644 --- a/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineExactDependencies.java +++ b/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineExactDependencies.java @@ -282,8 +282,7 @@ public static String asDependencyStringWithoutName(ResolvedArtifact artifact) { private static String asDependencyString(ResolvedArtifact artifact, boolean withName) { ComponentIdentifier componentId = artifact.getId().getComponentIdentifier(); - if (componentId instanceof ProjectComponentIdentifier) { - ProjectComponentIdentifier projectComponentId = (ProjectComponentIdentifier) componentId; + if (componentId instanceof ProjectComponentIdentifier projectComponentId) { StringBuilder builder = new StringBuilder() .append("project('") .append(projectComponentId.getProjectPath()) diff --git a/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineImmutables.java b/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineImmutables.java index f602a322c..399d91b7a 100644 --- a/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineImmutables.java +++ b/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineImmutables.java @@ -92,12 +92,10 @@ private static boolean hasImmutablesProcessor(Project project, SourceSet sourceS private static boolean isImmutablesValue(ResolvedArtifact resolvedArtifact) { ComponentIdentifier id = resolvedArtifact.getId().getComponentIdentifier(); - if (!(id instanceof ModuleComponentIdentifier)) { + if (!(id instanceof ModuleComponentIdentifier moduleId)) { return false; } - ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) id; - // The actual annotation processor jar has no classifier, we must make sure not to match on the // `annotations` jar which has the `annotations` classifier boolean noClassifier = resolvedArtifact.getClassifier() == null; diff --git a/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java b/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java index c983cb9bb..0d7c8f2db 100644 --- a/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java +++ b/gradle-baseline-java/src/main/java/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java @@ -140,8 +140,7 @@ public void execute(Task task) { Javadoc javadoc = (Javadoc) task; MinimalJavadocOptions options = javadoc.getOptions(); - if (options instanceof CoreJavadocOptions) { - CoreJavadocOptions coreOptions = (CoreJavadocOptions) options; + if (options instanceof CoreJavadocOptions coreOptions) { ImmutableList info = collectClasspathInfo(project, sourceSet); List exportValues = Stream.concat( @@ -318,16 +317,18 @@ private static ImmutableList collectClasspathArgs( Stream allOpens = Stream.concat( extension.opens().get().stream(), classpathInfo.stream().flatMap(info -> info.opens().stream())); switch (mode) { - case COMPILATION: + case COMPILATION -> { return Stream.concat(allExports, allOpens) .distinct() .sorted() .flatMap(BaselineModuleJvmArgs::addExportArg) .collect(ImmutableList.toImmutableList()); - case RUNTIME: + } + case RUNTIME -> { Stream exports = allExports.distinct().sorted().flatMap(BaselineModuleJvmArgs::addExportArg); Stream opens = allOpens.distinct().sorted().flatMap(BaselineModuleJvmArgs::addOpensArg); return Stream.concat(exports, opens).collect(ImmutableList.toImmutableList()); + } } throw new IllegalStateException("unknown mode: " + mode); } diff --git a/gradle-baseline-java/src/main/java/com/palantir/baseline/tasks/CheckClassUniquenessLockTask.java b/gradle-baseline-java/src/main/java/com/palantir/baseline/tasks/CheckClassUniquenessLockTask.java index 02fd819f9..b1ef2a0ca 100644 --- a/gradle-baseline-java/src/main/java/com/palantir/baseline/tasks/CheckClassUniquenessLockTask.java +++ b/gradle-baseline-java/src/main/java/com/palantir/baseline/tasks/CheckClassUniquenessLockTask.java @@ -241,10 +241,10 @@ private void ensureLockfileDoesNotExist() { * also use reflection to just find the getName method but this is a little more explicit as to why. */ private static String getConfigurationName(Object config) { - if (config instanceof Named) { - return ((Named) config).getName(); - } else if (config instanceof Configuration) { - return ((Configuration) config).getName(); + if (config instanceof Named named) { + return named.getName(); + } else if (config instanceof Configuration configuration) { + return configuration.getName(); } throw new IllegalArgumentException("Unknown class for getting name: " + config.getClass()); From da8c5c0c52c415b4643312851f4e312792f51a3c Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Tue, 6 May 2025 13:42:58 -0400 Subject: [PATCH 4/7] Retrigger From 5092ccddb930983d6e9c99fc2d1e090869e88d96 Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Tue, 6 May 2025 14:52:55 -0400 Subject: [PATCH 5/7] Inject parameters --- .../errorprone/ExecutorSubmitRunnableFutureIgnored.java | 6 ++++++ .../baseline/errorprone/ReadReturnValueIgnored.java | 6 ++++++ .../baseline/errorprone/UnsafeGaugeRegistration.java | 6 ++++++ 3 files changed, 18 insertions(+) diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java index 96892e792..ff482d26d 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ExecutorSubmitRunnableFutureIgnored.java @@ -30,6 +30,7 @@ import com.sun.source.tree.ExpressionTree; import com.sun.source.tree.MethodInvocationTree; import java.util.concurrent.ExecutorService; +import javax.inject.Inject; @AutoService(BugChecker.class) @BugPattern( @@ -51,6 +52,11 @@ public ExecutorSubmitRunnableFutureIgnored() { super(ConstantExpressions.fromFlags(ErrorProneFlags.empty())); } + @Inject + ExecutorSubmitRunnableFutureIgnored(ConstantExpressions constantExpressions) { + super(constantExpressions); + } + @Override public Matcher specializedMatcher() { return MATCHER; diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java index b421b26fb..aef5f94e3 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ReadReturnValueIgnored.java @@ -40,6 +40,7 @@ import java.io.RandomAccessFile; import java.io.Reader; import java.util.List; +import javax.inject.Inject; @AutoService(BugChecker.class) @BugPattern( @@ -54,6 +55,11 @@ public ReadReturnValueIgnored() { super(ConstantExpressions.fromFlags(ErrorProneFlags.empty())); } + @Inject + ReadReturnValueIgnored(ConstantExpressions constantExpressions) { + super(constantExpressions); + } + // MethodMatchers does not support matching arrays private static final Matcher INPUT_STREAM_BUFFER_READ_MATCHER = Matchers.allOf( MethodMatchers.instanceMethod() diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java index 96597ffca..a39926a83 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/UnsafeGaugeRegistration.java @@ -32,6 +32,7 @@ import com.sun.source.tree.ExpressionTree; import com.sun.source.tree.MethodInvocationTree; import com.sun.tools.javac.code.Symbol; +import javax.inject.Inject; @AutoService(BugChecker.class) @BugPattern( @@ -60,6 +61,11 @@ public UnsafeGaugeRegistration() { super(ConstantExpressions.fromFlags(ErrorProneFlags.empty())); } + @Inject + UnsafeGaugeRegistration(ConstantExpressions constantExpressions) { + super(constantExpressions); + } + @Override public Matcher specializedMatcher() { return MATCHER; From 421ab59d83473465b6507d94737bc65d4ee15072 Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Tue, 6 May 2025 22:15:56 -0400 Subject: [PATCH 6/7] Disable test that has been rendered incorrect by underlying errorprone change --- .../BaselineErrorProneIntegrationTest.groovy | 65 ++++++++++--------- 1 file changed, 34 insertions(+), 31 deletions(-) diff --git a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineErrorProneIntegrationTest.groovy b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineErrorProneIntegrationTest.groovy index ece611487..75b50a369 100644 --- a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineErrorProneIntegrationTest.groovy +++ b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineErrorProneIntegrationTest.groovy @@ -203,37 +203,40 @@ class BaselineErrorProneIntegrationTest extends AbstractPluginTest { '''.stripIndent() } - def 'compileJava applies patches when errorProneApply contains specific checks including disabled'() { - when: - buildFile << standardBuildFile - buildFile << """ - tasks.withType(JavaCompile) { - options.errorprone.disable 'OptionalOrElseMethodInvocation' - } - dependencies { - implementation 'org.slf4j:slf4j-api:1.7.25' - } - """.stripIndent() - file('src/main/java/test/Test.java') << invalidJavaFile - - then: - BuildResult result = with('compileJava', '-PerrorProneApply=OptionalOrElseMethodInvocation').build() - result.task(":compileJava").outcome == TaskOutcome.SUCCESS - file('src/main/java/test/Test.java').text == ''' - package test; - import java.util.Optional; - public class Test { - void test() { - int[] a = {1, 2, 3}; - int[] b = {1, 2, 3}; - if (a.equals(b)) { - System.out.println("arrays are equal!"); - Optional.of("hello").orElseGet(() -> System.getProperty("world")); - } - } - } - '''.stripIndent() - } +// As of https://github.com/google/error-prone/pull/4699, error prone no longer applies patches to disabled checks. +// Disabling this test since it is no longer valid and will require significant changes to restore the prior behavior. + +// def 'compileJava applies patches when errorProneApply contains specific checks including disabled'() { +// when: +// buildFile << standardBuildFile +// buildFile << """ +// tasks.withType(JavaCompile) { +// options.errorprone.disable 'OptionalOrElseMethodInvocation' +// } +// dependencies { +// implementation 'org.slf4j:slf4j-api:1.7.25' +// } +// """.stripIndent() +// file('src/main/java/test/Test.java') << invalidJavaFile +// +// then: +// BuildResult result = with('compileJava', '-PerrorProneApply=OptionalOrElseMethodInvocation').build() +// result.task(":compileJava").outcome == TaskOutcome.SUCCESS +// file('src/main/java/test/Test.java').text == ''' +// package test; +// import java.util.Optional; +// public class Test { +// void test() { +// int[] a = {1, 2, 3}; +// int[] b = {1, 2, 3}; +// if (a.equals(b)) { +// System.out.println("arrays are equal!"); +// Optional.of("hello").orElseGet(() -> System.getProperty("world")); +// } +// } +// } +// '''.stripIndent() +// } enum CheckConfigurationMethod { ARG, DSL } From d9079461dc9255cc526e1f92627e99d91e1fdf00 Mon Sep 17 00:00:00 2001 From: Joe Mongeluzzi Date: Tue, 6 May 2025 22:33:28 -0400 Subject: [PATCH 7/7] Add changelog --- changelog/@unreleased/pr-3101.v2.yml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 changelog/@unreleased/pr-3101.v2.yml diff --git a/changelog/@unreleased/pr-3101.v2.yml b/changelog/@unreleased/pr-3101.v2.yml new file mode 100644 index 000000000..b5ae0824c --- /dev/null +++ b/changelog/@unreleased/pr-3101.v2.yml @@ -0,0 +1,5 @@ +type: fix +fix: + description: Fix compatibility with error-prone 2.38.0 + links: + - https://github.com/palantir/gradle-baseline/pull/3101