diff --git a/src/main/java/org/openrewrite/java/migrate/AddMissingMethodImplementation.java b/src/main/java/org/openrewrite/java/migrate/AddMissingMethodImplementation.java index 74b0dfb9e5..9700bded13 100644 --- a/src/main/java/org/openrewrite/java/migrate/AddMissingMethodImplementation.java +++ b/src/main/java/org/openrewrite/java/migrate/AddMissingMethodImplementation.java @@ -81,7 +81,7 @@ public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration cs, Execution } // If the class already has method, don't make any changes to it. if (classDecl.getBody().getStatements().stream() - .filter(statement -> statement instanceof J.MethodDeclaration) + .filter(J.MethodDeclaration.class::isInstance) .map(J.MethodDeclaration.class::cast) .anyMatch(methodDeclaration -> methodMatcher.matches(methodDeclaration, classDecl))) { return classDecl; diff --git a/src/main/java/org/openrewrite/java/migrate/BeanDiscovery.java b/src/main/java/org/openrewrite/java/migrate/BeanDiscovery.java index b80f526eb5..a4453fd762 100644 --- a/src/main/java/org/openrewrite/java/migrate/BeanDiscovery.java +++ b/src/main/java/org/openrewrite/java/migrate/BeanDiscovery.java @@ -61,7 +61,7 @@ public Xml visitTag(Xml.Tag tag, ExecutionContext ctx) { boolean hasBeanDiscoveryMode = false; String idealVersion = null; for (Xml.Attribute attribute : t.getAttributes()) { - if (attribute.getKeyAsString().equals("bean-discovery-mode")) { + if ("bean-discovery-mode".equals(attribute.getKeyAsString())) { hasBeanDiscoveryMode = true; } else if (attribute.getKeyAsString().endsWith("schemaLocation")) { String schemaLocation = attribute.getValueAsString(); diff --git a/src/main/java/org/openrewrite/java/migrate/CastArraysAsListToList.java b/src/main/java/org/openrewrite/java/migrate/CastArraysAsListToList.java index dd6872bfeb..f07719c8d3 100644 --- a/src/main/java/org/openrewrite/java/migrate/CastArraysAsListToList.java +++ b/src/main/java/org/openrewrite/java/migrate/CastArraysAsListToList.java @@ -75,7 +75,7 @@ public J visitTypeCast(J.TypeCast typeCast, ExecutionContext ctx) { String fullyQualifiedName = ((JavaType.FullyQualified) elementType).getFullyQualifiedName(); J.ArrayType castType = (J.ArrayType) typeCast.getClazz().getTree(); - if (fullyQualifiedName.equals("java.lang.Object") && !(castType.getElementType() instanceof J.ArrayType)) { + if ("java.lang.Object".equals(fullyQualifiedName) && !(castType.getElementType() instanceof J.ArrayType)) { // we don't need to fix this case because toArray() does return Object[] type return typeCast; } diff --git a/src/main/java/org/openrewrite/java/migrate/JpaCacheProperties.java b/src/main/java/org/openrewrite/java/migrate/JpaCacheProperties.java index 673d3a3aaf..9735913676 100644 --- a/src/main/java/org/openrewrite/java/migrate/JpaCacheProperties.java +++ b/src/main/java/org/openrewrite/java/migrate/JpaCacheProperties.java @@ -71,10 +71,10 @@ class SharedDataHolder { // both shared-cache-mode and javax.persistence.sharedCache.mode are present // None of the properties/elements are present public boolean shouldFlag() { - return (openJPACacheProperty != null || + return openJPACacheProperty != null || ((sharedCacheModeElement != null && sharedCacheModeElementUnspecified) || (sharedCacheModeProperty != null && sharedCacheModePropertyUnspecified)) || (sharedCacheModeElement != null && sharedCacheModeProperty != null) || - (sharedCacheModeElement == null && sharedCacheModeProperty == null && eclipselinkCacheProperty == null)); + (sharedCacheModeElement == null && sharedCacheModeProperty == null && eclipselinkCacheProperty == null); } } diff --git a/src/main/java/org/openrewrite/java/migrate/ReplaceAWTGetPeerMethod.java b/src/main/java/org/openrewrite/java/migrate/ReplaceAWTGetPeerMethod.java index 8e67d5785a..0f8c231a23 100644 --- a/src/main/java/org/openrewrite/java/migrate/ReplaceAWTGetPeerMethod.java +++ b/src/main/java/org/openrewrite/java/migrate/ReplaceAWTGetPeerMethod.java @@ -109,7 +109,7 @@ public J visitInstanceOf(J.InstanceOf instOf, ExecutionContext ctx) { J.InstanceOf instanceOfVar = (J.InstanceOf) super.visitInstanceOf(instOf, ctx); if (instanceOfVar.getExpression() instanceof J.MethodInvocation) { - J.MethodInvocation mi = ((J.MethodInvocation) instanceOfVar.getExpression()); + J.MethodInvocation mi = (J.MethodInvocation) instanceOfVar.getExpression(); if (methodMatcherGetPeer.matches(mi) && TypeUtils.isAssignableTo(lightweightPeerFQCN, ((TypedTree) instanceOfVar.getClazz()).getType())) { mi = (J.MethodInvocation) new ChangeMethodName(getPeerMethodPattern, "isLightweight", true, null) .getVisitor().visit(mi, ctx); diff --git a/src/main/java/org/openrewrite/java/migrate/UseJavaUtilBase64.java b/src/main/java/org/openrewrite/java/migrate/UseJavaUtilBase64.java index 7f56b6633b..d462670132 100644 --- a/src/main/java/org/openrewrite/java/migrate/UseJavaUtilBase64.java +++ b/src/main/java/org/openrewrite/java/migrate/UseJavaUtilBase64.java @@ -129,7 +129,7 @@ public J visitNewClass(J.NewClass newClass, ExecutionContext ctx) { // noinspection Convert2MethodRef JavaTemplate.Builder encoderTemplate = useMimeCoder ? Semantics.expression(this, "getMimeEncoder", () -> Base64.getMimeEncoder()) : - Semantics.expression(this, "getEncoder", () -> Base64.getEncoder()); + Semantics.expression(this, "getEncoder", Base64::getEncoder); return encoderTemplate .build() .apply(updateCursor(c), c.getCoordinates().replace()); diff --git a/src/main/java/org/openrewrite/java/migrate/guava/AbstractNoGuavaImmutableOf.java b/src/main/java/org/openrewrite/java/migrate/guava/AbstractNoGuavaImmutableOf.java index fc3b742a59..8b9b48179e 100644 --- a/src/main/java/org/openrewrite/java/migrate/guava/AbstractNoGuavaImmutableOf.java +++ b/src/main/java/org/openrewrite/java/migrate/guava/AbstractNoGuavaImmutableOf.java @@ -79,12 +79,12 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { TreeVisitor check = Preconditions.and(new UsesJavaVersion<>(9), new UsesType<>(guavaType, false)); - final MethodMatcher IMMUTABLE_MATCHER = new MethodMatcher(guavaType + " of(..)"); + final MethodMatcher immutableMatcher = new MethodMatcher(guavaType + " of(..)"); return Preconditions.check(check, new JavaVisitor() { @Override public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { J.MethodInvocation mi = (J.MethodInvocation) super.visitMethodInvocation(method, ctx); - if (!IMMUTABLE_MATCHER.matches(mi) || !isParentTypeDownCast(mi)) { + if (!immutableMatcher.matches(mi) || !isParentTypeDownCast(mi)) { return mi; } maybeRemoveImport(guavaType); @@ -198,7 +198,7 @@ private boolean isParentTypeDownCast(MethodCall immutableMethod) { int index = 0; if (c.getConstructorType() != null) { for (Expression argument : c.getArguments()) { - if (IMMUTABLE_MATCHER.matches(argument)) { + if (immutableMatcher.matches(argument)) { break; } index++; diff --git a/src/main/java/org/openrewrite/java/migrate/guava/PreferJavaStringJoinVisitor.java b/src/main/java/org/openrewrite/java/migrate/guava/PreferJavaStringJoinVisitor.java index b50d9140a1..33af622d64 100644 --- a/src/main/java/org/openrewrite/java/migrate/guava/PreferJavaStringJoinVisitor.java +++ b/src/main/java/org/openrewrite/java/migrate/guava/PreferJavaStringJoinVisitor.java @@ -61,7 +61,7 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu maybeRemoveImport("com.google.common.base.Joiner"); - return JavaTemplate.apply( + return JavaTemplate.apply( "String.join(#{any(java.lang.CharSequence)}", getCursor(), mi.getCoordinates().replace(), diff --git a/src/main/java/org/openrewrite/java/migrate/javax/AddDefaultConstructorToEntityClass.java b/src/main/java/org/openrewrite/java/migrate/javax/AddDefaultConstructorToEntityClass.java index b00c04043a..a4b641eb9a 100644 --- a/src/main/java/org/openrewrite/java/migrate/javax/AddDefaultConstructorToEntityClass.java +++ b/src/main/java/org/openrewrite/java/migrate/javax/AddDefaultConstructorToEntityClass.java @@ -54,7 +54,7 @@ public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, Ex // Exit if class already has default no-arg constructor if (classDecl.getBody().getStatements().stream() - .filter(statement -> statement instanceof J.MethodDeclaration) + .filter(J.MethodDeclaration.class::isInstance) .map(J.MethodDeclaration.class::cast) .filter(J.MethodDeclaration::isConstructor) .anyMatch(constructor -> constructor.getParameters().get(0) instanceof J.Empty)) { diff --git a/src/main/java/org/openrewrite/java/migrate/javax/AnnotateTypesVisitor.java b/src/main/java/org/openrewrite/java/migrate/javax/AnnotateTypesVisitor.java index fae08dcbfd..891b611167 100644 --- a/src/main/java/org/openrewrite/java/migrate/javax/AnnotateTypesVisitor.java +++ b/src/main/java/org/openrewrite/java/migrate/javax/AnnotateTypesVisitor.java @@ -35,7 +35,7 @@ public AnnotateTypesVisitor(String annotationToBeAdded) { String className = split[split.length - 1]; String packageName = this.annotationToBeAdded.substring(0, this.annotationToBeAdded.lastIndexOf(".")); this.annotationMatcher = new AnnotationMatcher("@" + this.annotationToBeAdded); - String interfaceAsString = String.format("package %s\npublic @interface %s {}", packageName, className); + String interfaceAsString = String.format("package %s%npublic @interface %s {}", packageName, className); //noinspection LanguageMismatch this.template = JavaTemplate.builder("@" + className) .imports(this.annotationToBeAdded) diff --git a/src/main/java/org/openrewrite/java/migrate/javax/RemoveTemporalAnnotation.java b/src/main/java/org/openrewrite/java/migrate/javax/RemoveTemporalAnnotation.java index 16fef3e665..0c039248cc 100644 --- a/src/main/java/org/openrewrite/java/migrate/javax/RemoveTemporalAnnotation.java +++ b/src/main/java/org/openrewrite/java/migrate/javax/RemoveTemporalAnnotation.java @@ -66,20 +66,20 @@ public String getDescription() { @Override public TreeVisitor getVisitor() { Pattern temporalPattern = Pattern.compile(".*TemporalType\\.(TIMESTAMP|DATE|TIME)"); - final String JAVA_SQL_TIMESTAMP = "java.sql.Timestamp"; - final String JAVA_SQL_TIME = "java.sql.Time"; - final String JAVA_SQL_DATE = "java.sql.Date"; + final String javaSqlTimestamp = "java.sql.Timestamp"; + final String javaSqlTime = "java.sql.Time"; + final String javaSqlDate = "java.sql.Date"; Set javaSqlDateTimeTypes = Stream.of( - JAVA_SQL_TIMESTAMP, - JAVA_SQL_TIME, - JAVA_SQL_DATE + javaSqlTimestamp, + javaSqlTime, + javaSqlDate ).collect(Collectors.toSet()); // Combinations of TemporalType and java.sql classes that do not need removal Map doNotRemove = Stream.of(new String[][]{ - {"DATE", JAVA_SQL_TIMESTAMP}, - {"TIME", JAVA_SQL_TIMESTAMP}, - {"TIMESTAMP", JAVA_SQL_DATE} + {"DATE", javaSqlTimestamp}, + {"TIME", javaSqlTimestamp}, + {"TIMESTAMP", javaSqlDate} }).collect(Collectors.toMap(data -> data[0], data -> data[1])); // TODO: maybe future recipe to handle these by creating a converter class // https://wiki.eclipse.org/EclipseLink/Examples/JPA/Migration/OpenJPA/Mappings#.40Temporal_on_java.sql.Date.2FTime.2FTimestamp_fields @@ -88,9 +88,9 @@ public TreeVisitor getVisitor() { Preconditions.and( new UsesType<>("javax.persistence.Temporal", true), Preconditions.or( - new UsesType<>(JAVA_SQL_DATE, true), - new UsesType<>(JAVA_SQL_TIME, true), - new UsesType<>(JAVA_SQL_TIMESTAMP, true) + new UsesType<>(javaSqlDate, true), + new UsesType<>(javaSqlTime, true), + new UsesType<>(javaSqlTimestamp, true) ) ), new JavaIsoVisitor() { diff --git a/src/main/java/org/openrewrite/java/migrate/joda/JodaTimeVisitor.java b/src/main/java/org/openrewrite/java/migrate/joda/JodaTimeVisitor.java index e5a863f088..a8116102d2 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/JodaTimeVisitor.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/JodaTimeVisitor.java @@ -182,7 +182,7 @@ public Javadoc visitReference(Javadoc.Reference reference, ExecutionContext ctx) @Override public @NonNull J visitFieldAccess(@NonNull J.FieldAccess fieldAccess, @NonNull ExecutionContext ctx) { J.FieldAccess f = (J.FieldAccess) super.visitFieldAccess(fieldAccess, ctx); - if (TypeUtils.isOfClassType(f.getType(), JODA_DATE_TIME_ZONE) && f.getSimpleName().equals("UTC")) { + if (TypeUtils.isOfClassType(f.getType(), JODA_DATE_TIME_ZONE) && "UTC".equals(f.getSimpleName())) { return JavaTemplate.builder("ZoneOffset.UTC") .imports(JAVA_ZONE_OFFSET) .build() @@ -203,7 +203,7 @@ public Javadoc visitReference(Javadoc.Reference reference, ExecutionContext ctx) } } - JavaType.FullyQualified jodaType = ((JavaType.Class) ident.getType()); + JavaType.FullyQualified jodaType = (JavaType.Class) ident.getType(); JavaType.FullyQualified fqType = TimeClassMap.getJavaTimeType(jodaType.getFullyQualifiedName()); if (fqType == null) { return ident; diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDateTimeTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDateTimeTemplates.java index f561541776..1e23d269d1 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDateTimeTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDateTimeTemplates.java @@ -51,19 +51,19 @@ public class AbstractDateTimeTemplates implements Templates { private final JavaTemplate toStringTemplate = JavaTemplate.builder("#{any(" + JAVA_DATE_TIME + ")}.toString()").build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(getDayOfMonth, getDayOfMonthTemplate)); - add(new MethodTemplate(getDayOfWeek, getDayOfWeekTemplate)); - add(new MethodTemplate(getHourOfDay, getHourOfDayTemplate)); - add(new MethodTemplate(getMillisOfSecond, getMillisOfSecondTemplate)); - add(new MethodTemplate(getMinuteOfDay, getMinuteOfDayTemplate)); - add(new MethodTemplate(getMinuteOfHour, getMinuteOfHourTemplate)); - add(new MethodTemplate(getMonthOfYear, getMonthOfYearTemplate)); - add(new MethodTemplate(getSecondOfDay, getSecondOfDayTemplate)); - add(new MethodTemplate(getSecondOfMinute, getSecondOfMinuteTemplate)); - add(new MethodTemplate(getWeekOfWeekyear, getWeekOfWeekyearTemplate)); - add(new MethodTemplate(toString, toStringTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(getDayOfMonth, getDayOfMonthTemplate)); + templates.add(new MethodTemplate(getDayOfWeek, getDayOfWeekTemplate)); + templates.add(new MethodTemplate(getHourOfDay, getHourOfDayTemplate)); + templates.add(new MethodTemplate(getMillisOfSecond, getMillisOfSecondTemplate)); + templates.add(new MethodTemplate(getMinuteOfDay, getMinuteOfDayTemplate)); + templates.add(new MethodTemplate(getMinuteOfHour, getMinuteOfHourTemplate)); + templates.add(new MethodTemplate(getMonthOfYear, getMonthOfYearTemplate)); + templates.add(new MethodTemplate(getSecondOfDay, getSecondOfDayTemplate)); + templates.add(new MethodTemplate(getSecondOfMinute, getSecondOfMinuteTemplate)); + templates.add(new MethodTemplate(getWeekOfWeekyear, getWeekOfWeekyearTemplate)); + templates.add(new MethodTemplate(toString, toStringTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDurationTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDurationTemplates.java index eb1422b678..77d980016f 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDurationTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractDurationTemplates.java @@ -33,10 +33,10 @@ public class AbstractDurationTemplates implements Templates { private final JavaTemplate toPeriodTemplate = JavaTemplate.builder("#{any(" + JAVA_DURATION + ")}.toPeriod()").build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(isLongerThan, isLongerThanTemplate)); - add(new MethodTemplate(toPeriod, toPeriodTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(isLongerThan, isLongerThanTemplate)); + templates.add(new MethodTemplate(toPeriod, toPeriodTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractInstantTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractInstantTemplates.java index 77a29c3d71..98f17ddd61 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractInstantTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractInstantTemplates.java @@ -71,27 +71,27 @@ public class AbstractInstantTemplates implements Templates { private final JavaTemplate toStringFormatterTemplate = JavaTemplate.builder("#{any(" + JAVA_DATE_TIME + ")}.format(#{any(" + JAVA_TIME_FORMATTER + ")})").build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(equals, equalsTemplate)); - add(new MethodTemplate(getZone, getZoneTemplate)); - add(new MethodTemplate(isAfterLong, isAfterLongTemplate)); - add(new MethodTemplate(isAfterLong, isAfterLongTemplateWithInstant)); - add(new MethodTemplate(isAfter, isAfterTemplate)); - add(new MethodTemplate(isAfter, isAfterTemplateWithInstant)); - add(new MethodTemplate(isBeforeLong, isBeforeLongTemplate)); - add(new MethodTemplate(isBeforeLong, isBeforeLongTemplateWithInstant)); - add(new MethodTemplate(isBefore, isBeforTemplate)); - add(new MethodTemplate(isBefore, isBeforeTemplateWithInstant)); - add(new MethodTemplate(isBeforeNow, isBeforeNowTemplate)); - add(new MethodTemplate(isEqualLong, isEqualLongTemplate)); - add(new MethodTemplate(isEqualReadableInstant, isEqualReadableInstantTemplate)); - add(new MethodTemplate(toDate, toDateTemplate)); - add(new MethodTemplate(toInstant, toInstantTemplate)); - add(new MethodTemplate(toString, toStringTemplate)); - add(new MethodTemplate(toStringFormatter, toStringFormatterTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(equals, equalsTemplate)); + templates.add(new MethodTemplate(getZone, getZoneTemplate)); + templates.add(new MethodTemplate(isAfterLong, isAfterLongTemplate)); + templates.add(new MethodTemplate(isAfterLong, isAfterLongTemplateWithInstant)); + templates.add(new MethodTemplate(isAfter, isAfterTemplate)); + templates.add(new MethodTemplate(isAfter, isAfterTemplateWithInstant)); + templates.add(new MethodTemplate(isBeforeLong, isBeforeLongTemplate)); + templates.add(new MethodTemplate(isBeforeLong, isBeforeLongTemplateWithInstant)); + templates.add(new MethodTemplate(isBefore, isBeforTemplate)); + templates.add(new MethodTemplate(isBefore, isBeforeTemplateWithInstant)); + templates.add(new MethodTemplate(isBeforeNow, isBeforeNowTemplate)); + templates.add(new MethodTemplate(isEqualLong, isEqualLongTemplate)); + templates.add(new MethodTemplate(isEqualReadableInstant, isEqualReadableInstantTemplate)); + templates.add(new MethodTemplate(toDate, toDateTemplate)); + templates.add(new MethodTemplate(toInstant, toInstantTemplate)); + templates.add(new MethodTemplate(toString, toStringTemplate)); + templates.add(new MethodTemplate(toStringFormatter, toStringFormatterTemplate)); + } @Override public boolean matchesMethodCall(MethodCall method, MethodTemplate template) { diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractIntervalTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractIntervalTemplates.java index 9fe69cdf14..79af125904 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractIntervalTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/AbstractIntervalTemplates.java @@ -52,13 +52,13 @@ public class AbstractIntervalTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(getStart, getStartTemplate)); - add(new MethodTemplate(getEnd, getEndTemplate)); - add(new MethodTemplate(toDuration, toDurationTemplate)); - add(new MethodTemplate(toDurationMillis, toDurationMillisTemplate)); - add(new MethodTemplate(contains, containsTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(getStart, getStartTemplate)); + templates.add(new MethodTemplate(getEnd, getEndTemplate)); + templates.add(new MethodTemplate(toDuration, toDurationTemplate)); + templates.add(new MethodTemplate(toDurationMillis, toDurationMillisTemplate)); + templates.add(new MethodTemplate(contains, containsTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/AllTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/AllTemplates.java index 3d79830153..d2741905bc 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/AllTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/AllTemplates.java @@ -44,27 +44,27 @@ public class AllTemplates { private static final MethodMatcher ANY_ABSTRACT_INTERVAL = new MethodMatcher(JODA_ABSTRACT_INTERVAL + " *(..)"); private static final MethodMatcher ANY_BASE_INTERVAL = new MethodMatcher(JODA_BASE_INTERVAL + " *(..)"); - private static List templates = new ArrayList() { - { - add(new MatcherAndTemplates(ANY_ABSTRACT_DATE_TIME, new AbstractDateTimeTemplates())); - add(new MatcherAndTemplates(ANY_ABSTRACT_DURATION, new AbstractDurationTemplates())); - add(new MatcherAndTemplates(ANY_ABSTRACT_INSTANT, new AbstractInstantTemplates())); - add(new MatcherAndTemplates(ANY_BASE_DATETIME, new BaseDateTime())); - add(new MatcherAndTemplates(ANY_TIME_FORMAT, new DateTimeFormatTemplates())); - add(new MatcherAndTemplates(ANY_TIME_FORMATTER, new DateTimeFormatterTemplates())); - add(new MatcherAndTemplates(ANY_NEW_DATE_TIME, new DateTimeTemplates())); - add(new MatcherAndTemplates(ANY_DATE_TIME, new DateTimeTemplates())); - add(new MatcherAndTemplates(ANY_NEW_DURATION, new DurationTemplates())); - add(new MatcherAndTemplates(ANY_DURATION, new DurationTemplates())); - add(new MatcherAndTemplates(ANY_BASE_DURATION, new BaseDurationTemplates())); - add(new MatcherAndTemplates(ANY_DATE_TIMEZONE, new TimeZoneTemplates())); - add(new MatcherAndTemplates(ANY_INSTANT, new InstantTemplates())); - add(new MatcherAndTemplates(ANY_NEW_INSTANT, new InstantTemplates())); - add(new MatcherAndTemplates(ANY_NEW_INTERVAL, new IntervalTemplates())); - add(new MatcherAndTemplates(ANY_ABSTRACT_INTERVAL, new AbstractIntervalTemplates())); - add(new MatcherAndTemplates(ANY_BASE_INTERVAL, new BaseIntervalTemplates())); - } - }; + private static final List templates; + static { + templates = new ArrayList<>(); + templates.add(new MatcherAndTemplates(ANY_ABSTRACT_DATE_TIME, new AbstractDateTimeTemplates())); + templates.add(new MatcherAndTemplates(ANY_ABSTRACT_DURATION, new AbstractDurationTemplates())); + templates.add(new MatcherAndTemplates(ANY_ABSTRACT_INSTANT, new AbstractInstantTemplates())); + templates.add(new MatcherAndTemplates(ANY_BASE_DATETIME, new BaseDateTime())); + templates.add(new MatcherAndTemplates(ANY_TIME_FORMAT, new DateTimeFormatTemplates())); + templates.add(new MatcherAndTemplates(ANY_TIME_FORMATTER, new DateTimeFormatterTemplates())); + templates.add(new MatcherAndTemplates(ANY_NEW_DATE_TIME, new DateTimeTemplates())); + templates.add(new MatcherAndTemplates(ANY_DATE_TIME, new DateTimeTemplates())); + templates.add(new MatcherAndTemplates(ANY_NEW_DURATION, new DurationTemplates())); + templates.add(new MatcherAndTemplates(ANY_DURATION, new DurationTemplates())); + templates.add(new MatcherAndTemplates(ANY_BASE_DURATION, new BaseDurationTemplates())); + templates.add(new MatcherAndTemplates(ANY_DATE_TIMEZONE, new TimeZoneTemplates())); + templates.add(new MatcherAndTemplates(ANY_INSTANT, new InstantTemplates())); + templates.add(new MatcherAndTemplates(ANY_NEW_INSTANT, new InstantTemplates())); + templates.add(new MatcherAndTemplates(ANY_NEW_INTERVAL, new IntervalTemplates())); + templates.add(new MatcherAndTemplates(ANY_ABSTRACT_INTERVAL, new AbstractIntervalTemplates())); + templates.add(new MatcherAndTemplates(ANY_BASE_INTERVAL, new BaseIntervalTemplates())); + } public static MethodTemplate getTemplate(MethodCall method) { return getTemplateGroup(method).flatMap(templates -> templates.getTemplates().stream() diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDateTime.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDateTime.java index 1e1dc299b6..deb87a0240 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDateTime.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDateTime.java @@ -31,9 +31,9 @@ public class BaseDateTime implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(getMillis, getMillisTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(getMillis, getMillisTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDurationTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDurationTemplates.java index aa23fa6385..71c522d989 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDurationTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseDurationTemplates.java @@ -31,9 +31,9 @@ public class BaseDurationTemplates implements Templates { private final JavaTemplate getMillisTemplate = JavaTemplate.builder("#{any(" + JAVA_DURATION + ")}.toMillis()").build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(getMillis, getMillisTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(getMillis, getMillisTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseIntervalTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseIntervalTemplates.java index afe6a70e35..e44e9a4bfe 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseIntervalTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/BaseIntervalTemplates.java @@ -38,10 +38,10 @@ public class BaseIntervalTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(getStartMillis, getStartMillisTemplate)); - add(new MethodTemplate(getEndMillis, getEndMillisTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(getStartMillis, getStartMillisTemplate)); + templates.add(new MethodTemplate(getEndMillis, getEndMillisTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatTemplates.java index 0389d50ed3..116535fae1 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatTemplates.java @@ -80,21 +80,21 @@ public class DateTimeFormatTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(forPattern, ofPatternTemplate)); - add(new MethodTemplate(shortDate, shortDateTemplate)); - add(new MethodTemplate(mediumDate, mediumDateTemplate)); - add(new MethodTemplate(longDate, longDateTemplate)); - add(new MethodTemplate(fullDate, fullDateTemplate)); - add(new MethodTemplate(shortTime, shortTimeTemplate)); - add(new MethodTemplate(mediumTime, mediumTimeTemplate)); - add(new MethodTemplate(longTime, longTimeTemplate)); - add(new MethodTemplate(fullTime, fullTimeTemplate)); - add(new MethodTemplate(shortDateTime, shortDateTimeTemplate)); - add(new MethodTemplate(mediumDateTime, mediumDateTimeTemplate)); - add(new MethodTemplate(longDateTime, longDateTimeTemplate)); - add(new MethodTemplate(fullDateTime, fullDateTimeTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(forPattern, ofPatternTemplate)); + templates.add(new MethodTemplate(shortDate, shortDateTemplate)); + templates.add(new MethodTemplate(mediumDate, mediumDateTemplate)); + templates.add(new MethodTemplate(longDate, longDateTemplate)); + templates.add(new MethodTemplate(fullDate, fullDateTemplate)); + templates.add(new MethodTemplate(shortTime, shortTimeTemplate)); + templates.add(new MethodTemplate(mediumTime, mediumTimeTemplate)); + templates.add(new MethodTemplate(longTime, longTimeTemplate)); + templates.add(new MethodTemplate(fullTime, fullTimeTemplate)); + templates.add(new MethodTemplate(shortDateTime, shortDateTimeTemplate)); + templates.add(new MethodTemplate(mediumDateTime, mediumDateTimeTemplate)); + templates.add(new MethodTemplate(longDateTime, longDateTimeTemplate)); + templates.add(new MethodTemplate(fullDateTime, fullDateTimeTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatterTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatterTemplates.java index 711ec20166..d0626a3bea 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatterTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeFormatterTemplates.java @@ -47,26 +47,26 @@ public class DateTimeFormatterTemplates implements Templates { .imports(JAVA_ZONE_OFFSET).build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(parseDateTime, parseDateTimeTemplate, m -> { - J.MethodInvocation mi = (J.MethodInvocation) m; - return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; - })); - add(new MethodTemplate(parseMillis, parseMillisTemplate, m -> { - J.MethodInvocation mi = (J.MethodInvocation) m; - return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; - })); - add(new MethodTemplate(printLong, printLongTemplate, m -> { - J.MethodInvocation mi = (J.MethodInvocation) m; - return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; - })); - add(new MethodTemplate(printDateTime, printDateTimeTemplate, m -> { - J.MethodInvocation mi = (J.MethodInvocation) m; - return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; - })); - add(new MethodTemplate(withZone, withZoneTemplate)); - add(new MethodTemplate(withZoneUTC, withZoneUTCTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(parseDateTime, parseDateTimeTemplate, m -> { + J.MethodInvocation mi = (J.MethodInvocation) m; + return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; + })); + templates.add(new MethodTemplate(parseMillis, parseMillisTemplate, m -> { + J.MethodInvocation mi = (J.MethodInvocation) m; + return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; + })); + templates.add(new MethodTemplate(printLong, printLongTemplate, m -> { + J.MethodInvocation mi = (J.MethodInvocation) m; + return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; + })); + templates.add(new MethodTemplate(printDateTime, printDateTimeTemplate, m -> { + J.MethodInvocation mi = (J.MethodInvocation) m; + return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; + })); + templates.add(new MethodTemplate(withZone, withZoneTemplate)); + templates.add(new MethodTemplate(withZoneUTC, withZoneUTCTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeTemplates.java index 85ea7b451f..58c42249d7 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/DateTimeTemplates.java @@ -271,76 +271,76 @@ public class DateTimeTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(newDateTime, dateTimeTemplate)); - add(new MethodTemplate(newDateTimeWithZone, dateTimeWithZoneTemplate)); - add(new MethodTemplate(newDateTimeWithEpoch, dateTimeWithEpochTemplate)); - add(new MethodTemplate(newDateTimeWithEpochAndZone, dateTimeWithEpochAndZoneTemplate)); - add(new MethodTemplate(newDateTimeWithMin, dateTimeWithMinTemplate)); - add(new MethodTemplate(newDateTimeWithMinAndZone, dateTimeWithMinAndZoneTemplate)); - add(new MethodTemplate(newDateTimeWithSec, dateTimeWithSecTemplate)); - add(new MethodTemplate(newDateTimeWithSecAndZone, dateTimeWithSecAndZoneTemplate)); - add(new MethodTemplate(newDateTimeWithMillis, dateTimeWithMillisTemplate)); - add(new MethodTemplate(newDateTimeWithMillisAndZone, dateTimeWithMillisAndZoneTemplate)); - add(new MethodTemplate(dateTimeNow, dateTimeTemplate)); - add(new MethodTemplate(dateTimeNowWithZone, dateTimeWithZoneTemplate)); - add(new MethodTemplate(dateTimeParse, dateTimeParseTemplate)); - add(new MethodTemplate(dateTimeParseWithFormatter, dateTimeParseWithFormatterTemplate)); - add(new MethodTemplate(toDateTime, toDateTimeTemplate)); - add(new MethodTemplate(toDateTimeWithZone, withZoneTemplate)); - add(new MethodTemplate(withMillis, withMillisTemplate, m -> { - J.MethodInvocation mi = (J.MethodInvocation) m; - return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; - })); - add(new MethodTemplate(withZone, withZoneTemplate)); - add(new MethodTemplate(withZoneRetainFields, withZoneRetainFieldsTemplate)); - add(new MethodTemplate(withEarlierOffsetAtOverlap, withEarlierOffsetAtOverlapTemplate)); - add(new MethodTemplate(withLaterOffsetAtOverlap, withLaterOffsetAtOverlapTemplate)); - add(new MethodTemplate(withDate, withDateTemplate)); - add(new MethodTemplate(withDateLocalDate, withTemporalAdjusterTemplate)); - add(new MethodTemplate(withTime, withTimeTemplate)); - add(new MethodTemplate(withTimeLocalTime, withTemporalAdjusterTemplate)); - add(new MethodTemplate(withTimeAtStartOfDay, withTimeAtStartOfDayTemplate, m -> { - J.MethodInvocation mi = (J.MethodInvocation) m; - return new Expression[]{mi.getSelect(), mi.getSelect()}; - })); - add(new MethodTemplate(withDurationAdded, withDurationAddedTemplate)); - add(new MethodTemplate(plusLong, plusMillisTemplate)); - add(new MethodTemplate(plusReadableDuration, plusReadableDurationTemplate)); - add(new MethodTemplate(plusYears, plusYearsTemplate)); - add(new MethodTemplate(plusMonths, plusMonthsTemplate)); - add(new MethodTemplate(plusWeeks, plusWeeksTemplate)); - add(new MethodTemplate(plusDays, plusDaysTemplate)); - add(new MethodTemplate(plusHours, plusHoursTemplate)); - add(new MethodTemplate(plusMinutes, plusMinutesTemplate)); - add(new MethodTemplate(plusSeconds, plusSecondsTemplate)); - add(new MethodTemplate(plusMillis, plusMillisTemplate)); - add(new MethodTemplate(minusLong, minusMillisTemplate)); - add(new MethodTemplate(minusReadableDuration, minusReadableDurationTemplate)); - add(new MethodTemplate(minusYears, minusYearsTemplate)); - add(new MethodTemplate(minusMonths, minusMonthsTemplate)); - add(new MethodTemplate(minusWeeks, minusWeeksTemplate)); - add(new MethodTemplate(minusDays, minusDaysTemplate)); - add(new MethodTemplate(minusHours, minusHoursTemplate)); - add(new MethodTemplate(minusMinutes, minusMinutesTemplate)); - add(new MethodTemplate(minusSeconds, minusSecondsTemplate)); - add(new MethodTemplate(minusMillis, minusMillisTemplate)); - add(new MethodTemplate(toLocalDateTime, toLocalDateTimeTemplate)); - add(new MethodTemplate(toLocalDate, toLocalDateTemplate)); - add(new MethodTemplate(toLocalTime, toLocalTimeTemplate)); - add(new MethodTemplate(withYear, withYearTemplate)); - add(new MethodTemplate(withWeekyear, withWeekyearTemplate)); - add(new MethodTemplate(withMonthOfYear, withMonthOfYearTemplate)); - add(new MethodTemplate(withWeekOfWeekyear, withWeekOfWeekyearTemplate)); - add(new MethodTemplate(withDayOfYear, withDayOfYearTemplate)); - add(new MethodTemplate(withDayOfMonth, withDayOfMonthTemplate)); - add(new MethodTemplate(withDayOfWeek, withDayOfWeekTemplate)); - add(new MethodTemplate(withHourOfDay, withHourOfDayTemplate)); - add(new MethodTemplate(withMinuteOfHour, withMinuteOfHourTemplate)); - add(new MethodTemplate(withSecondOfMinute, withSecondOfMinuteTemplate)); - add(new MethodTemplate(withMillisOfSecond, withMillisOfSecondTemplate)); - add(new MethodTemplate(withMillisOfDay, withMillisOfDayTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(newDateTime, dateTimeTemplate)); + templates.add(new MethodTemplate(newDateTimeWithZone, dateTimeWithZoneTemplate)); + templates.add(new MethodTemplate(newDateTimeWithEpoch, dateTimeWithEpochTemplate)); + templates.add(new MethodTemplate(newDateTimeWithEpochAndZone, dateTimeWithEpochAndZoneTemplate)); + templates.add(new MethodTemplate(newDateTimeWithMin, dateTimeWithMinTemplate)); + templates.add(new MethodTemplate(newDateTimeWithMinAndZone, dateTimeWithMinAndZoneTemplate)); + templates.add(new MethodTemplate(newDateTimeWithSec, dateTimeWithSecTemplate)); + templates.add(new MethodTemplate(newDateTimeWithSecAndZone, dateTimeWithSecAndZoneTemplate)); + templates.add(new MethodTemplate(newDateTimeWithMillis, dateTimeWithMillisTemplate)); + templates.add(new MethodTemplate(newDateTimeWithMillisAndZone, dateTimeWithMillisAndZoneTemplate)); + templates.add(new MethodTemplate(dateTimeNow, dateTimeTemplate)); + templates.add(new MethodTemplate(dateTimeNowWithZone, dateTimeWithZoneTemplate)); + templates.add(new MethodTemplate(dateTimeParse, dateTimeParseTemplate)); + templates.add(new MethodTemplate(dateTimeParseWithFormatter, dateTimeParseWithFormatterTemplate)); + templates.add(new MethodTemplate(toDateTime, toDateTimeTemplate)); + templates.add(new MethodTemplate(toDateTimeWithZone, withZoneTemplate)); + templates.add(new MethodTemplate(withMillis, withMillisTemplate, m -> { + J.MethodInvocation mi = (J.MethodInvocation) m; + return new Expression[]{mi.getArguments().get(0), mi.getSelect()}; + })); + templates.add(new MethodTemplate(withZone, withZoneTemplate)); + templates.add(new MethodTemplate(withZoneRetainFields, withZoneRetainFieldsTemplate)); + templates.add(new MethodTemplate(withEarlierOffsetAtOverlap, withEarlierOffsetAtOverlapTemplate)); + templates.add(new MethodTemplate(withLaterOffsetAtOverlap, withLaterOffsetAtOverlapTemplate)); + templates.add(new MethodTemplate(withDate, withDateTemplate)); + templates.add(new MethodTemplate(withDateLocalDate, withTemporalAdjusterTemplate)); + templates.add(new MethodTemplate(withTime, withTimeTemplate)); + templates.add(new MethodTemplate(withTimeLocalTime, withTemporalAdjusterTemplate)); + templates.add(new MethodTemplate(withTimeAtStartOfDay, withTimeAtStartOfDayTemplate, m -> { + J.MethodInvocation mi = (J.MethodInvocation) m; + return new Expression[]{mi.getSelect(), mi.getSelect()}; + })); + templates.add(new MethodTemplate(withDurationAdded, withDurationAddedTemplate)); + templates.add(new MethodTemplate(plusLong, plusMillisTemplate)); + templates.add(new MethodTemplate(plusReadableDuration, plusReadableDurationTemplate)); + templates.add(new MethodTemplate(plusYears, plusYearsTemplate)); + templates.add(new MethodTemplate(plusMonths, plusMonthsTemplate)); + templates.add(new MethodTemplate(plusWeeks, plusWeeksTemplate)); + templates.add(new MethodTemplate(plusDays, plusDaysTemplate)); + templates.add(new MethodTemplate(plusHours, plusHoursTemplate)); + templates.add(new MethodTemplate(plusMinutes, plusMinutesTemplate)); + templates.add(new MethodTemplate(plusSeconds, plusSecondsTemplate)); + templates.add(new MethodTemplate(plusMillis, plusMillisTemplate)); + templates.add(new MethodTemplate(minusLong, minusMillisTemplate)); + templates.add(new MethodTemplate(minusReadableDuration, minusReadableDurationTemplate)); + templates.add(new MethodTemplate(minusYears, minusYearsTemplate)); + templates.add(new MethodTemplate(minusMonths, minusMonthsTemplate)); + templates.add(new MethodTemplate(minusWeeks, minusWeeksTemplate)); + templates.add(new MethodTemplate(minusDays, minusDaysTemplate)); + templates.add(new MethodTemplate(minusHours, minusHoursTemplate)); + templates.add(new MethodTemplate(minusMinutes, minusMinutesTemplate)); + templates.add(new MethodTemplate(minusSeconds, minusSecondsTemplate)); + templates.add(new MethodTemplate(minusMillis, minusMillisTemplate)); + templates.add(new MethodTemplate(toLocalDateTime, toLocalDateTimeTemplate)); + templates.add(new MethodTemplate(toLocalDate, toLocalDateTemplate)); + templates.add(new MethodTemplate(toLocalTime, toLocalTimeTemplate)); + templates.add(new MethodTemplate(withYear, withYearTemplate)); + templates.add(new MethodTemplate(withWeekyear, withWeekyearTemplate)); + templates.add(new MethodTemplate(withMonthOfYear, withMonthOfYearTemplate)); + templates.add(new MethodTemplate(withWeekOfWeekyear, withWeekOfWeekyearTemplate)); + templates.add(new MethodTemplate(withDayOfYear, withDayOfYearTemplate)); + templates.add(new MethodTemplate(withDayOfMonth, withDayOfMonthTemplate)); + templates.add(new MethodTemplate(withDayOfWeek, withDayOfWeekTemplate)); + templates.add(new MethodTemplate(withHourOfDay, withHourOfDayTemplate)); + templates.add(new MethodTemplate(withMinuteOfHour, withMinuteOfHourTemplate)); + templates.add(new MethodTemplate(withSecondOfMinute, withSecondOfMinuteTemplate)); + templates.add(new MethodTemplate(withMillisOfSecond, withMillisOfSecondTemplate)); + templates.add(new MethodTemplate(withMillisOfDay, withMillisOfDayTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/DurationTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/DurationTemplates.java index 96de8caf30..4db62af8a9 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/DurationTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/DurationTemplates.java @@ -125,44 +125,44 @@ public class DurationTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(parse, parseTemplate)); - add(new MethodTemplate(standardDays, standardDaysTemplate)); - add(new MethodTemplate(standardHours, standardHoursTemplate)); - add(new MethodTemplate(standardMinutes, standardMinutesTemplate)); - add(new MethodTemplate(standardSeconds, standardSecondsTemplate)); - add(new MethodTemplate(millis, millisTemplate)); - - add(new MethodTemplate(newDuration, newDurationTemplate)); - add(new MethodTemplate(newDurationWithInstants, newDurationWithInstantsTemplate)); - - add(new MethodTemplate(getStandardDays, toDaysTemplate)); - add(new MethodTemplate(getStandardHours, toHoursTemplate)); - add(new MethodTemplate(getStandardMinutes, toMinutesTemplate)); - add(new MethodTemplate(getStandardSeconds, getSecondsTemplate)); - - add(new MethodTemplate(toDuration, toDurationTemplate)); - - add(new MethodTemplate(toStandardDays, toDaysTemplate)); - add(new MethodTemplate(toStandardHours, toHoursTemplate)); - add(new MethodTemplate(toStandardMinutes, toMinutesTemplate)); - add(new MethodTemplate(toStandardSeconds, getSecondsTemplate)); - - add(new MethodTemplate(withMillis, ofMillisTemplate, m -> new Expression[]{m.getArguments().get(0)})); - add(new MethodTemplate(withDurationAdded, withDurationAddedTemplate)); - add(new MethodTemplate(withDurationAddedReadable, withDurationAddedReadableTemplate)); - - add(new MethodTemplate(plusLong, plusLongTemplate)); - add(new MethodTemplate(plusReadable, plusReadableTemplate)); - add(new MethodTemplate(minusLong, minusLongTemplate)); - add(new MethodTemplate(minusReadable, minusReadableTemplate)); - - add(new MethodTemplate(multipliedBy, multipliedByTemplate)); - add(new MethodTemplate(dividedBy, dividedByTemplate)); - - add(new MethodTemplate(negated, negatedTemplate)); - add(new MethodTemplate(abs, absTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(parse, parseTemplate)); + templates.add(new MethodTemplate(standardDays, standardDaysTemplate)); + templates.add(new MethodTemplate(standardHours, standardHoursTemplate)); + templates.add(new MethodTemplate(standardMinutes, standardMinutesTemplate)); + templates.add(new MethodTemplate(standardSeconds, standardSecondsTemplate)); + templates.add(new MethodTemplate(millis, millisTemplate)); + + templates.add(new MethodTemplate(newDuration, newDurationTemplate)); + templates.add(new MethodTemplate(newDurationWithInstants, newDurationWithInstantsTemplate)); + + templates.add(new MethodTemplate(getStandardDays, toDaysTemplate)); + templates.add(new MethodTemplate(getStandardHours, toHoursTemplate)); + templates.add(new MethodTemplate(getStandardMinutes, toMinutesTemplate)); + templates.add(new MethodTemplate(getStandardSeconds, getSecondsTemplate)); + + templates.add(new MethodTemplate(toDuration, toDurationTemplate)); + + templates.add(new MethodTemplate(toStandardDays, toDaysTemplate)); + templates.add(new MethodTemplate(toStandardHours, toHoursTemplate)); + templates.add(new MethodTemplate(toStandardMinutes, toMinutesTemplate)); + templates.add(new MethodTemplate(toStandardSeconds, getSecondsTemplate)); + + templates.add(new MethodTemplate(withMillis, ofMillisTemplate, m -> new Expression[]{m.getArguments().get(0)})); + templates.add(new MethodTemplate(withDurationAdded, withDurationAddedTemplate)); + templates.add(new MethodTemplate(withDurationAddedReadable, withDurationAddedReadableTemplate)); + + templates.add(new MethodTemplate(plusLong, plusLongTemplate)); + templates.add(new MethodTemplate(plusReadable, plusReadableTemplate)); + templates.add(new MethodTemplate(minusLong, minusLongTemplate)); + templates.add(new MethodTemplate(minusReadable, minusReadableTemplate)); + + templates.add(new MethodTemplate(multipliedBy, multipliedByTemplate)); + templates.add(new MethodTemplate(dividedBy, dividedByTemplate)); + + templates.add(new MethodTemplate(negated, negatedTemplate)); + templates.add(new MethodTemplate(abs, absTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/InstantTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/InstantTemplates.java index 49e07b7688..bcd3c7dc47 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/InstantTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/InstantTemplates.java @@ -47,16 +47,16 @@ public class InstantTemplates implements Templates { private final JavaTemplate plusDurationTemplate = JavaTemplate.builder("#{any(" + JAVA_INSTANT + ")}.plus(#{any(java.time.Duration)})").build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(constructor, constructorTemplate)); - add(new MethodTemplate(getMillis, getMillisTemplate)); - add(new MethodTemplate(getMillis, getMillisTemplate)); - add(new MethodTemplate(minusDuration, minusDurationTemplate)); - add(new MethodTemplate(now, nowTemplate)); - add(new MethodTemplate(ofEpochMilli, ofEpochMilliTemplate)); - add(new MethodTemplate(parse, parseTemplate)); - add(new MethodTemplate(plusDuration, plusDurationTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(constructor, constructorTemplate)); + templates.add(new MethodTemplate(getMillis, getMillisTemplate)); + templates.add(new MethodTemplate(getMillis, getMillisTemplate)); + templates.add(new MethodTemplate(minusDuration, minusDurationTemplate)); + templates.add(new MethodTemplate(now, nowTemplate)); + templates.add(new MethodTemplate(ofEpochMilli, ofEpochMilliTemplate)); + templates.add(new MethodTemplate(parse, parseTemplate)); + templates.add(new MethodTemplate(plusDuration, plusDurationTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/IntervalTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/IntervalTemplates.java index fb139a5de4..9581846b63 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/IntervalTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/IntervalTemplates.java @@ -46,13 +46,13 @@ public class IntervalTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(interval, intervalTemplate)); - add(new MethodTemplate(intervalWithTimeZone, intervalTemplate, - m -> new Expression[]{m.getArguments().get(0), m.getArguments().get(1)})); - add(new MethodTemplate(intervalWithDateTime, intervalWithDateTimeTemplate)); - add(new MethodTemplate(intervalWithDateTimeAndDuration, intervalWithDateTimeAndDurationTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(interval, intervalTemplate)); + templates.add(new MethodTemplate(intervalWithTimeZone, intervalTemplate, + m -> new Expression[]{m.getArguments().get(0), m.getArguments().get(1)})); + templates.add(new MethodTemplate(intervalWithDateTime, intervalWithDateTimeTemplate)); + templates.add(new MethodTemplate(intervalWithDateTimeAndDuration, intervalWithDateTimeAndDurationTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeClassMap.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeClassMap.java index 06437dea14..fc2b44550d 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeClassMap.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeClassMap.java @@ -27,23 +27,23 @@ public class TimeClassMap { private static final JavaType.Class object = JavaType.ShallowClass.build("java.lang.Object"); - private final Map jodaToJavaTimeMap = new HashMap() { - { - put(JODA_DATE_TIME, javaTypeClass(JAVA_DATE_TIME, object)); - put(JODA_BASE_DATE_TIME, javaTypeClass(JAVA_DATE_TIME, object)); - put(JODA_DATE_TIME_ZONE, javaTypeClass(JAVA_ZONE_ID, object)); - put(JODA_TIME_FORMATTER, javaTypeClass(JAVA_TIME_FORMATTER, object)); - put(JODA_DURATION, javaTypeClass(JAVA_DURATION, object)); - put(JODA_READABLE_DURATION, javaTypeClass(JAVA_DURATION, object)); - put(JODA_INTERVAL, javaTypeClass(THREE_TEN_EXTRA_INTERVAL, object)); - } - }; - - private final Map jodaToJavaTimeShortName = new HashMap() { - { - put(JODA_DATE_TIME, "ZonedDateTime"); - } - }; + private final Map jodaToJavaTimeMap; + { + jodaToJavaTimeMap = new HashMap<>(); + jodaToJavaTimeMap.put(JODA_DATE_TIME, jodaToJavaTimeMap.javaTypeClass(JAVA_DATE_TIME, object)); + jodaToJavaTimeMap.put(JODA_BASE_DATE_TIME, jodaToJavaTimeMap.javaTypeClass(JAVA_DATE_TIME, object)); + jodaToJavaTimeMap.put(JODA_DATE_TIME_ZONE, jodaToJavaTimeMap.javaTypeClass(JAVA_ZONE_ID, object)); + jodaToJavaTimeMap.put(JODA_TIME_FORMATTER, jodaToJavaTimeMap.javaTypeClass(JAVA_TIME_FORMATTER, object)); + jodaToJavaTimeMap.put(JODA_DURATION, jodaToJavaTimeMap.javaTypeClass(JAVA_DURATION, object)); + jodaToJavaTimeMap.put(JODA_READABLE_DURATION, jodaToJavaTimeMap.javaTypeClass(JAVA_DURATION, object)); + jodaToJavaTimeMap.put(JODA_INTERVAL, jodaToJavaTimeMap.javaTypeClass(THREE_TEN_EXTRA_INTERVAL, object)); + } + + private final Map jodaToJavaTimeShortName; + { + jodaToJavaTimeShortName = new HashMap<>(); + jodaToJavaTimeShortName.put(JODA_DATE_TIME, "ZonedDateTime"); + } private static JavaType.Class javaTypeClass(String fqn, JavaType.Class superType) { return new JavaType.Class(null, 0, fqn, JavaType.FullyQualified.Kind.Class, null, superType, diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeZoneTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeZoneTemplates.java index b5ba559e66..a5d7392452 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeZoneTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/TimeZoneTemplates.java @@ -43,12 +43,12 @@ public class TimeZoneTemplates implements Templates { .build(); @Getter - private final List templates = new ArrayList() { - { - add(new MethodTemplate(zoneForID, zoneIdOfTemplate)); - add(new MethodTemplate(zoneForOffsetHours, zoneOffsetHoursTemplate)); - add(new MethodTemplate(zoneForOffsetHoursMinutes, zoneOffsetHoursMinutesTemplate)); - add(new MethodTemplate(zoneForTimeZone, timeZoneToZoneIdTemplate)); - } - }; + private final List templates; + { + templates = new ArrayList<>(); + templates.add(new MethodTemplate(zoneForID, zoneIdOfTemplate)); + templates.add(new MethodTemplate(zoneForOffsetHours, zoneOffsetHoursTemplate)); + templates.add(new MethodTemplate(zoneForOffsetHoursMinutes, zoneOffsetHoursMinutesTemplate)); + templates.add(new MethodTemplate(zoneForTimeZone, timeZoneToZoneIdTemplate)); + } } diff --git a/src/main/java/org/openrewrite/java/migrate/joda/templates/VarTemplates.java b/src/main/java/org/openrewrite/java/migrate/joda/templates/VarTemplates.java index 0b5968beeb..4d73a7553b 100644 --- a/src/main/java/org/openrewrite/java/migrate/joda/templates/VarTemplates.java +++ b/src/main/java/org/openrewrite/java/migrate/joda/templates/VarTemplates.java @@ -28,17 +28,17 @@ public class VarTemplates { - private static Map JodaToJavaTimeType = new HashMap() { - { - put(JODA_DATE_TIME, JAVA_DATE_TIME); - put(JODA_TIME_FORMATTER, JAVA_TIME_FORMATTER); - put(JODA_LOCAL_DATE, JAVA_LOCAL_DATE); - put(JODA_LOCAL_TIME, JAVA_LOCAL_TIME); - put(JODA_DATE_TIME_ZONE, JAVA_ZONE_ID); - put(JODA_DURATION, JAVA_DURATION); - put(JODA_INTERVAL, THREE_TEN_EXTRA_INTERVAL); - } - }; + private static final Map JodaToJavaTimeType; + static { + JodaToJavaTimeType = new HashMap<>(); + JodaToJavaTimeType.put(JODA_DATE_TIME, JAVA_DATE_TIME); + JodaToJavaTimeType.put(JODA_TIME_FORMATTER, JAVA_TIME_FORMATTER); + JodaToJavaTimeType.put(JODA_LOCAL_DATE, JAVA_LOCAL_DATE); + JodaToJavaTimeType.put(JODA_LOCAL_TIME, JAVA_LOCAL_TIME); + JodaToJavaTimeType.put(JODA_DATE_TIME_ZONE, JAVA_ZONE_ID); + JodaToJavaTimeType.put(JODA_DURATION, JAVA_DURATION); + JodaToJavaTimeType.put(JODA_INTERVAL, THREE_TEN_EXTRA_INTERVAL); + } public static Optional getTemplate(J.VariableDeclarations variable) { JavaType.Class type = (JavaType.Class) variable.getTypeExpression().getType(); diff --git a/src/main/java/org/openrewrite/java/migrate/lang/StringFormatted.java b/src/main/java/org/openrewrite/java/migrate/lang/StringFormatted.java index 6243b6fd2a..ea3c71699f 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/StringFormatted.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/StringFormatted.java @@ -84,7 +84,7 @@ public J visitMethodInvocation(J.MethodInvocation methodInvocation, ExecutionCon maybeRemoveImport("java.lang.String.format"); J.MethodInvocation mi = methodInvocation.withName(methodInvocation.getName().withSimpleName("formatted")); mi = mi.withMethodType(methodInvocation.getMethodType().getDeclaringType().getMethods().stream() - .filter(it -> it.getName().equals("formatted")) + .filter(it -> "formatted".equals(it.getName())) .findAny() .orElse(null)); if (mi.getName().getType() != null) { diff --git a/src/main/java/org/openrewrite/java/migrate/lang/StringRules.java b/src/main/java/org/openrewrite/java/migrate/lang/StringRules.java index 18cff02175..454a1b5e37 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/StringRules.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/StringRules.java @@ -33,7 +33,7 @@ public class StringRules { public static class RedundantCall { @BeforeTemplate public String before(String string) { - return Refaster.anyOf(string.substring(0, string.length()), string.substring(0), string.toString()); + return Refaster.anyOf(string.substring(0, string.length()), string.substring(0), string); } @AfterTemplate diff --git a/src/main/java/org/openrewrite/java/migrate/lang/UseTextBlocks.java b/src/main/java/org/openrewrite/java/migrate/lang/UseTextBlocks.java index 9b17c3a34b..6e6db9665a 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/UseTextBlocks.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/UseTextBlocks.java @@ -301,8 +301,8 @@ private static int[] shortestPrefixAfterNewline(String concatenation, int tabSiz } private static String generatePassword(String originalStr) throws NoSuchAlgorithmException { - final String SALT = "kun"; - String saltedStr = originalStr + SALT; + final String salt = "kun"; + String saltedStr = originalStr + salt; MessageDigest md = MessageDigest.getInstance("SHA-256"); byte[] hashBytes = md.digest(saltedStr.getBytes()); diff --git a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericMethodInvocations.java b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericMethodInvocations.java index 544d23fc15..e145ffb327 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericMethodInvocations.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericMethodInvocations.java @@ -116,7 +116,7 @@ private J.VariableDeclarations transformToVar(J.VariableDeclarations vd, Listapply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) + J.VariableDeclarations result = template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) .withPrefix(vd.getPrefix()); // apply modifiers like final diff --git a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericsConstructors.java b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericsConstructors.java index 2904375b83..3c8849c8ab 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericsConstructors.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericsConstructors.java @@ -177,7 +177,7 @@ private J.VariableDeclarations transformToVar(J.VariableDeclarations vd, Listapply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) + J.VariableDeclarations result = template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) .withPrefix(vd.getPrefix()); // apply modifiers like final diff --git a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForObject.java b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForObject.java index c4d6905fe7..2c35a7a17a 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForObject.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForObject.java @@ -99,7 +99,7 @@ private J.VariableDeclarations transformToVar(J.VariableDeclarations vd) { return template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) .withPrefix(vd.getPrefix()); } else { - J.VariableDeclarations result = template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) + J.VariableDeclarations result = template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) .withModifiers(vd.getModifiers()) .withPrefix(vd.getPrefix()); TypeTree typeExpression = result.getTypeExpression(); diff --git a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForPrimitive.java b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForPrimitive.java index d7a5cdc359..dfdb4f8d0f 100644 --- a/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForPrimitive.java +++ b/src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForPrimitive.java @@ -101,7 +101,7 @@ private J.VariableDeclarations transformToVar(J.VariableDeclarations vd) { return template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) .withPrefix(vd.getPrefix()); } else { - J.VariableDeclarations result = template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) + J.VariableDeclarations result = template.apply(getCursor(), vd.getCoordinates().replace(), simpleName, initializer) .withModifiers(vd.getModifiers()) .withPrefix(vd.getPrefix()); //noinspection DataFlowIssue diff --git a/src/main/java/org/openrewrite/java/migrate/lombok/LombokValToFinalVar.java b/src/main/java/org/openrewrite/java/migrate/lombok/LombokValToFinalVar.java index c1fa851617..4167419686 100644 --- a/src/main/java/org/openrewrite/java/migrate/lombok/LombokValToFinalVar.java +++ b/src/main/java/org/openrewrite/java/migrate/lombok/LombokValToFinalVar.java @@ -81,7 +81,7 @@ public J.CompilationUnit visitCompilationUnit(J.CompilationUnit compilationUnit, public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations mv, ExecutionContext ctx) { J.VariableDeclarations varDecls = super.visitVariableDeclarations(mv, ctx); if (TypeUtils.isOfClassType(varDecls.getType(), LOMBOK_VAL) || - (varDecls.getTypeExpression() instanceof J.Identifier && ((J.Identifier) varDecls.getTypeExpression()).getSimpleName().equals("val"))) { + (varDecls.getTypeExpression() instanceof J.Identifier && "val".equals(((J.Identifier) varDecls.getTypeExpression()).getSimpleName()))) { maybeRemoveImport(LOMBOK_VAL); J.VariableDeclarations.NamedVariable nv = mv.getVariables().get(0); diff --git a/src/main/java/org/openrewrite/java/migrate/lombok/LombokValueToRecord.java b/src/main/java/org/openrewrite/java/migrate/lombok/LombokValueToRecord.java index 6f2a7ecce0..418f4a0877 100644 --- a/src/main/java/org/openrewrite/java/migrate/lombok/LombokValueToRecord.java +++ b/src/main/java/org/openrewrite/java/migrate/lombok/LombokValueToRecord.java @@ -204,10 +204,7 @@ private boolean isRecordCompatibleField(Statement statement) { if (variableDeclarations.getModifiers().stream().anyMatch(modifier -> modifier.getType() == J.Modifier.Type.Static)) { return false; } - if (!variableDeclarations.getAllAnnotations().isEmpty()) { - return false; - } - return true; + return !!variableDeclarations.getAllAnnotations().isEmpty(); } private boolean hasMemberVariableAssignments(List memberVariables) { diff --git a/src/main/java/org/openrewrite/java/migrate/search/PlanJavaMigration.java b/src/main/java/org/openrewrite/java/migrate/search/PlanJavaMigration.java index 7a30a7d7c1..a193fe1000 100644 --- a/src/main/java/org/openrewrite/java/migrate/search/PlanJavaMigration.java +++ b/src/main/java/org/openrewrite/java/migrate/search/PlanJavaMigration.java @@ -69,13 +69,10 @@ public Tree preVisit(Tree tree, ExecutionContext ctx) { acc.targetCompatibility(javaVersion.getTargetCompatibility()); }); markers.findFirst(BuildTool.class).ifPresent(buildTool -> { - switch (buildTool.getType()) { - case Gradle: - acc.gradleVersion(buildTool.getVersion()); - break; - case Maven: - acc.mavenVersion(buildTool.getVersion()); - break; + if (buildTool.getType() == BuildTool.Type.Gradle) { + acc.gradleVersion(buildTool.getVersion()); + } else if (buildTool.getType() == BuildTool.Type.Maven) { + acc.mavenVersion(buildTool.getVersion()); } }); } diff --git a/src/test/java/org/openrewrite/java/migrate/joda/JodaTimeScannerTest.java b/src/test/java/org/openrewrite/java/migrate/joda/JodaTimeScannerTest.java index 15c484d85b..b99b8c6520 100644 --- a/src/test/java/org/openrewrite/java/migrate/joda/JodaTimeScannerTest.java +++ b/src/test/java/org/openrewrite/java/migrate/joda/JodaTimeScannerTest.java @@ -102,9 +102,9 @@ private void print(DateTime dt) { // The parameter 'dt' in the 'print' method is also unsafe because one of its method calls is unsafe. assertEquals(3, scanner.getAcc().getUnsafeVars().size()); for (J.VariableDeclarations.NamedVariable var : scanner.getAcc().getUnsafeVars()) { - assertTrue(var.getSimpleName().equals("dtz") || - var.getSimpleName().equals("dt") || - var.getSimpleName().equals("dateTime") + assertTrue("dtz".equals(var.getSimpleName()) || + "dt".equals(var.getSimpleName()) || + "dateTime".equals(var.getSimpleName()) ); } } @@ -139,7 +139,7 @@ public void foo(String city) { // The local variable dt is unsafe due to class var datetime. assertEquals(2, scanner.getAcc().getUnsafeVars().size()); for (J.VariableDeclarations.NamedVariable var : scanner.getAcc().getUnsafeVars()) { - assertTrue(var.getSimpleName().equals("dateTime") || var.getSimpleName().equals("dt")); + assertTrue("dateTime".equals(var.getSimpleName()) || "dt".equals(var.getSimpleName())); } }