diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index 457fc2b7..6890219e 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -54,4 +54,3 @@ jobs: run: mvn build-helper:remove-project-artifact # XXX: Enable Codecov once we "go public". -# XXX: Enable SonarCloud once we "go public". diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml new file mode 100644 index 00000000..3966960a --- /dev/null +++ b/.github/workflows/sonarcloud.yml @@ -0,0 +1,36 @@ +# Analyzes the code base using SonarCloud. See +# https://sonarcloud.io/project/overview?id=PicnicSupermarket_error-prone-support. +name: SonarCloud analysis +on: + pull_request: + push: + branches: [ master ] + schedule: + - cron: '0 4 * * 1' +permissions: + contents: read +jobs: + analyze: + permissions: + contents: read + runs-on: ubuntu-22.04 + steps: + - name: Check out code + uses: actions/checkout@v3.1.0 + with: + fetch-depth: 0 + persist-credentials: false + - name: Set up JDK + uses: actions/setup-java@v3.8.0 + with: + java-version: 17.0.6 + distribution: temurin + cache: maven + - name: Create missing `test` directory + # XXX: Drop this step in favour of actually having a test. + run: mkdir refaster-compiler/src/test + - name: Perform SonarCloud analysis + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} + run: mvn -T1C jacoco:prepare-agent verify jacoco:report sonar:sonar -Dverification.skip -Dsonar.projectKey=PicnicSupermarket_error-prone-support diff --git a/documentation-support/src/main/java/tech/picnic/errorprone/documentation/ExtractorType.java b/documentation-support/src/main/java/tech/picnic/errorprone/documentation/ExtractorType.java index 42f5b48a..8ba9e8b8 100644 --- a/documentation-support/src/main/java/tech/picnic/errorprone/documentation/ExtractorType.java +++ b/documentation-support/src/main/java/tech/picnic/errorprone/documentation/ExtractorType.java @@ -25,6 +25,7 @@ enum ExtractorType { return identifier; } + @SuppressWarnings("java:S1452" /* The extractor returns data of an unspecified type. */) Extractor getExtractor() { return extractor; } diff --git a/documentation-support/src/test/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListenerTest.java b/documentation-support/src/test/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListenerTest.java index 48b50ca6..b49e7ba1 100644 --- a/documentation-support/src/test/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListenerTest.java +++ b/documentation-support/src/test/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListenerTest.java @@ -67,10 +67,11 @@ final class DocumentationGeneratorTaskListenerTest { @Test void excessArguments(@TempDir Path outputDirectory) { + String actualOutputDirectory = outputDirectory.toAbsolutePath() + " extra-arg"; assertThatThrownBy( () -> Compilation.compileWithDocumentationGenerator( - outputDirectory.toAbsolutePath() + " extra-arg", "A.java", "package pkg;")) + actualOutputDirectory, "A.java", "package pkg;")) .isInstanceOf(IllegalArgumentException.class) .hasMessage("Precisely one path must be provided"); } diff --git a/error-prone-contrib/README.md b/error-prone-contrib/README.md index 77ee5c6f..cf5d5925 100644 --- a/error-prone-contrib/README.md +++ b/error-prone-contrib/README.md @@ -24,7 +24,6 @@ project: - Document how to apply patches. - Document each of the checks. -- Add [SonarQube][sonarcloud] and [Codecov][codecov] integrations. - Add non-Java file formatting support, like we have internally at Picnic. (I.e., somehow open-source that stuff.) - Auto-generate a website listing each of the checks, just like the Error Prone @@ -273,7 +272,6 @@ Refaster's expressiveness: [autorefactor]: https://autorefactor.org [bettercodehub]: https://bettercodehub.com [checkstyle-external-project-tests]: https://github.com/checkstyle/checkstyle/blob/master/wercker.yml -[codecov]: https://codecov.io [error-prone-bug-patterns]: https://errorprone.info/bugpatterns [error-prone]: https://errorprone.info [error-prone-repo]: https://github.com/google/error-prone @@ -283,4 +281,3 @@ Refaster's expressiveness: [main-contributing]: ../CONTRIBUTING.md [main-readme]: ../README.md [modernizer-maven-plugin]: https://github.com/gaul/modernizer-maven-plugin -[sonarcloud]: https://sonarcloud.io diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AssociativeMethodInvocation.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AssociativeMethodInvocation.java index 40259d7d..1bcc8ec3 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AssociativeMethodInvocation.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AssociativeMethodInvocation.java @@ -39,7 +39,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode; @AutoService(BugChecker.class) @BugPattern( summary = - "These methods implement an associative operation, so the list of operands can be flattened", + "This method implements an associative operation, so the list of operands can be flattened", link = BUG_PATTERNS_BASE_URL + "AssociativeMethodInvocation", linkType = CUSTOM, severity = SUGGESTION, @@ -70,24 +70,31 @@ public final class AssociativeMethodInvocation extends BugChecker for (Matcher matcher : ASSOCIATIVE_OPERATIONS) { if (matcher.matches(tree, state)) { - SuggestedFix.Builder fix = SuggestedFix.builder(); - for (ExpressionTree arg : tree.getArguments()) { - if (matcher.matches(arg, state)) { - MethodInvocationTree invocation = (MethodInvocationTree) arg; - fix.merge( - invocation.getArguments().isEmpty() - ? SuggestedFixes.removeElement(arg, tree.getArguments(), state) - : SourceCode.unwrapMethodInvocation(invocation, state)); - } - } - - return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix.build()); + SuggestedFix fix = processMatchingArguments(tree, matcher, state); + return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix); } } return Description.NO_MATCH; } + private static SuggestedFix processMatchingArguments( + MethodInvocationTree tree, Matcher matcher, VisitorState state) { + SuggestedFix.Builder fix = SuggestedFix.builder(); + + for (ExpressionTree arg : tree.getArguments()) { + if (matcher.matches(arg, state)) { + MethodInvocationTree invocation = (MethodInvocationTree) arg; + fix.merge( + invocation.getArguments().isEmpty() + ? SuggestedFixes.removeElement(invocation, tree.getArguments(), state) + : SourceCode.unwrapMethodInvocation(invocation, state)); + } + } + + return fix.build(); + } + private static Matcher hasArgumentOfType(Supplier type) { return (tree, state) -> tree.getArguments().stream() diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AutowiredConstructor.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AutowiredConstructor.java index 06f860c6..0d9eaee0 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AutowiredConstructor.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AutowiredConstructor.java @@ -58,8 +58,8 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM /* * This is the only `@Autowired` constructor: suggest that it be removed. Note that this likely - * means that the associated import can be removed as well. Rather than adding code for this case we - * leave flagging the unused import to Error Prone's `RemoveUnusedImports` check. + * means that the associated import can be removed as well. Rather than adding code for this + * case we leave flagging the unused import to Error Prone's `RemoveUnusedImports` check. */ AnnotationTree annotation = Iterables.getOnlyElement(annotations); return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state)); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CollectorMutability.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CollectorMutability.java index e2baa3c1..e5725f74 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CollectorMutability.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CollectorMutability.java @@ -30,7 +30,7 @@ import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary; @AutoService(BugChecker.class) @BugPattern( summary = - "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability", + "Avoid `Collectors.to{List,Map,Set}` in favor of collectors that emphasize (im)mutability", link = BUG_PATTERNS_BASE_URL + "CollectorMutability", linkType = CUSTOM, severity = WARNING, diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/EmptyMethod.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/EmptyMethod.java index 0de1b28c..e1b4173c 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/EmptyMethod.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/EmptyMethod.java @@ -42,6 +42,7 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher { public EmptyMethod() {} @Override + @SuppressWarnings("java:S1067" /* Chaining disjunctions like this does not impact readability. */) public Description matchMethod(MethodTree tree, VisitorState state) { if (tree.getBody() == null || !tree.getBody().getStatements().isEmpty() diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ErrorProneTestHelperSourceFormat.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ErrorProneTestHelperSourceFormat.java index cec01c62..36638164 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ErrorProneTestHelperSourceFormat.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ErrorProneTestHelperSourceFormat.java @@ -104,7 +104,9 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker String formatted; try { formatted = formatSourceCode(source, retainUnusedImports).trim(); - } catch (FormatterException e) { + } catch ( + @SuppressWarnings("java:S1166" /* Stack trace not relevant. */) + FormatterException e) { return buildDescription(methodInvocation) .setMessage(String.format("Source code is malformed: %s", e.getMessage())) .build(); @@ -131,7 +133,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker SuggestedFix.replace( startPos, endPos, - Splitter.on('\n') + Splitter.on(System.lineSeparator()) .splitToStream(formatted) .map(state::getConstantExpression) .collect(joining(", ")))); @@ -157,7 +159,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker return Optional.empty(); } - source.append(value).append('\n'); + source.append(value).append(System.lineSeparator()); } return Optional.of(source.toString()); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListing.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListing.java index 2bf8cbd7..bd346140 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListing.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListing.java @@ -58,6 +58,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode; linkType = CUSTOM, severity = SUGGESTION, tags = STYLE) +@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */) public final class LexicographicalAnnotationAttributeListing extends BugChecker implements AnnotationTreeMatcher { private static final long serialVersionUID = 1L; diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListing.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListing.java index 01cd32f5..2f026938 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListing.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListing.java @@ -46,9 +46,19 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode; public final class LexicographicalAnnotationListing extends BugChecker implements MethodTreeMatcher { private static final long serialVersionUID = 1L; + /** + * A comparator that minimally reorders {@link AnnotationType}s, such that declaration annotations + * are placed before type annotations. + */ + @SuppressWarnings({ + "java:S1067", + "java:S3358" + } /* Avoiding the nested ternary operator hurts readability. */) private static final Comparator<@Nullable AnnotationType> BY_ANNOTATION_TYPE = (a, b) -> - (a == null || a == DECLARATION) && b == TYPE ? -1 : a == TYPE && b == DECLARATION ? 1 : 0; + (a == null || a == DECLARATION) && b == TYPE + ? -1 + : (a == TYPE && b == DECLARATION ? 1 : 0); /** Instantiates a new {@link LexicographicalAnnotationListing} instance. */ public LexicographicalAnnotationListing() {} diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsage.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsage.java index 87d4b3ef..6c75d67e 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsage.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsage.java @@ -118,6 +118,8 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr .flatMap(expectedInstance -> constructMethodRef(lambdaExpr, subTree, expectedInstance)); } + @SuppressWarnings( + "java:S1151" /* Extracting `IDENTIFIER` case block to separate method does not improve readability. */) private static Optional constructMethodRef( LambdaExpressionTree lambdaExpr, MethodInvocationTree subTree, @@ -130,10 +132,9 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr return Optional.empty(); } Symbol sym = ASTHelpers.getSymbol(methodSelect); - if (!ASTHelpers.isStatic(sym)) { - return constructFix(lambdaExpr, "this", methodSelect); - } - return constructFix(lambdaExpr, sym.owner, methodSelect); + return ASTHelpers.isStatic(sym) + ? constructFix(lambdaExpr, sym.owner, methodSelect) + : constructFix(lambdaExpr, "this", methodSelect); case MEMBER_SELECT: return constructMethodRef(lambdaExpr, (MemberSelectTree) methodSelect, expectedInstance); default: diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/NonEmptyMono.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/NonEmptyMono.java index 87514bdb..4108d703 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/NonEmptyMono.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/NonEmptyMono.java @@ -43,6 +43,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode; // emitting a value (e.g. `Mono.empty()`, `someFlux.then()`, ...), or known not to complete normally // (`Mono.never()`, `someFlux.repeat()`, `Mono.error(...)`, ...). The latter category could // potentially be split out further. +@SuppressWarnings("java:S1192" /* Factoring out repeated method names impacts readability. */) public final class NonEmptyMono extends BugChecker implements MethodInvocationTreeMatcher { private static final long serialVersionUID = 1L; private static final Matcher MONO_SIZE_CHECK = diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/PrimitiveComparison.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/PrimitiveComparison.java index bd26e35d..9f2d2f82 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/PrimitiveComparison.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/PrimitiveComparison.java @@ -49,6 +49,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode; linkType = CUSTOM, severity = WARNING, tags = PERFORMANCE) +@SuppressWarnings("java:S1192" /* Factoring out repeated method names impacts readability. */) public final class PrimitiveComparison extends BugChecker implements MethodInvocationTreeMatcher { private static final long serialVersionUID = 1L; private static final Matcher STATIC_COMPARISON_METHOD = diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RedundantStringConversion.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RedundantStringConversion.java index 53c6e0f9..db4889a9 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RedundantStringConversion.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RedundantStringConversion.java @@ -62,6 +62,11 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode; linkType = CUSTOM, severity = SUGGESTION, tags = SIMPLIFICATION) +@SuppressWarnings({ + "java:S1192" /* Factoring out repeated method names impacts readability. */, + "java:S2160" /* Super class equality definition suffices. */, + "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict" +}) public final class RedundantStringConversion extends BugChecker implements BinaryTreeMatcher, CompoundAssignmentTreeMatcher, MethodInvocationTreeMatcher { private static final long serialVersionUID = 1L; @@ -163,7 +168,7 @@ public final class RedundantStringConversion extends BugChecker ExpressionTree lhs = tree.getLeftOperand(); ExpressionTree rhs = tree.getRightOperand(); if (!STRING.matches(lhs, state)) { - return finalize(tree, tryFix(rhs, state, STRING)); + return createDescription(tree, tryFix(rhs, state, STRING)); } List fixes = new ArrayList<>(); @@ -177,7 +182,7 @@ public final class RedundantStringConversion extends BugChecker } tryFix(rhs, state, ANY_EXPR).ifPresent(fixes::add); - return finalize(tree, fixes.stream().reduce(SuggestedFix.Builder::merge)); + return createDescription(tree, fixes.stream().reduce(SuggestedFix.Builder::merge)); } @Override @@ -186,36 +191,36 @@ public final class RedundantStringConversion extends BugChecker return Description.NO_MATCH; } - return finalize(tree, tryFix(tree.getExpression(), state, ANY_EXPR)); + return createDescription(tree, tryFix(tree.getExpression(), state, ANY_EXPR)); } @Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (STRINGBUILDER_APPEND_INVOCATION.matches(tree, state)) { - return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 0)); + return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 0)); } if (STRINGBUILDER_INSERT_INVOCATION.matches(tree, state)) { - return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 1)); + return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 1)); } if (FORMATTER_INVOCATION.matches(tree, state)) { - return finalize(tree, tryFixFormatter(tree.getArguments(), state)); + return createDescription(tree, tryFixFormatter(tree.getArguments(), state)); } if (GUAVA_GUARD_INVOCATION.matches(tree, state)) { - return finalize(tree, tryFixGuavaGuard(tree.getArguments(), state)); + return createDescription(tree, tryFixGuavaGuard(tree.getArguments(), state)); } if (SLF4J_LOGGER_INVOCATION.matches(tree, state)) { - return finalize(tree, tryFixSlf4jLogger(tree.getArguments(), state)); + return createDescription(tree, tryFixSlf4jLogger(tree.getArguments(), state)); } if (instanceMethod().matches(tree, state)) { - return finalize(tree, tryFix(tree, state, STRING)); + return createDescription(tree, tryFix(tree, state, STRING)); } - return finalize(tree, tryFix(tree, state, NON_NULL_STRING)); + return createDescription(tree, tryFix(tree, state, NON_NULL_STRING)); } private Optional tryFixPositionalConverter( @@ -298,7 +303,7 @@ public final class RedundantStringConversion extends BugChecker /* Simplify the values to be plugged into the format pattern, if possible. */ return arguments.stream() - .skip(patternIndex + 1) + .skip(patternIndex + 1L) .map(arg -> tryFix(arg, state, remainingArgFilter)) .flatMap(Optional::stream) .reduce(SuggestedFix.Builder::merge); @@ -362,7 +367,7 @@ public final class RedundantStringConversion extends BugChecker return Optional.of(Iterables.getOnlyElement(methodInvocation.getArguments())); } - private Description finalize(Tree tree, Optional fixes) { + private Description createDescription(Tree tree, Optional fixes) { return fixes .map(SuggestedFix.Builder::build) .map(fix -> describeMatch(tree, fix)) diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestMappingAnnotation.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestMappingAnnotation.java index f626075a..d8d6df2f 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestMappingAnnotation.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestMappingAnnotation.java @@ -99,8 +99,9 @@ public final class RequestMappingAnnotation extends BugChecker implements Method && LACKS_PARAMETER_ANNOTATION.matches(tree, state) ? buildDescription(tree) .setMessage( - "Not all parameters of this request mapping method are annotated; this may be a mistake. " - + "If the unannotated parameters represent query string parameters, annotate them with `@RequestParam`.") + "Not all parameters of this request mapping method are annotated; this may be a " + + "mistake. If the unannotated parameters represent query string parameters, " + + "annotate them with `@RequestParam`.") .build() : Description.NO_MATCH; } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestParamType.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestParamType.java index 28b9e8d4..13143621 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestParamType.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestParamType.java @@ -38,6 +38,7 @@ import tech.picnic.errorprone.bugpatterns.util.Flags; linkType = CUSTOM, severity = ERROR, tags = LIKELY_ERROR) +@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */) public final class RequestParamType extends BugChecker implements VariableTreeMatcher { private static final long serialVersionUID = 1L; private static final String SUPPORTED_CUSTOM_TYPES_FLAG = "RequestParamType:SupportedCustomTypes"; diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/AnnotationAttributeMatcher.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/AnnotationAttributeMatcher.java index 05098a49..fc10d03f 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/AnnotationAttributeMatcher.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/AnnotationAttributeMatcher.java @@ -103,7 +103,7 @@ public final class AnnotationAttributeMatcher implements Serializable { * @param tree The annotation AST node to be inspected. * @return Any matching annotation arguments. */ - public Stream extractMatchingArguments(AnnotationTree tree) { + public Stream extractMatchingArguments(AnnotationTree tree) { Type type = ASTHelpers.getType(tree.getAnnotationType()); if (type == null) { return Stream.empty(); @@ -111,6 +111,7 @@ public final class AnnotationAttributeMatcher implements Serializable { String annotationType = type.toString(); return tree.getArguments().stream() + .map(ExpressionTree.class::cast) .filter(a -> matches(annotationType, extractAttributeName(a))); } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/JavaKeywords.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/JavaKeywords.java index e9e70515..d2654086 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/JavaKeywords.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/JavaKeywords.java @@ -114,6 +114,7 @@ public final class JavaKeywords { * @see JDK 17 JLS * section 3.8: Identifiers */ + @SuppressWarnings("java:S1067" /* Chaining conjunctions like this does not impact readability. */) public static boolean isValidIdentifier(String str) { return !str.isEmpty() && !isReservedKeyword(str) diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactory.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactory.java index 2a895214..6da73601 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactory.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactory.java @@ -18,6 +18,9 @@ import java.util.regex.Pattern; public final class MethodMatcherFactory { private static final Splitter ARGUMENT_TYPE_SPLITTER = Splitter.on(',').trimResults().omitEmptyStrings(); + // XXX: Check whether we can use a parser for "standard" Java signatures here. Maybe + // `sun.reflect.generics.parser.SignatureParser`? + @SuppressWarnings("java:S5998" /* In practice there will be only modest recursion. */) private static final Pattern METHOD_SIGNATURE = Pattern.compile("([^\\s#(,)]+)#([^\\s#(,)]+)\\(((?:[^\\s#(,)]+(?:,[^\\s#(,)]+)*)?)\\)"); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/ThirdPartyLibrary.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/ThirdPartyLibrary.java index 9b8cbd9e..7fb7c118 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/ThirdPartyLibrary.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/ThirdPartyLibrary.java @@ -90,7 +90,9 @@ public enum ThirdPartyLibrary { try { classFinder.loadClass(state.getSymtab().unnamedModule, binaryName); return true; - } catch (CompletionFailure e) { + } catch ( + @SuppressWarnings("java:S1166" /* Not exceptional. */) + CompletionFailure e) { return false; } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJPrimitiveRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJPrimitiveRules.java index e3285067..476d57da 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJPrimitiveRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJPrimitiveRules.java @@ -23,6 +23,8 @@ final class AssertJPrimitiveRules { } @BeforeTemplate + @SuppressWarnings( + "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */) AbstractBooleanAssert before(double actual, double expected) { return Refaster.anyOf( assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse()); @@ -43,6 +45,8 @@ final class AssertJPrimitiveRules { } @BeforeTemplate + @SuppressWarnings( + "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */) AbstractBooleanAssert before(double actual, double expected) { return Refaster.anyOf( assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse()); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java index f07102e2..49b92a4e 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java @@ -2024,8 +2024,8 @@ final class AssertJRules { //////////////////////////////////////////////////////////////////////////// // Above: Generated code. - /////////////////////////////////////////////////////////////////////////////////////////////////////// - /////////////////////////////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////// // Organize the code below. // XXX: Do the "single Comparable" match shown below. diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRules.java index 3bfb7502..a1c571ee 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRules.java @@ -47,7 +47,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalArgumentExceptionHasMessage { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalArgumentException().isThrownBy(throwingCallable).withMessage(message); } @@ -64,7 +64,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */) AbstractObjectAssert before( ThrowingCallable throwingCallable, String message, @Repeated Object parameters) { return assertThatIllegalArgumentException() @@ -85,7 +85,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalArgumentException() .isThrownBy(throwingCallable) @@ -104,7 +104,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalArgumentExceptionHasMessageContaining { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalArgumentException() .isThrownBy(throwingCallable) @@ -123,7 +123,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */) AbstractObjectAssert before( ThrowingCallable throwingCallable, @Repeated CharSequence values) { return assertThatIllegalArgumentException() @@ -157,7 +157,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalStateExceptionHasMessage { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalStateException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalStateException().isThrownBy(throwingCallable).withMessage(message); } @@ -174,7 +174,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalStateException" /* This is a more specific template. */) AbstractObjectAssert before( ThrowingCallable throwingCallable, String message, @Repeated Object parameters) { return assertThatIllegalStateException() @@ -195,7 +195,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalStateExceptionHasMessageStartingWith { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalStateException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalStateException() .isThrownBy(throwingCallable) @@ -214,7 +214,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalStateExceptionHasMessageContaining { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalStateException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalStateException() .isThrownBy(throwingCallable) @@ -233,7 +233,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIllegalStateExceptionHasMessageNotContaining { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByIllegalStateException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIllegalStateException() .isThrownBy(throwingCallable) @@ -265,7 +265,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByNullPointerExceptionHasMessage { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByNullPointerException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatNullPointerException().isThrownBy(throwingCallable).withMessage(message); } @@ -282,7 +282,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByNullPointerExceptionHasMessageParameters { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByNullPointerException" /* This is a more specific template. */) AbstractObjectAssert before( ThrowingCallable throwingCallable, String message, @Repeated Object parameters) { return assertThatNullPointerException() @@ -303,7 +303,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByNullPointerExceptionHasMessageStartingWith { @BeforeTemplate @SuppressWarnings( - "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */) + "AssertThatThrownByNullPointerException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatNullPointerException() .isThrownBy(throwingCallable) @@ -334,8 +334,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIOExceptionHasMessage { @BeforeTemplate - @SuppressWarnings( - "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */) + @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */) AbstractObjectAssert before(ThrowingCallable throwingCallable, String message) { return assertThatIOException().isThrownBy(throwingCallable).withMessage(message); } @@ -351,8 +350,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByIOExceptionHasMessageParameters { @BeforeTemplate - @SuppressWarnings( - "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */) + @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */) AbstractObjectAssert before( ThrowingCallable throwingCallable, String message, @Repeated Object parameters) { return assertThatIOException().isThrownBy(throwingCallable).withMessage(message, parameters); @@ -385,7 +383,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByHasMessage { @BeforeTemplate - @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */) + @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */) AbstractObjectAssert before( Class exceptionType, ThrowingCallable throwingCallable, @@ -407,7 +405,7 @@ final class AssertJThrowingCallableRules { static final class AssertThatThrownByHasMessageParameters { @BeforeTemplate - @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */) + @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */) AbstractObjectAssert before( Class exceptionType, ThrowingCallable throwingCallable, diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java index ff0cd1f1..a76e99c8 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java @@ -115,6 +115,7 @@ final class AssortedRules { // intelligently. static final class LogicalImplication { @BeforeTemplate + @SuppressWarnings("java:S2589" /* This violation will be rewritten. */) boolean before(boolean firstTest, boolean secondTest) { return firstTest || (!firstTest && secondTest); } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java index 08e3878f..ca143ad2 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java @@ -56,6 +56,7 @@ final class BigDecimalRules { // `BugChecker`. static final class BigDecimalValueOf { @BeforeTemplate + @SuppressWarnings("java:S2111" /* This violation will be rewritten. */) BigDecimal before(double value) { return new BigDecimal(value); } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java index 90dc4f18..ff8c9d4c 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java @@ -35,6 +35,7 @@ final class CollectionRules { */ static final class CollectionIsEmpty { @BeforeTemplate + @SuppressWarnings("java:S1155" /* This violation will be rewritten. */) boolean before(Collection collection) { return Refaster.anyOf( collection.size() == 0, diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java index c15b466a..f8ec1393 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java @@ -233,6 +233,7 @@ final class ComparatorRules { /** Prefer {@link Comparators#min(Comparable, Comparable)}} over more verbose alternatives. */ static final class MinOfPairNaturalOrder> { @BeforeTemplate + @SuppressWarnings("java:S1067" /* The conditional operators are independent. */) T before(T value1, T value2) { return Refaster.anyOf( value1.compareTo(value2) <= 0 ? value1 : value2, @@ -259,6 +260,7 @@ final class ComparatorRules { */ static final class MinOfPairCustomOrder { @BeforeTemplate + @SuppressWarnings("java:S1067" /* The conditional operators are independent. */) T before(T value1, T value2, Comparator cmp) { return Refaster.anyOf( cmp.compare(value1, value2) <= 0 ? value1 : value2, @@ -299,6 +301,7 @@ final class ComparatorRules { /** Prefer {@link Comparators#max(Comparable, Comparable)}} over more verbose alternatives. */ static final class MaxOfPairNaturalOrder> { @BeforeTemplate + @SuppressWarnings("java:S1067" /* The conditional operators are independent. */) T before(T value1, T value2) { return Refaster.anyOf( value1.compareTo(value2) >= 0 ? value1 : value2, @@ -325,6 +328,7 @@ final class ComparatorRules { */ static final class MaxOfPairCustomOrder { @BeforeTemplate + @SuppressWarnings("java:S1067" /* The conditional operators are independent. */) T before(T value1, T value2, Comparator cmp) { return Refaster.anyOf( cmp.compare(value1, value2) >= 0 ? value1 : value2, diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/DoubleStreamRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/DoubleStreamRules.java index ae8a3892..5e12ce57 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/DoubleStreamRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/DoubleStreamRules.java @@ -237,6 +237,7 @@ final class DoubleStreamRules { /** Prefer {@link DoubleStream#anyMatch(DoublePredicate)} over more contrived alternatives. */ static final class DoubleStreamAnyMatch { @BeforeTemplate + @SuppressWarnings("java:S4034" /* This violation will be rewritten. */) boolean before(DoubleStream stream, DoublePredicate predicate) { return Refaster.anyOf( !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent()); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/EqualityRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/EqualityRules.java index 244a9ece..bb6eb4bb 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/EqualityRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/EqualityRules.java @@ -30,6 +30,7 @@ final class EqualityRules { @AfterTemplate @AlsoNegation + @SuppressWarnings("java:S1698" /* Reference comparison is valid for enums. */) boolean after(T a, T b) { return a == b; } @@ -56,6 +57,7 @@ final class EqualityRules { /** Avoid double negations; this is not Javascript. */ static final class DoubleNegation { @BeforeTemplate + @SuppressWarnings("java:S2761" /* This violation will be rewritten. */) boolean before(boolean b) { return !!b; } @@ -72,6 +74,7 @@ final class EqualityRules { */ // XXX: Replacing `a ? !b : b` with `a != b` changes semantics if both `a` and `b` are boxed // booleans. + @SuppressWarnings("java:S1940" /* This violation will be rewritten. */) static final class Negation { @BeforeTemplate boolean before(boolean a, boolean b) { @@ -79,6 +82,8 @@ final class EqualityRules { } @BeforeTemplate + @SuppressWarnings( + "java:S1244" /* The equality check is fragile, but may be seen in the wild. */) boolean before(double a, double b) { return !(a == b); } @@ -100,6 +105,7 @@ final class EqualityRules { */ // XXX: Replacing `a ? b : !b` with `a == b` changes semantics if both `a` and `b` are boxed // booleans. + @SuppressWarnings("java:S1940" /* This violation will be rewritten. */) static final class IndirectDoubleNegation { @BeforeTemplate boolean before(boolean a, boolean b) { @@ -107,6 +113,8 @@ final class EqualityRules { } @BeforeTemplate + @SuppressWarnings( + "java:S1244" /* The inequality check is fragile, but may be seen in the wild. */) boolean before(double a, double b) { return !(a != b); } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java index 9e5096bb..49021f1a 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java @@ -250,7 +250,8 @@ final class ImmutableMapRules { * Prefer {@link ImmutableMap#of(Object, Object, Object, Object)} over alternatives that don't * communicate the immutability of the resulting map at the type level. */ - // XXX: Also rewrite the `ImmutableMap.builder()` variant? + // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will + // also make it easier to rewrite various `ImmutableMap.builder()` variants. static final class ImmutableMapOf2 { @BeforeTemplate Map before(K k1, V v1, K k2, V v2) { @@ -267,7 +268,8 @@ final class ImmutableMapRules { * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object)} over * alternatives that don't communicate the immutability of the resulting map at the type level. */ - // XXX: Also rewrite the `ImmutableMap.builder()` variant? + // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will + // also make it easier to rewrite various `ImmutableMap.builder()` variants. static final class ImmutableMapOf3 { @BeforeTemplate Map before(K k1, V v1, K k2, V v2, K k3, V v3) { @@ -285,7 +287,9 @@ final class ImmutableMapRules { * over alternatives that don't communicate the immutability of the resulting map at the type * level. */ - // XXX: Also rewrite the `ImmutableMap.builder()` variant? + // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will + // also make it easier to rewrite various `ImmutableMap.builder()` variants. + @SuppressWarnings("java:S107" /* Can't avoid many method parameters here. */) static final class ImmutableMapOf4 { @BeforeTemplate Map before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) { @@ -303,7 +307,9 @@ final class ImmutableMapRules { * Object, Object)} over alternatives that don't communicate the immutability of the resulting map * at the type level. */ - // XXX: Also rewrite the `ImmutableMap.builder()` variant? + // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will + // also make it easier to rewrite various `ImmutableMap.builder()` variants. + @SuppressWarnings("java:S107" /* Can't avoid many method parameters here. */) static final class ImmutableMapOf5 { @BeforeTemplate Map before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) { diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/IntStreamRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/IntStreamRules.java index 679bddaa..c49b7741 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/IntStreamRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/IntStreamRules.java @@ -250,6 +250,7 @@ final class IntStreamRules { /** Prefer {@link IntStream#anyMatch(IntPredicate)} over more contrived alternatives. */ static final class IntStreamAnyMatch { @BeforeTemplate + @SuppressWarnings("java:S4034" /* This violation will be rewritten. */) boolean before(IntStream stream, IntPredicate predicate) { return Refaster.anyOf( !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent()); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/JUnitToAssertJRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/JUnitToAssertJRules.java index 7d89b6ec..9cf04198 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/JUnitToAssertJRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/JUnitToAssertJRules.java @@ -34,8 +34,7 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation; *

