Review feedback

Author: zbynek

user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java

@@ -330,9 +330,9 @@ public boolean tryAdvance(DoubleConsumer action) {
 
   default DoubleStream mapMulti(DoubleStream.DoubleMapMultiConsumer mapper) {
     return flatMap(element -> {
-      List<Double> buffer = new ArrayList<>();
-      mapper.accept(element, (DoubleConsumer) buffer::add);
-      return buffer.stream().mapToDouble(n -> n);
+      Builder builder = builder();
+      mapper.accept(element, (DoubleConsumer) builder::add);
+      return builder.build();
     });
   }
 

user/super/com/google/gwt/emul/java/util/stream/IntStream.java

@@ -379,9 +379,9 @@ public boolean tryAdvance(IntConsumer action) {
 
   default IntStream mapMulti(IntMapMultiConsumer mapper) {
     return flatMap(element -> {
-      List<Integer> buffer = new ArrayList<>();
-      mapper.accept(element, (IntConsumer) buffer::add);
-      return buffer.stream().mapToInt(n -> n);
+      Builder builder = builder();
+      mapper.accept(element, (IntConsumer) builder::add);
+      return builder.build();
     });
   }
 

user/super/com/google/gwt/emul/java/util/stream/LongStream.java

@@ -17,10 +17,8 @@
 
 import static javaemul.internal.InternalPreconditions.checkState;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
-import java.util.List;
 import java.util.LongSummaryStatistics;
 import java.util.OptionalDouble;
 import java.util.OptionalLong;
@@ -377,9 +375,9 @@ public boolean tryAdvance(LongConsumer action) {
 
   default LongStream mapMulti(LongStream.LongMapMultiConsumer mapper) {
     return flatMap(element -> {
-      List<Long> buffer = new ArrayList<>();
-      mapper.accept(element, (LongConsumer) buffer::add);
-      return buffer.stream().mapToLong(n -> n);
+      Builder builder = builder();
+      mapper.accept(element, (LongConsumer) builder::add);
+      return builder.build();
     });
   }
 

user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/util/stream/DoubleStreamTest.java

@@ -27,11 +27,10 @@ public void testMapMulti() {
       callback.accept(num + num);
     };
     assertEquals(new double[0],
-        hideFromCompiler(DoubleStream.of()).mapMulti(doubling).toArray());
+        DoubleStream.of().mapMulti(doubling).toArray());
     assertEquals(new double[]{1.0, 2.0, 3.0, 6.0},
-        hideFromCompiler(DoubleStream.of(1.0, 3.0)).mapMulti(doubling).toArray());
+        DoubleStream.of(1.0, 3.0).mapMulti(doubling).toArray());
     assertEquals(new double[0],
-        hideFromCompiler(DoubleStream.of(1.0, 2.0)).mapMulti((a, b) -> {
-        }).toArray());
+        DoubleStream.of(1.0, 2.0).mapMulti((a, b) -> {}).toArray());
   }
 }

user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/util/stream/IntStreamTest.java

@@ -28,11 +28,10 @@ public void testMapMulti() {
       callback.accept(num + num);
     };
     assertEquals(new int[0],
-        hideFromCompiler(IntStream.of()).mapMulti(doubling).toArray());
+        IntStream.of().mapMulti(doubling).toArray());
     assertEquals(new int[]{1, 2, 3, 6},
-        hideFromCompiler(IntStream.of(1, 3)).mapMulti(doubling).toArray());
+        IntStream.of(1, 3).mapMulti(doubling).toArray());
     assertEquals(new int[0],
-        hideFromCompiler(IntStream.of(1, 3)).mapMulti((a, b) -> {
-        }).toArray());
+        IntStream.of(1, 3).mapMulti((a, b) -> {}).toArray());
   }
 }

user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/util/stream/LongStreamTest.java

@@ -27,11 +27,10 @@ public void testMapMulti() {
       callback.accept(num + num);
     };
     assertEquals(new long[0],
-        hideFromCompiler(LongStream.of()).mapMulti(doubling).toArray());
+        LongStream.of().mapMulti(doubling).toArray());
     assertEquals(new long[]{1L, 2L, 3L, 6L},
-        hideFromCompiler(LongStream.of(1L, 3L)).mapMulti(doubling).toArray());
+        LongStream.of(1L, 3L).mapMulti(doubling).toArray());
     assertEquals(new long[0],
-        hideFromCompiler(LongStream.of(1L, 2L)).mapMulti((a, b) -> {
-        }).toArray());
+        LongStream.of(1L, 2L).mapMulti((a, b) -> {}).toArray());
   }
 }

user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/util/stream/StreamTest.java

