From e903cb0e4c7a3665fbb92b7f8ab22d20a6ecc353 Mon Sep 17 00:00:00 2001 From: Dmitry Batkovich Date: Thu, 22 Oct 2015 14:50:04 +0300 Subject: [PATCH] guava type migration: added test for complex structure --- .../GuavaFluentIterableConversionRule.java | 3 +- .../inspections/GuavaInspectionTest.java | 8 +++++ .../guava/fluentIterableAndOptional.java | 25 +++++++++++++++ .../fluentIterableAndOptional_after.java | 25 +++++++++++++++ .../fluentIterableMigrationInInheritance.java | 31 +++++++++++++++++++ ...tIterableMigrationInInheritance_after.java | 24 ++++++++++++++ 6 files changed, 114 insertions(+), 2 deletions(-) create mode 100644 java/typeMigration/testData/inspections/guava/fluentIterableAndOptional.java create mode 100644 java/typeMigration/testData/inspections/guava/fluentIterableAndOptional_after.java create mode 100644 java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance.java create mode 100644 java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance_after.java diff --git a/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaFluentIterableConversionRule.java b/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaFluentIterableConversionRule.java index a90f7639be1a..7593fc57f3ee 100644 --- a/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaFluentIterableConversionRule.java +++ b/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaFluentIterableConversionRule.java @@ -92,13 +92,12 @@ public class GuavaFluentIterableConversionRule extends BaseGuavaTypeConversionRu DESCRIPTORS_MAP.put("isEmpty", new TypeConversionDescriptorFactory("$q$.isEmpty()", "$q$.findAny().isPresent()", false)); DESCRIPTORS_MAP.put("skip", new TypeConversionDescriptorFactory("$q$.skip($p$)", "$q$.skip($p$)", false, true, true)); DESCRIPTORS_MAP.put("limit", new TypeConversionDescriptorFactory("$q$.limit($p$)", "$q$.limit($p$)", false, true, true)); - DESCRIPTORS_MAP.put("first", new TypeConversionDescriptorFactory("$q$.first()", "$q$.findFirst()", false)); + DESCRIPTORS_MAP.put("first", new TypeConversionDescriptorFactory("$q$.first()", "$q$.findFirst()", false, true, false)); DESCRIPTORS_MAP.put("transform", new TypeConversionDescriptorFactory("$q$.transform($params$)", "$q$.map($params$)", true, true, true)); DESCRIPTORS_MAP.put("allMatch", new TypeConversionDescriptorFactory("$it$.allMatch($c$)", "$it$." + StreamApiConstants.ALL_MATCH + "($c$)", true)); DESCRIPTORS_MAP.put("anyMatch", new TypeConversionDescriptorFactory("$it$.anyMatch($c$)", "$it$." + StreamApiConstants.ANY_MATCH + "($c$)", true)); - DESCRIPTORS_MAP.put("first", new TypeConversionDescriptorFactory("$it$.first()", "$it$." + StreamApiConstants.FIND_FIRST + "()", false)); DESCRIPTORS_MAP.put("firstMatch", new TypeConversionDescriptorFactory("$it$.firstMatch($p$)", "$it$.filter($p$).findFirst()", true, true, false)); DESCRIPTORS_MAP.put("size", new TypeConversionDescriptorFactory("$it$.size()", "(int) $it$.count()", false)); diff --git a/java/typeMigration/test/com/intellij/codeInsight/inspections/GuavaInspectionTest.java b/java/typeMigration/test/com/intellij/codeInsight/inspections/GuavaInspectionTest.java index 4fa31f9ad75f..a864df425701 100644 --- a/java/typeMigration/test/com/intellij/codeInsight/inspections/GuavaInspectionTest.java +++ b/java/typeMigration/test/com/intellij/codeInsight/inspections/GuavaInspectionTest.java @@ -162,6 +162,14 @@ public class GuavaInspectionTest extends JavaCodeInsightFixtureTestCase { doTest(); } + public void testFluentIterableMigrationInInheritance() { + doTest(); + } + + public void testFluentIterableAndOptional() { + doTest(); + } + private void doTestNoQuickFixes(final Class... quickFixesClasses) { myFixture.configureByFile(getTestName(true) + ".java"); myFixture.enableInspections(new GuavaInspection()); diff --git a/java/typeMigration/testData/inspections/guava/fluentIterableAndOptional.java b/java/typeMigration/testData/inspections/guava/fluentIterableAndOptional.java new file mode 100644 index 000000000000..e942a7c9e815 --- /dev/null +++ b/java/typeMigration/testData/inspections/guava/fluentIterableAndOptional.java @@ -0,0 +1,25 @@ +import com.google.common.base.Optional; +import com.google.common.collect.FluentIterable; + +import java.util.ArrayList; + +public class Main18 { + + class A { + private String i = "12"; + + Optional getOpt() { + return Optional.fromNullable(i); + } + } + + class B { + FluentIterable getFIterable() { + return FluentIterable.from(new ArrayList()).filter(String.class); + } + } + + void m(A a, B b) { + String sss = b.getFIterable().transform(s -> s).first().or(a.getOpt()).get(); + } +} diff --git a/java/typeMigration/testData/inspections/guava/fluentIterableAndOptional_after.java b/java/typeMigration/testData/inspections/guava/fluentIterableAndOptional_after.java new file mode 100644 index 000000000000..d717ca06ec09 --- /dev/null +++ b/java/typeMigration/testData/inspections/guava/fluentIterableAndOptional_after.java @@ -0,0 +1,25 @@ +import com.google.common.base.Optional; + +import java.util.ArrayList; +import java.util.stream.Stream; + +public class Main18 { + + class A { + private String i = "12"; + + Optional getOpt() { + return Optional.fromNullable(i); + } + } + + class B { + Stream getFIterable() { + return new ArrayList().stream().filter(String.class::isInstance); + } + } + + void m(A a, B b) { + String sss = java.util.Optional.ofNullable(b.getFIterable().map(s -> s).findFirst().orElseGet(a.getOpt()::get)).get(); + } +} diff --git a/java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance.java b/java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance.java new file mode 100644 index 000000000000..f943cae23623 --- /dev/null +++ b/java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance.java @@ -0,0 +1,31 @@ +import com.google.common.base.Function; +import com.google.common.collect.FluentIterable; + +import java.util.ArrayList; + +public class Main17 { + + interface A { + FluentIterable getIterable(); + } + + class B implements A { + @Override + public FluentIterable getIterable() { + return FluentIterable.from(new ArrayList()).transform(new Function() { + @Override + public String apply(String s) { + return s.intern(); + } + }); + } + } + + static void m(A a) { + int s = a.getIterable().transform(s1 -> s1).size(); + } + + static void m2(B b) { + int s = b.getIterable().size(); + } +} diff --git a/java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance_after.java b/java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance_after.java new file mode 100644 index 000000000000..3193f3230d04 --- /dev/null +++ b/java/typeMigration/testData/inspections/guava/fluentIterableMigrationInInheritance_after.java @@ -0,0 +1,24 @@ +import java.util.ArrayList; +import java.util.stream.Stream; + +public class Main17 { + + interface A { + Stream getIterable(); + } + + class B implements A { + @Override + public Stream getIterable() { + return new ArrayList().stream().map(s -> s.intern()); + } + } + + static void m(A a) { + int s = (int) a.getIterable().map(s1 -> s1).count(); + } + + static void m2(B b) { + int s = (int) b.getIterable().count(); + } +}