Note that, while both libraries throw an {@link AssertionError} in case of an assertion * failure, the exact subtype used generally differs. */ -// XXX: Not all `org.assertj.core.api.Assertions` methods have an associated Refaster rule yet; -// expand this class. +// XXX: Not all JUnit `Assertions` methods have an associated Refaster rule yet; expand this class. // XXX: Introduce a `@Matcher` on `Executable` and `ThrowingSupplier` expressions, such that they // are only matched if they are also compatible with the `ThrowingCallable` functional interface. // When implementing such a matcher, note that expressions with a non-void return type such as @@ -45,7 +44,7 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation; final class JUnitToAssertJRules { private JUnitToAssertJRules() {} - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Assertions.class, assertDoesNotThrow(() -> null), diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/LongStreamRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/LongStreamRules.java index 76da55b0..bd7edb55 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/LongStreamRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/LongStreamRules.java @@ -250,6 +250,7 @@ final class LongStreamRules { /** Prefer {@link LongStream#anyMatch(LongPredicate)} over more contrived alternatives. */ static final class LongStreamAnyMatch { @BeforeTemplate + @SuppressWarnings("java:S4034" /* This violation will be rewritten. */) boolean before(LongStream stream, LongPredicate predicate) { return Refaster.anyOf( !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent()); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java index 676c7633..87f4ab8d 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java @@ -68,7 +68,10 @@ final class OptionalRules { /** Prefer {@link Optional#orElseThrow()} over the less explicit {@link Optional#get()}. */ static final class OptionalOrElseThrow { @BeforeTemplate - @SuppressWarnings("NullAway") + @SuppressWarnings({ + "java:S3655" /* Matched expressions are in practice embedded in a larger context. */, + "NullAway" + }) T before(Optional optional) { return optional.get(); } @@ -304,14 +307,12 @@ final class OptionalRules { abstract Optional toOptionalFunction(@MayOptionallyUse T element); @BeforeTemplate - Optional before( - Optional optional, Function> function) { + Optional before(Optional optional, Function> function) { return optional.flatMap(v -> toOptionalFunction(v).flatMap(function)); } @AfterTemplate - Optional after( - Optional optional, Function> function) { + Optional after(Optional optional, Function> function) { return optional.flatMap(v -> toOptionalFunction(v)).flatMap(function); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PreconditionsRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PreconditionsRules.java index 3ab863d1..0d11cc36 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PreconditionsRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PreconditionsRules.java @@ -91,6 +91,7 @@ final class PreconditionsRules { /** Prefer {@link Objects#requireNonNull(Object)} over more verbose alternatives. */ static final class RequireNonNullStatement { @BeforeTemplate + @SuppressWarnings("java:S1695" /* This violation will be rewritten. */) void before(T object) { if (object == null) { throw new NullPointerException(); @@ -121,6 +122,7 @@ final class PreconditionsRules { /** Prefer {@link Objects#requireNonNull(Object, String)} over more verbose alternatives. */ static final class RequireNonNullWithMessageStatement { @BeforeTemplate + @SuppressWarnings("java:S1695" /* This violation will be rewritten. */) void before(T object, String message) { if (object == null) { throw new NullPointerException(message); diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PrimitiveRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PrimitiveRules.java index b0c6c138..9baead99 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PrimitiveRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PrimitiveRules.java @@ -13,6 +13,7 @@ final class PrimitiveRules { /** Avoid contrived ways of expressing the "less than" relationship. */ static final class LessThan { @BeforeTemplate + @SuppressWarnings("java:S1940" /* This violation will be rewritten. */) boolean before(double a, double b) { return !(a >= b); } @@ -26,6 +27,7 @@ final class PrimitiveRules { /** Avoid contrived ways of expressing the "less than or equal to" relationship. */ static final class LessThanOrEqualTo { @BeforeTemplate + @SuppressWarnings("java:S1940" /* This violation will be rewritten. */) boolean before(double a, double b) { return !(a > b); } @@ -39,6 +41,7 @@ final class PrimitiveRules { /** Avoid contrived ways of expressing the "greater than" relationship. */ static final class GreaterThan { @BeforeTemplate + @SuppressWarnings("java:S1940" /* This violation will be rewritten. */) boolean before(double a, double b) { return !(a <= b); } @@ -52,6 +55,7 @@ final class PrimitiveRules { /** Avoid contrived ways of expressing the "greater than or equal to" relationship. */ static final class GreaterThanOrEqualTo { @BeforeTemplate + @SuppressWarnings("java:S1940" /* This violation will be rewritten. */) boolean before(double a, double b) { return !(a < b); } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java index a716420a..ef0734e2 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java @@ -620,6 +620,7 @@ final class ReactorRules { abstract S transformation(@MayOptionallyUse T value); @BeforeTemplate + @SuppressWarnings("java:S138" /* Method is long, but not complex. */) Publisher before(Flux flux, boolean delayUntilEnd, int maxConcurrency, int prefetch) { return Refaster.anyOf( flux.concatMap( diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java index adc1a53f..fb922ca4 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java @@ -316,6 +316,7 @@ final class StreamRules { /** Prefer {@link Stream#noneMatch(Predicate)} over more contrived alternatives. */ static final class StreamNoneMatch { @BeforeTemplate + @SuppressWarnings("java:S4034" /* This violation will be rewritten. */) boolean before(Stream stream, Predicate predicate) { return Refaster.anyOf( !stream.anyMatch(predicate), @@ -347,6 +348,7 @@ final class StreamRules { /** Prefer {@link Stream#anyMatch(Predicate)} over more contrived alternatives. */ static final class StreamAnyMatch { @BeforeTemplate + @SuppressWarnings("java:S4034" /* This violation will be rewritten. */) boolean before(Stream stream, Predicate predicate) { return Refaster.anyOf( !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent()); diff --git a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactoryTest.java b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactoryTest.java index c4af933c..2e06f291 100644 --- a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactoryTest.java +++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactoryTest.java @@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns.util; import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.params.provider.Arguments.arguments; import com.google.common.collect.ImmutableList; import com.google.errorprone.BugPattern; @@ -13,7 +14,11 @@ import com.google.errorprone.matchers.Description; import com.google.errorprone.matchers.Matcher; import com.sun.source.tree.ExpressionTree; import com.sun.source.tree.MethodInvocationTree; +import java.util.stream.Stream; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; final class MethodMatcherFactoryTest { private static final Matcher TEST_MATCHER = @@ -24,16 +29,20 @@ final class MethodMatcherFactoryTest { "com.example.A#m2(java.lang.String)", "com.example.sub.B#m3(int,int)")); - @Test - void createWithMalformedSignatures() { + private static Stream createWithMalformedSignaturesTestCases() { + /* { signatures } */ + return Stream.of( + arguments(ImmutableList.of("foo.bar")), + arguments(ImmutableList.of("foo.bar#baz")), + arguments(ImmutableList.of("a", "foo.bar#baz()")), + arguments(ImmutableList.of("foo.bar#baz()", "a"))); + } + + @MethodSource("createWithMalformedSignaturesTestCases") + @ParameterizedTest + void createWithMalformedSignatures(ImmutableList signatures) { MethodMatcherFactory factory = new MethodMatcherFactory(); - assertThatThrownBy(() -> factory.create(ImmutableList.of("foo.bar"))) - .isInstanceOf(IllegalArgumentException.class); - assertThatThrownBy(() -> factory.create(ImmutableList.of("foo.bar#baz"))) - .isInstanceOf(IllegalArgumentException.class); - assertThatThrownBy(() -> factory.create(ImmutableList.of("a", "foo.bar#baz()"))) - .isInstanceOf(IllegalArgumentException.class); - assertThatThrownBy(() -> factory.create(ImmutableList.of("foo.bar#baz()", "a"))) + assertThatThrownBy(() -> factory.create(signatures)) .isInstanceOf(IllegalArgumentException.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestInput.java index 6f33a5c2..3ed92b35 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestInput.java @@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJBigDecimalRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestOutput.java index 9fc72e7b..b9240671 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestOutput.java @@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJBigDecimalRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestInput.java index b3feb861..ef19fddc 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestInput.java @@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJBigIntegerRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestOutput.java index ea2fa457..dd723a51 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestOutput.java @@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJBigIntegerRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestInput.java index 2db99cbb..d3b98d58 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJByteRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestOutput.java index 5f740bde..b9554f30 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJByteRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestInput.java index 232265e9..5c023a27 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJDoubleRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestOutput.java index 62acf54d..2ec5c46d 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJDoubleRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestInput.java index 7157710f..bab44b4e 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestInput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJEnumerableRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Iterables.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestOutput.java index 2f676a8e..892f2f69 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestOutput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJEnumerableRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Iterables.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestInput.java index caaa12de..9a2a2ef1 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJFloatRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestOutput.java index e2c4fd0f..74ef4155 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJFloatRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestInput.java index 9c69c87c..5d5e7727 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJIntegerRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestOutput.java index 495cf185..12d53371 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJIntegerRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestInput.java index 7c3bcc4e..c6199487 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJLongRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestOutput.java index 81692bf1..69384e2a 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJLongRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestInput.java index 66ebdc0e..7c41571e 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestInput.java @@ -23,7 +23,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJMapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( ArrayList.class, HashMap.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestOutput.java index 413d8fbe..c4483415 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestOutput.java @@ -23,7 +23,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJMapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( ArrayList.class, HashMap.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestInput.java index 6114d861..3398b5ae 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJShortRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestOutput.java index 463bea8e..ad5a1eb0 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJShortRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(offset(0), withPercentage(0)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java index 3d6c1763..8c0d9278 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java @@ -13,7 +13,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Files.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java index 0804620b..c9d019b2 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Files.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestInput.java index 3dc64aea..a6fb1b2b 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestInput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( assertThatExceptionOfType(Throwable.class), assertThatIOException(), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestOutput.java index c00ed335..e4c70ca0 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestOutput.java @@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( assertThatExceptionOfType(Throwable.class), assertThatIOException(), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestInput.java index 7aa5b769..1f785293 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestInput.java @@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssortedRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( HashSet.class, Iterables.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestOutput.java index 6a76afe1..2fd9c408 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestOutput.java @@ -20,7 +20,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssortedRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( HashSet.class, Iterables.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestInput.java index 49eaa579..2d0aa622 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestInput.java @@ -8,7 +8,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(FixChoosers.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestOutput.java index 39aef891..d1f21fd0 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestOutput.java @@ -8,7 +8,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(FixChoosers.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java index 68f6f79b..369a84cb 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class CollectionRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Iterables.class, Lists.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java index 0ebaa40f..1f5380ec 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class CollectionRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Iterables.class, Lists.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java index 8fde9018..52ff1c3b 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ComparatorRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Arrays.class, Collections.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java index 9c27527d..7c3662bb 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ComparatorRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Arrays.class, Collections.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestInput.java index 5f8ab5a0..b7dbcc9c 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class DoubleStreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestOutput.java index c382f567..089cf2e4 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class DoubleStreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestInput.java index e887e5a0..d025e7d0 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestInput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class EqualityRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Objects.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestOutput.java index b3aa3024..793c24f3 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestOutput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class EqualityRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Objects.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java index 287e550a..6ad5befd 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java @@ -20,7 +20,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableListMultimapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Streams.class, flatteningToImmutableListMultimap(null, null), identity()); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java index cfed18e6..c4f5274e 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java @@ -20,7 +20,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableListMultimapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Streams.class, flatteningToImmutableListMultimap(null, null), identity()); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestInput.java index 8a8623f0..84882105 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestInput.java @@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableListRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Arrays.class, Collections.class, Comparator.class, Streams.class, naturalOrder()); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestOutput.java index 6a026f8c..b152693d 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestOutput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableListRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Arrays.class, Collections.class, Comparator.class, Streams.class, naturalOrder()); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java index 3db671a7..aab420c6 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Collections.class, Streams.class, identity()); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java index 1b135e32..e4bfabe7 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Collections.class, Streams.class, identity()); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestInput.java index efeeb2db..96231993 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestInput.java @@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableMultisetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestOutput.java index 297b3167..76af043a 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestOutput.java @@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableMultisetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestInput.java index 8ac65425..34e43bae 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestInput.java @@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSetMultimapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class, flatteningToImmutableSetMultimap(null, null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestOutput.java index 5f358443..60ac3cd9 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestOutput.java @@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSetMultimapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class, flatteningToImmutableSetMultimap(null, null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestInput.java index 9a457ff0..9512cdea 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestInput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Collections.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestOutput.java index 21e612a3..b081feee 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestOutput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Collections.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestInput.java index 45fef73d..3dc40717 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestInput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSortedMapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Stream.class, Streams.class, naturalOrder(), toImmutableSortedMap(null, null, null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestOutput.java index 9955c0c5..6a37cbf3 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestOutput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSortedMapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Stream.class, Streams.class, naturalOrder(), toImmutableSortedMap(null, null, null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestInput.java index 0906733c..36c0b35f 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestInput.java @@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSortedMultisetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestOutput.java index ffcba293..36fca66a 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestOutput.java @@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSortedMultisetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestInput.java index a1d8f80f..418eb069 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestInput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSortedSetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestOutput.java index 5fa58dbb..6e29d15c 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestOutput.java @@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ImmutableSortedSetRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Arrays.class, Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestInput.java index 6ff668b0..76ccd173 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class IntStreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestOutput.java index 23ab645e..8c42b111 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class IntStreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestInput.java index d1a68ad7..0c398251 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestInput.java @@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Assertions.class, assertDoesNotThrow(() -> null), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestOutput.java index c41d0246..9834155f 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestOutput.java @@ -21,7 +21,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Assertions.class, assertDoesNotThrow(() -> null), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestInput.java index 83e4bb6a..e42aceeb 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class LongStreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestOutput.java index 629028e7..d951371b 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class LongStreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestInput.java index 99b40dd7..d5a42d04 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestInput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MapEntryRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(AbstractMap.class, Maps.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestOutput.java index 39cfa9c2..c7937bb1 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapEntryRulesTestOutput.java @@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MapEntryRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(AbstractMap.class, Maps.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestInput.java index 707243ba..abb7eefb 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestInput.java @@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(HashMap.class, requireNonNullElse(null, null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestOutput.java index 9214fa6f..2127ddd8 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MapRulesTestOutput.java @@ -13,7 +13,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(HashMap.class, requireNonNullElse(null, null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestInput.java index 667bd220..85dedcc4 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MockitoRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(times(1)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestOutput.java index 292faf35..f24f8645 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MockitoRulesTestOutput.java @@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MockitoRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(times(1)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestInput.java index d11347fa..97efdc53 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestInput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MultimapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Multimaps.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestOutput.java index 417de18a..51b74d66 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/MultimapRulesTestOutput.java @@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class MultimapRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Multimaps.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestInput.java index 745f19bf..56254384 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestInput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class NullRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(MoreObjects.class, Optional.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestOutput.java index f5e15e0f..33384f5b 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/NullRulesTestOutput.java @@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class NullRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(MoreObjects.class, Optional.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestInput.java index 5dbe4d69..16c4d856 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestInput.java @@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class OptionalRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestOutput.java index e22d2006..a24fb5e8 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestOutput.java @@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class OptionalRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Streams.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestInput.java index 56a3a41e..337c9298 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestInput.java @@ -8,7 +8,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class PreconditionsRulesTest implements RefasterRuleCollectionTestCase { @Override @SuppressWarnings("RequireNonNull") - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(checkNotNull(null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestOutput.java index 53a045fd..1b95c234 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PreconditionsRulesTestOutput.java @@ -13,7 +13,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class PreconditionsRulesTest implements RefasterRuleCollectionTestCase { @Override @SuppressWarnings("RequireNonNull") - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(checkNotNull(null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestInput.java index c3b5d3d5..aefee758 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestInput.java @@ -6,7 +6,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class PrimitiveRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Ints.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestOutput.java index a9d675f0..9b229442 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/PrimitiveRulesTestOutput.java @@ -6,7 +6,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class PrimitiveRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Ints.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java index d63f48ba..3a15f612 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java @@ -29,7 +29,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ReactorRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( ArrayList.class, Collection.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java index b667cf81..67812db8 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java @@ -32,7 +32,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class ReactorRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( ArrayList.class, Collection.class, diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java index f11d0496..1ef30d1e 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestInput.java @@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class StreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Objects.class, Streams.class, not(null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java index 8c89199f..549df571 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StreamRulesTestOutput.java @@ -18,7 +18,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class StreamRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Objects.class, Streams.class, not(null)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestInput.java index 420411b2..e547a759 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestInput.java @@ -18,7 +18,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class StringRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Arrays.class, Joiner.class, Objects.class, Stream.class, Streams.class, joining(), UTF_8); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestOutput.java index f6379366..8cb371cc 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/StringRulesTestOutput.java @@ -21,7 +21,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class StringRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( Arrays.class, Joiner.class, Objects.class, Stream.class, Streams.class, joining(), UTF_8); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestInput.java index 465c3de6..cdfa045d 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestInput.java @@ -21,7 +21,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class TestNGToAssertJRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( (Runnable) () -> assertEquals(new byte[0], null), (Runnable) () -> assertEqualsNoOrder((Object[]) null, null), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestOutput.java index e2088c4d..bd43fb87 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TestNGToAssertJRulesTestOutput.java @@ -26,7 +26,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class TestNGToAssertJRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of( (Runnable) () -> assertEquals(new byte[0], null), (Runnable) () -> assertEqualsNoOrder((Object[]) null, null), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestInput.java index 6407a91a..64ee11fd 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestInput.java @@ -18,7 +18,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class TimeRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(ChronoUnit.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestOutput.java index 1f02b4f6..f0bc2c72 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/TimeRulesTestOutput.java @@ -18,7 +18,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class TimeRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(ChronoUnit.class); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestInput.java index 61a0cd2d..2bbb7e81 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestInput.java @@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class WebClientRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(fromValue(""), GET, HEAD, OPTIONS, PATCH, POST, PUT); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestOutput.java index fcdbf4c2..445d3ab5 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/WebClientRulesTestOutput.java @@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class WebClientRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(fromValue(""), GET, HEAD, OPTIONS, PATCH, POST, PUT); } diff --git a/list-sonarcloud-profile-modifications.sh b/list-sonarcloud-profile-modifications.sh new file mode 100755 index 00000000..1d4f6f08 --- /dev/null +++ b/list-sonarcloud-profile-modifications.sh @@ -0,0 +1,44 @@ +#!/usr/bin/env bash + +# Compares the `Picnic` SonarCloud quality profile for Java against the default +# `Sonar way` profile. While the web UI also provides such functionality, this +# script also compares the configuration parameters of each rule. +# +# This script uses `faq`, see https://github.com/jzelinskie/faq. + +set -e -u -o pipefail + +if [ -z "${SONAR_TOKEN}" ]; then + echo 'Environment variable `SONAR_TOKEN` is not set.' + exit 1 +fi + +export_profile() { + local profile="${1}" + + curl --fail --silent --user "${SONAR_TOKEN}:" \ + "https://sonarcloud.io/api/qualityprofiles/export?qualityProfile=${profile}&language=java&organization=picnic-technologies" +} + +tabulate() { + faq --raw-output ' + def enumerate_params: + if .parameters == "" then + [] + elif (.parameters.parameter | type) == "object" then + .parameters.parameter | [.key, .value] + else + .parameters.parameter[] | [.key, .value] + end; + + .profile.rules.rule + | map([.repositoryKey, .key, .priority] + enumerate_params) + | sort + | .[] + | @tsv + ' --output-format json +} + +vimdiff \ + <(export_profile 'Sonar%20way' | tabulate) \ + <(export_profile 'Picnic%20Public' | tabulate) diff --git a/pom.xml b/pom.xml index 1a2acd1c..5523482e 100644 --- a/pom.xml +++ b/pom.xml @@ -143,6 +143,57 @@ timestamp in support of reproducible builds. --> 2023-03-31T07:31:01Z UTF-8 + + **/tech/picnic/errorprone/refasterrules/*.java + + ${refaster-rules.path-pattern} + https://sonarcloud.io + + java-resource,refaster-rules-1,refaster-rules-2,refaster-rules-3,refaster-rules-4,refaster-rules-5,refaster-rules-6 + **/src/test/resources/**/*.java + java:* + + ${refaster-rules.path-pattern} + java:S1452 + + ${refaster-rules.path-pattern} + java:S1610 + + ${refaster-rules.path-pattern} + java:S1612 + + ${refaster-rules.path-pattern} + java:S2166 + + ${refaster-rules.path-pattern} + java:S3959 + + ${refaster-rules.path-pattern} + java:S5960 + picnic-technologies + + pom.xml,src/main + src/test @@ -1267,6 +1318,13 @@ org.jacoco jacoco-maven-plugin 0.8.9 + + + + ${refaster-rules.path-pattern} + + org.pitest diff --git a/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/CodeTransformers.java b/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/CodeTransformers.java index cda3004c..7830b3c1 100644 --- a/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/CodeTransformers.java +++ b/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/CodeTransformers.java @@ -72,11 +72,16 @@ public final class CodeTransformers { } int lastPathSeparator = resourceName.lastIndexOf('/'); - int beginIndex = lastPathSeparator < 0 ? 0 : lastPathSeparator + 1; + int beginIndex = lastPathSeparator < 0 ? 0 : (lastPathSeparator + 1); int endIndex = resourceName.length() - REFASTER_RULE_SUFFIX.length(); return Optional.of(resourceName.substring(beginIndex, endIndex)); } + @SuppressWarnings({ + "java:S1166" /* The caught exception's stack traces are not relevant. */, + "java:S2147" /* The `catch` clauses have distinct comments. */, + "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict" + }) private static Optional loadCodeTransformer(ResourceInfo resource) { try (InputStream in = resource.url().openStream(); ObjectInputStream ois = new ObjectInputStream(in)) { @@ -84,7 +89,13 @@ public final class CodeTransformers { CodeTransformer codeTransformer = (CodeTransformer) ois.readObject(); return Optional.of(codeTransformer); } catch (NoSuchElementException e) { - /* For some reason we can't load the resource. Skip it. */ + /* + * For some reason we can't load the resource; skip it. This issue has been observed when + * executing the code using Maven Surefire, in which case `ResourceInfo` may reference a path + * relative to the current working directory, even though the current working directory is not + */ + // XXX: This appears to be a bug in Guava's ClassPath implementation. Consider migrating to + // ClassGraph. // XXX: Should we log this? return Optional.empty(); } catch (ClassCastException e) { diff --git a/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Refaster.java b/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Refaster.java index 4cfbeb72..49730602 100644 --- a/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Refaster.java +++ b/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Refaster.java @@ -55,13 +55,14 @@ import java.util.stream.Stream; linkType = NONE, severity = SUGGESTION, tags = SIMPLIFICATION) +@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */) public final class Refaster extends BugChecker implements CompilationUnitTreeMatcher { /** Flag to pass a pattern that restricts which Refaster rules are loaded. */ public static final String INCLUDED_RULES_PATTERN_FLAG = "Refaster:NamePattern"; private static final long serialVersionUID = 1L; - @SuppressWarnings("serial" /* Concrete instance will be `Serializable`. */) + @SuppressWarnings({"java:S1948", "serial"} /* Concrete instance will be `Serializable`. */) private final CodeTransformer codeTransformer; /** Instantiates a default {@link Refaster} instance. */ @@ -123,7 +124,10 @@ public final class Refaster extends BugChecker implements CompilationUnitTreeMat for (Description description : byReplacementSize) { ImmutableRangeSet ranges = getReplacementRanges(description, endPositions); if (ranges.asRanges().stream().noneMatch(replacedSections::intersects)) { - /* This suggested fix does not overlap with any ("larger") replacement seen until now. Apply it. */ + /* + * This suggested fix does not overlap with any ("larger") replacement seen until now, so + * apply it. + */ state.reportMatch(augmentDescription(description, getSeverityOverride(state))); replacedSections.addAll(ranges); } diff --git a/refaster-runner/src/test/java/tech/picnic/errorprone/refaster/runner/RefasterTest.java b/refaster-runner/src/test/java/tech/picnic/errorprone/refaster/runner/RefasterTest.java index 11db1cd7..2fa0f548 100644 --- a/refaster-runner/src/test/java/tech/picnic/errorprone/refaster/runner/RefasterTest.java +++ b/refaster-runner/src/test/java/tech/picnic/errorprone/refaster/runner/RefasterTest.java @@ -161,23 +161,22 @@ final class RefasterTest { @ParameterizedTest void severityAssignment( ImmutableList arguments, ImmutableList expectedSeverities) { - assertThatThrownBy( - () -> - compilationHelper - .setArgs(arguments) - .addSourceLines( - "A.java", - "class A {", - " void m() {", - " boolean[] bs = {", - " \"foo\".toCharArray().length == 0,", - " \"bar\".toCharArray().length == 1,", - " \"baz\".toCharArray().length == 2,", - " \"qux\".toCharArray().length == 3", - " };", - " }", - "}") - .doTest()) + CompilationTestHelper compilationTestHelper = + compilationHelper + .setArgs(arguments) + .addSourceLines( + "A.java", + "class A {", + " void m() {", + " boolean[] bs = {", + " \"foo\".toCharArray().length == 0,", + " \"bar\".toCharArray().length == 1,", + " \"baz\".toCharArray().length == 2,", + " \"qux\".toCharArray().length == 3", + " };", + " }", + "}"); + assertThatThrownBy(compilationTestHelper::doTest) .isInstanceOf(AssertionError.class) .message() .satisfies( diff --git a/refaster-support/src/main/java/tech/picnic/errorprone/refaster/AnnotatedCompositeCodeTransformer.java b/refaster-support/src/main/java/tech/picnic/errorprone/refaster/AnnotatedCompositeCodeTransformer.java index ee2dccbf..6f865b1b 100644 --- a/refaster-support/src/main/java/tech/picnic/errorprone/refaster/AnnotatedCompositeCodeTransformer.java +++ b/refaster-support/src/main/java/tech/picnic/errorprone/refaster/AnnotatedCompositeCodeTransformer.java @@ -49,6 +49,7 @@ public abstract class AnnotatedCompositeCodeTransformer implements CodeTransform abstract ImmutableList transformers(); @Override + @SuppressWarnings("java:S3038" /* All AutoValue properties must be specified explicitly. */) public abstract ImmutableClassToInstanceMap annotations(); /** @@ -92,16 +93,17 @@ public abstract class AnnotatedCompositeCodeTransformer implements CodeTransform } private String getShortCheckName(String fullCheckName) { - if (packageName().isEmpty()) { + String packageName = packageName(); + if (packageName.isEmpty()) { return fullCheckName; } - String prefix = packageName() + '.'; + String prefix = packageName + '.'; checkState( fullCheckName.startsWith(prefix), "Refaster rule class '%s' is not located in package '%s'", fullCheckName, - packageName()); + packageName); return fullCheckName.substring(prefix.length()); } diff --git a/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/ThrowsCheckedException.java b/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/ThrowsCheckedException.java index 71989ea1..15d743e6 100644 --- a/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/ThrowsCheckedException.java +++ b/refaster-support/src/main/java/tech/picnic/errorprone/refaster/matchers/ThrowsCheckedException.java @@ -16,6 +16,7 @@ import java.util.Collection; * A matcher of functional interface expressions for which execution of the functional interface * method may throw a checked exception. */ +@SuppressWarnings("java:S2166" /* This type's name is suitable for a `Matcher`. */) public final class ThrowsCheckedException implements Matcher { private static final long serialVersionUID = 1L; @@ -48,7 +49,9 @@ public final class ThrowsCheckedException implements Matcher { try { return state.getTypes().findDescriptorType(type).getThrownTypes(); - } catch (FunctionDescriptorLookupError e) { + } catch ( + @SuppressWarnings("java:S1166" /* Not exceptional. */) + FunctionDescriptorLookupError e) { return ImmutableSet.of(); } } diff --git a/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollection.java b/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollection.java index 588077a1..8fd5803b 100644 --- a/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollection.java +++ b/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollection.java @@ -62,6 +62,7 @@ import tech.picnic.errorprone.refaster.runner.Refaster; // `@BeforeTemplate` method is covered by a test. Review how we can make sure that _all_ // `@BeforeTemplate` methods and `Refaster.anyOf` branches are covered. @BugPattern(summary = "Exercises a Refaster rule collection", severity = ERROR) +@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */) public final class RefasterRuleCollection extends BugChecker implements CompilationUnitTreeMatcher { private static final long serialVersionUID = 1L; private static final String RULE_COLLECTION_FLAG = "RefasterRuleCollection:RuleCollection"; @@ -159,13 +160,14 @@ public final class RefasterRuleCollection extends BugChecker implements Compilat SuggestedFix.prefixWith( typeDeclaration, String.format( - "/* ERROR: Class should be named `%s`. */\n", expectedClassName)))); + "/* ERROR: Class should be named `%s`. */%n", expectedClassName)))); } } else { state.reportMatch( describeMatch( typeDeclaration, - SuggestedFix.prefixWith(typeDeclaration, "/* ERROR: Unexpected token. */\n"))); + SuggestedFix.prefixWith( + typeDeclaration, String.format("/* ERROR: Unexpected token. */%n")))); } } } @@ -216,13 +218,13 @@ public final class RefasterRuleCollection extends BugChecker implements Compilat private void reportViolations( Tree tree, String message, ImmutableSet violations, VisitorState state) { - String violationEnumeration = String.join("\n* - ", violations); + String violationEnumeration = String.join(String.format("%n* - "), violations); String comment = - String.format("/*\n* ERROR: %s:\n* - %s\n*/\n", message, violationEnumeration); + String.format("/*%n* ERROR: %s:%n* - %s%n*/%n", message, violationEnumeration); SuggestedFix fixWithComment = tree instanceof MethodTree ? SuggestedFix.prefixWith(tree, comment) - : SuggestedFix.postfixWith(tree, '\n' + comment); + : SuggestedFix.postfixWith(tree, String.format("%n%s", comment)); state.reportMatch(describeMatch(tree, fixWithComment)); } @@ -295,7 +297,7 @@ public final class RefasterRuleCollection extends BugChecker implements Compilat describeMatch( tree, SuggestedFix.prefixWith( - tree, "/* ERROR: Method names should start with `test`. */\n"))); + tree, String.format("/* ERROR: Method names should start with `test`. */%n")))); } return Optional.empty(); diff --git a/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTestCase.java b/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTestCase.java index 37c3c0c5..4923b9c5 100644 --- a/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTestCase.java +++ b/refaster-test-support/src/main/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTestCase.java @@ -19,7 +19,7 @@ public interface RefasterRuleCollectionTestCase { * *Input.java} import statements are also required to be present in the associated {@code * *Output.java} file. */ - default ImmutableSet elidedTypesAndStaticImports() { + default ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(); } } diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestInput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestInput.java index 466d8f89..fb1bf0ce 100644 --- a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestInput.java +++ b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestInput.java @@ -5,7 +5,7 @@ import com.google.common.collect.ImmutableSet; /** Code to test the Refaster rules from {@link MethodWithoutPrefixRules}. */ final class MethodWithoutPrefixRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(); } diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestOutput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestOutput.java index 74d509e4..ccdded90 100644 --- a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestOutput.java +++ b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/MethodWithoutPrefixRulesTestOutput.java @@ -5,7 +5,7 @@ import com.google.common.collect.ImmutableSet; /** Code to test the Refaster rules from {@link MethodWithoutPrefixRules}. */ final class MethodWithoutPrefixRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(); } diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestInput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestInput.java index 8752bc0f..cf6d842c 100644 --- a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestInput.java +++ b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestInput.java @@ -8,7 +8,7 @@ import java.util.Set; /** Code to test the Refaster rules from {@link ValidRules}. */ final class ValidRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Strings.class); } diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestOutput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestOutput.java index 1822797c..45b31289 100644 --- a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestOutput.java +++ b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidRulesTestOutput.java @@ -10,7 +10,7 @@ import java.util.Set; /** Code to test the Refaster rules from {@link ValidRules}. */ final class ValidRulesTest implements RefasterRuleCollectionTestCase { @Override - public ImmutableSet elidedTypesAndStaticImports() { + public ImmutableSet elidedTypesAndStaticImports() { return ImmutableSet.of(Strings.class); }