From 96be1a7fb26c1d00cb2aa8a35a6a80edfd5f0cfd Mon Sep 17 00:00:00 2001
From: Tagir Valeev <Tagir.Valeev@jetbrains.com>
Date: Mon, 26 Feb 2018 18:14:54 +0700
Subject: [PATCH] StreamChainInliner: toImmutableXyz -> toUnmodifiableXyz

---
 .../dataFlow/inliner/StreamChainInliner.java         |  8 ++++----
 .../dataFlow/fixture/StreamCollector10Inlining.java  | 12 ++++++------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/inliner/StreamChainInliner.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/inliner/StreamChainInliner.java
index 9592c32b1833..1c22f7e3e0ab 100644
--- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/inliner/StreamChainInliner.java
+++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/inliner/StreamChainInliner.java
@@ -57,10 +57,10 @@ public class StreamChainInliner implements CallInliner {
   private static final CallMatcher COUNTING_COLLECTOR =
     staticCall(JAVA_UTIL_STREAM_COLLECTORS, "counting").parameterCount(0);
   private static final CallMatcher COLLECTION_COLLECTOR =
-    anyOf(staticCall(JAVA_UTIL_STREAM_COLLECTORS, "toList", "toSet", "toImmutableList", "toImmutableSet").parameterCount(0),
+    anyOf(staticCall(JAVA_UTIL_STREAM_COLLECTORS, "toList", "toSet", "toUnmodifiableList", "toUnmodifiableSet").parameterCount(0),
           staticCall(JAVA_UTIL_STREAM_COLLECTORS, "toCollection").parameterCount(1));
   private static final CallMatcher MAP_COLLECTOR =
-    staticCall(JAVA_UTIL_STREAM_COLLECTORS, "toMap", "toConcurrentMap", "toImmutableMap");
+    staticCall(JAVA_UTIL_STREAM_COLLECTORS, "toMap", "toConcurrentMap", "toUnmodifiableMap");
 
   private static final CallMatcher SKIP_STEP =
     instanceCall(JAVA_UTIL_STREAM_BASE_STREAM, "unordered", "parallel", "sequential").parameterCount(0);
@@ -773,7 +773,7 @@ public class StreamChainInliner implements CallInliner {
     if (COLLECTION_COLLECTOR.matches(collectorCall)) {
       String name = Objects.requireNonNull(collectorCall.getMethodExpression().getReferenceName());
       return new ToCollectionStep(call, ArrayUtil.getFirstElement(collectorCall.getArgumentList().getExpressions()),
-                                  name.startsWith("toImmutable"));
+                                  name.startsWith("toUnmodifiable"));
     }
     if (MAP_COLLECTOR.matches(collectorCall)) {
       PsiExpression[] args = collectorCall.getArgumentList().getExpressions();
@@ -783,7 +783,7 @@ public class StreamChainInliner implements CallInliner {
         PsiExpression merger = args.length >= 3 ? args[2] : null;
         PsiExpression supplier = args.length >= 4 ? args[3] : null;
         return new ToMapStep(call, keyExtractor, valueExtractor, merger, supplier,
-                             "toImmutableMap".equals(collectorCall.getMethodExpression().getReferenceName()));
+                             "toUnmodifiableMap".equals(collectorCall.getMethodExpression().getReferenceName()));
       }
     }
     return new UnknownTerminalStep(call);
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/StreamCollector10Inlining.java b/java/java-tests/testData/inspection/dataFlow/fixture/StreamCollector10Inlining.java
index e957fc7b83b5..397fc7711443 100644
--- a/java/java-tests/testData/inspection/dataFlow/fixture/StreamCollector10Inlining.java
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/StreamCollector10Inlining.java
@@ -10,9 +10,9 @@ import java.util.stream.*;
 // Mock
 class Collectors {
   public static <T> Collector<T, ?, List<T>> toList() {<error descr="Missing return statement">}</error>
-  public static <T> Collector<T, ?, List<T>> toImmutableList() {<error descr="Missing return statement">}</error>
-  public static <T> Collector<T, ?, Set<T>> toImmutableSet() {<error descr="Missing return statement">}</error>
-  public static <T, K, U> Collector<T, ?, Map<K,U>> toImmutableMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {<error descr="Missing return statement">}</error>
+  public static <T> Collector<T, ?, List<T>> toUnmodifiableList() {<error descr="Missing return statement">}</error>
+  public static <T> Collector<T, ?, Set<T>> toUnmodifiableSet() {<error descr="Missing return statement">}</error>
+  public static <T, K, U> Collector<T, ?, Map<K,U>> toUnmodifiableMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {<error descr="Missing return statement">}</error>
 }
 
 public class StreamCollector10Inlining {
@@ -30,20 +30,20 @@ public class StreamCollector10Inlining {
   void testToImmutableList() {
     List<String> list = Stream.of("foo", "bar", "baz")
                               .map(<warning descr="Function may return null, but it's not allowed here">this::convert</warning>)
-                              .collect(Collectors.toImmutableList());
+                              .collect(Collectors.toUnmodifiableList());
     list.<warning descr="Immutable object is modified">sort</warning>(null);
   }
 
   void testToImmutableSet() {
     Set<String> set = Stream.of("foo", "bar", "baz")
                             .map(<warning descr="Function may return null, but it's not allowed here">this::convert</warning>)
-                            .collect(Collectors.toImmutableSet());
+                            .collect(Collectors.toUnmodifiableSet());
     set.<warning descr="Immutable object is modified">add</warning>("qux");
   }
 
   void testToImmutableMap() {
     Map<String, String> map = Stream.of("foo", "bar", "baz", "")
-      .collect(Collectors.toImmutableMap(<warning descr="Function may return null, but it's not allowed here">this::convert</warning>, <warning descr="Function may return null, but it's not allowed here">this::convert</warning>));
+      .collect(Collectors.toUnmodifiableMap(<warning descr="Function may return null, but it's not allowed here">this::convert</warning>, <warning descr="Function may return null, but it's not allowed here">this::convert</warning>));
     map.<warning descr="Immutable object is modified">put</warning>("qux", "qux");
   }
 }