StreamApiMigration: CollectTerminal is abstract class now (IDEA-CR-17236)

java/java-impl/src/com/intellij/codeInspection/streamMigration/CollectMigration.java

@@ -183,59 +183,58 @@ class CollectMigration extends BaseStreamApiMigration {
     return false;
   }
 
-  interface CollectTerminal {
-    @Nullable
-    default PsiElement getElementToReplace() { return null; }
+  abstract static class CollectTerminal {
+    private final PsiLocalVariable myTargetVariable;
 
-    default String getMethodName() { return "collect"; }
+    protected CollectTerminal(PsiLocalVariable variable) {
+      myTargetVariable = variable;
+    }
 
     @Nullable
-    PsiVariable getTargetVariable();
+    PsiElement getElementToReplace() { return null; }
 
-    default String generateIntermediate() { return ""; }
+    String getMethodName() { return "collect"; }
 
-    String generateTerminal();
+    PsiLocalVariable getTargetVariable() { return myTargetVariable; }
 
-    default void cleanUp() {}
+    String generateIntermediate() { return ""; }
 
-    default boolean isTrivial() {
+    abstract String generateTerminal();
+
+    void cleanUp() {}
+
+    boolean isTrivial() {
       return generateIntermediate().isEmpty();
     }
   }
 
-  static class AddingTerminal implements CollectTerminal {
-    @Nullable PsiVariable myTarget;
+  static class AddingTerminal extends CollectTerminal {
     final PsiType myTargetType;
     final PsiExpression myInitializer;
     final PsiVariable myElement;
     final PsiMethodCallExpression myAddCall;
 
-    AddingTerminal(@NotNull PsiVariable target,
+    AddingTerminal(@NotNull PsiLocalVariable target,
                    PsiVariable element,
                    PsiMethodCallExpression addCall) {
-      this(target.getType(), target.getInitializer(), element, addCall);
-      if (isEmptyCollectionInitializer(myInitializer)) {
-        myTarget = target;
-      }
+      super(isEmptyCollectionInitializer(target.getInitializer()) ? target : null);
+      myTargetType = target.getType();
+      myInitializer = target.getInitializer();
+      myElement = element;
+      myAddCall = addCall;
     }
 
     AddingTerminal(@NotNull PsiType targetType,
                    PsiExpression initializer,
                    PsiVariable element,
                    PsiMethodCallExpression addCall) {
-      myTarget = null;
+      super(null);
       myTargetType = targetType;
       myInitializer = initializer;
       myElement = element;
       myAddCall = addCall;
     }
 
-    @Override
-    @Nullable
-    public PsiVariable getTargetVariable() {
-      return myTarget;
-    }
-
     PsiVariable getElementVariable() {
       return myElement;
     }
@@ -306,7 +305,7 @@ class CollectMigration extends BaseStreamApiMigration {
   static class AddingAllTerminal extends AddingTerminal {
     private final PsiMethodCallExpression myAddAllCall;
 
-    AddingAllTerminal(PsiVariable target, PsiVariable element, PsiMethodCallExpression addAllCall) {
+    AddingAllTerminal(PsiLocalVariable target, PsiVariable element, PsiMethodCallExpression addAllCall) {
       super(target, element, null);
       myAddAllCall = addAllCall;
     }
@@ -343,14 +342,13 @@ class CollectMigration extends BaseStreamApiMigration {
     }
   }
 
-  static class GroupingTerminal implements CollectTerminal {
+  static class GroupingTerminal extends CollectTerminal {
     private final AddingTerminal myDownstream;
-    private final PsiLocalVariable myTarget;
     private final PsiExpression myKeyExpression;
 
     GroupingTerminal(AddingTerminal downstream, PsiLocalVariable target, PsiExpression expression) {
+      super(target);
       myDownstream = downstream;
-      myTarget = target;
       myKeyExpression = expression;
     }
 
@@ -359,12 +357,6 @@ class CollectMigration extends BaseStreamApiMigration {
       return false;
     }
 
-    @Nullable
-    @Override
-    public PsiVariable getTargetVariable() {
-      return myTarget;
-    }
-
     @Override
     public String generateTerminal() {
       String downstreamCollector = myDownstream.generateCollector();
@@ -377,9 +369,9 @@ class CollectMigration extends BaseStreamApiMigration {
       StringBuilder builder = new StringBuilder();
       builder.append(".collect(" + CommonClassNames.JAVA_UTIL_STREAM_COLLECTORS + ".groupingBy(")
         .append(LambdaUtil.createLambda(elementVariable, myKeyExpression));
-      PsiExpression initializer = myTarget.getInitializer();
+      PsiExpression initializer = getTargetVariable().getInitializer();
       LOG.assertTrue(initializer != null);
-      if (!isHashMap(myTarget)) {
+      if (!isHashMap(getTargetVariable())) {
         builder.append(",()->").append(initializer.getText()).append(",").append(downstreamCollector);
       }
       else if (!(CommonClassNames.JAVA_UTIL_STREAM_COLLECTORS + "." + "toList()").equals(downstreamCollector)) {
@@ -418,23 +410,16 @@ class CollectMigration extends BaseStreamApiMigration {
     }
   }
 
-  static class ToMapTerminal implements CollectTerminal {
+  static class ToMapTerminal extends CollectTerminal {
     private final PsiMethodCallExpression myMapUpdateCall;
-    private final PsiLocalVariable myTargetVariable;
     private final PsiVariable myElementVariable;
 
     ToMapTerminal(PsiMethodCallExpression call, PsiVariable elementVariable, PsiLocalVariable variable) {
+      super(variable);
       myMapUpdateCall = call;
-      myTargetVariable = variable;
       myElementVariable = elementVariable;
     }
 
-    @Nullable
-    @Override
-    public PsiVariable getTargetVariable() {
-      return myTargetVariable;
-    }
-
     @Override
     public String generateTerminal() {
       PsiExpression[] args = myMapUpdateCall.getArgumentList().getExpressions();
@@ -464,9 +449,9 @@ class CollectMigration extends BaseStreamApiMigration {
       collector.append(LambdaUtil.createLambda(myElementVariable, args[0])).append(',')
         .append(LambdaUtil.createLambda(myElementVariable, args[1])).append(',')
         .append(merger);
-      PsiExpression initializer = myTargetVariable.getInitializer();
+      PsiExpression initializer = getTargetVariable().getInitializer();
       LOG.assertTrue(initializer != null);
-      if (!isHashMap(myTargetVariable)) {
+      if (!isHashMap(getTargetVariable())) {
         collector.append(",()->").append(initializer.getText());
       }
       collector.append("))");
@@ -485,12 +470,13 @@ class CollectMigration extends BaseStreamApiMigration {
     }
   }
 
-  static class SortingTerminal implements CollectTerminal {
+  static class SortingTerminal extends CollectTerminal {
     private final CollectTerminal myDownstream;
     private final PsiExpression myComparator;
     private final PsiStatement myStatement;
 
     SortingTerminal(CollectTerminal downstream, PsiStatement statement, PsiExpression comparator) {
+      super(downstream.getTargetVariable());
       myDownstream = downstream;
       myStatement = statement;
       myComparator = comparator;
@@ -501,12 +487,6 @@ class CollectMigration extends BaseStreamApiMigration {
       return myDownstream.getMethodName();
     }
 
-    @Nullable
-    @Override
-    public PsiVariable getTargetVariable() {
-      return myDownstream.getTargetVariable();
-    }
-
     @Override
     public String generateIntermediate() {
       return myDownstream.generateIntermediate() + ".sorted("
@@ -568,7 +548,7 @@ class CollectMigration extends BaseStreamApiMigration {
     }
   }
 
-  static class ToArrayTerminal implements CollectTerminal {
+  static class ToArrayTerminal extends CollectTerminal {
     static final Map<String, String> INTERMEDIATE_STEPS = EntryStream.of(
       CommonClassNames.JAVA_UTIL_ARRAY_LIST, "",
       "java.util.LinkedList", "",
@@ -586,6 +566,7 @@ class CollectMigration extends BaseStreamApiMigration {
                     String intermediate,
                     String supplier,
                     PsiMethodCallExpression toArrayExpression) {
+      super(upstream.getTargetVariable());
       myUpstream = upstream;
       mySupplier = supplier;
       myIntermediate = intermediate;
@@ -608,12 +589,6 @@ class CollectMigration extends BaseStreamApiMigration {
       return myToArrayExpression;
     }
 
-    @Nullable
-    @Override
-    public PsiVariable getTargetVariable() {
-      return myUpstream.getTargetVariable();
-    }
-
     @Override
     public String generateIntermediate() {
       return myUpstream.generateIntermediate() + myIntermediate;