@@ -40,12 +40,11 @@ public void testMapMulti() {
       callback.accept(str + str);
     };
     assertEquals(Arrays.asList(),
-        this.<Stream<String>>hideFromCompiler(Stream.of()).<String>mapMulti(doubling).toList());
+        Stream.<String>of().mapMulti(doubling).toList());
     assertEquals(Arrays.asList("a", "aa", "b", "bb"),
-        hideFromCompiler(Stream.of("a", "b")).<String>mapMulti(doubling).toList());
+        Stream.of("a", "b")).<String>mapMulti(doubling).toList());
     assertEquals(Arrays.asList(),
-        hideFromCompiler(Stream.of("a", "b")).mapMulti((a, b) -> {
-        }).toList());
+        Stream.of("a", "b").mapMulti((a, b) -> {}).toList());
   }
 
   public void testMapMultiToInt() {
@@ -54,12 +53,11 @@ public void testMapMultiToInt() {
       callback.accept(str.length() * 2);
     };
     assertEquals(new int[]{1, 2, 3, 6},
-        hideFromCompiler(Stream.of("a", "bbb")).mapMultiToInt(doubling).toArray());
+        Stream.of("a", "bbb").mapMultiToInt(doubling).toArray());
     assertEquals(new int[0],
-        hideFromCompiler(Stream.<String>of()).mapMultiToInt(doubling).toArray());
+        Stream.<String>of().mapMultiToInt(doubling).toArray());
     assertEquals(new int[0],
-        hideFromCompiler(Stream.of("a", "b")).mapMultiToInt((a, b) -> {
-        }).toArray());
+        Stream.of("a", "b").mapMultiToInt((a, b) -> {}).toArray());
   }
 
   public void testMapMultiToLong() {
@@ -68,11 +66,11 @@ public void testMapMultiToLong() {
       callback.accept(str.length() * 2L);
     };
     assertEquals(new long[]{1L, 2L, 3L, 6L},
-        hideFromCompiler(Stream.of("a", "bbb")).mapMultiToLong(doubling).toArray());
+        Stream.of("a", "bbb").mapMultiToLong(doubling).toArray());
     assertEquals(new long[0],
-        hideFromCompiler(Stream.<String>of()).mapMultiToLong(doubling).toArray());
+        Stream.<String>of().mapMultiToLong(doubling).toArray());
     assertEquals(new long[0],
-        hideFromCompiler(Stream.of("a", "b")).mapMultiToLong((a, b) -> {
+        Stream.of("a", "b").mapMultiToLong((a, b) -> {
         }).toArray());
   }
 
@@ -82,11 +80,10 @@ public void testMapMultiToDouble() {
       callback.accept(str.length() * 2);
     };
     assertEquals(new double[]{1.0, 2.0, 3.0, 6.0},
-        hideFromCompiler(Stream.of("a", "bbb")).mapMultiToDouble(doubling).toArray());
+        Stream.of("a", "bbb").mapMultiToDouble(doubling).toArray());
     assertEquals(new double[0],
-        hideFromCompiler(Stream.<String>of()).mapMultiToDouble(doubling).toArray());
+        Stream.<String>of().mapMultiToDouble(doubling).toArray());
     assertEquals(new double[0],
-        hideFromCompiler(Stream.of("a", "b")).mapMultiToDouble((a, b) -> {
-        }).toArray());
+        Stream.of("a", "b").mapMultiToDouble((a, b) -> {}).toArray());
   }
 }

user/test/com/google/gwt/emultest/EmulJava17Suite.java

@@ -17,6 +17,7 @@
 
 import com.google.gwt.emultest.java17.lang.CharSequenceTest;
 import com.google.gwt.emultest.java17.lang.StringTest;
+import com.google.gwt.emultest.java17.util.MapEntryTest;
 import com.google.gwt.emultest.java17.util.stream.CollectorsTest;
 import com.google.gwt.emultest.java17.util.stream.DoubleStreamTest;
 import com.google.gwt.emultest.java17.util.stream.IntStreamTest;
@@ -35,7 +36,8 @@
     StreamTest.class,
     DoubleStreamTest.class,
     IntStreamTest.class,
-    LongStreamTest.class
+    LongStreamTest.class,
+    MapEntryTest.class
 })
 public class EmulJava17Suite {
 }

user/test/com/google/gwt/emultest/java17/lang/StringTest.java

@@ -35,6 +35,10 @@ public void testIndent() {
     assertFalse(isGwtSourceLevel17());
   }
 
+  public void testStripIndent() {
+    assertFalse(isGwtSourceLevel17());
+  }
+
   public void testTranslateEscapes() {
     assertFalse(isGwtSourceLevel17());
   }