Java 12-17API additions

dev/core/src/com/google/gwt/dev/javac/testing/impl/JavaResourceBase.java

@@ -82,6 +82,7 @@ public class JavaResourceBase {
           "public interface CharSequence {",
           "  char charAt(int index);",
           "  int length();",
+          "  default boolean isEmpty() { return length() == 0; }",
           "  String toString();",
           "}");
 
@@ -345,7 +346,6 @@ public class JavaResourceBase {
           "  }",
           "  private native boolean equals(String obj) /*-{ return false; }-*/;",
           "  public boolean equalsIgnoreCase(String str) { return false; }",
-          "  public native boolean isEmpty() /*-{ return true; }-*/;",
           "  public int length() { return 0; }",
           "  public static String valueOf(int i) { return \"\" + i; }",
           "  public static String valueOf(char c) { return \"\" + c; }",

tools/api-checker/config/gwt212_213userapi.conf

@@ -156,6 +156,8 @@ java.lang.Deprecated MISSING
 java.lang.FunctionalInterface MISSING
 java.lang.Override MISSING
 java.lang.SafeVarargs MISSING
+# Moved to CharSequence as a default method
+java.lang.String::isEmpty() MISSING
 java.lang.SuppressWarnings MISSING
 java.lang.annotation.AnnotationTypeMismatchException MISSING
 java.lang.annotation.Documented MISSING

user/super/com/google/gwt/emul/java/lang/CharSequence.java

@@ -58,6 +58,38 @@ public boolean hasNext() {
     }, Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED, false);
   }
 
+  default IntStream codePoints() {
+    return  StreamSupport.intStream(() -> {
+      PrimitiveIterator.OfInt it = new PrimitiveIterator.OfInt() {
+        int cursor;
+
+        @Override
+        public int nextInt() {
+          checkElement(hasNext());
+          int codePoint = CharSequence.this.toString().codePointAt(cursor++);
+          if (codePoint >= 1 << 16) {
+            cursor++;
+          }
+          return codePoint;
+        }
+
+        @Override
+        public boolean hasNext() {
+          return cursor < length();
+        }
+      };
+      return Spliterators.spliterator(it, length(), Spliterator.ORDERED);
+    }, Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED, false);
+  }
+
+  default boolean isEmpty() {
+    return length() == 0;
+  }
+
+  static int compare(CharSequence cs1, CharSequence cs2) {
+    return cs1.toString().compareTo(cs2.toString());
+  }
+
   // CHECKSTYLE_OFF: Utility methods.
   @JsMethod
   static boolean $isInstance(HasCharSequenceTypeMarker instance) {

user/super/com/google/gwt/emul/java/lang/String.java

@@ -27,11 +27,14 @@
 import java.nio.charset.Charset;
 import java.nio.charset.UnsupportedCharsetException;
 import java.util.Comparator;
+import java.util.List;
 import java.util.Locale;
 import java.util.Spliterator;
 import java.util.Spliterators;
 import java.util.StringJoiner;
 import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 import javaemul.internal.ArrayHelper;
@@ -488,10 +491,6 @@ public String intern() {
     return checkNotNull(this);
   }
 
-  public boolean isEmpty() {
-    return length() == 0;
-  }
-
   public int lastIndexOf(int codePoint) {
     return lastIndexOf(fromCodePoint(codePoint));
   }
@@ -791,6 +790,10 @@ public String repeat(int count) {
     return asNativeString().repeat(count);
   }
 
+  public <R> R transform(Function<? super String,? extends R> f) {
+    return f.apply(this);
+  }
+
   private int getLeadingWhitespaceLength() {
     int length = length();
     for (int i = 0; i < length; i++) {
@@ -811,6 +814,131 @@ private int getTrailingWhitespaceLength() {
     return length;
   }
 
+  public String indent(int spaces) {
+    if (isEmpty()) {
+      return "";
+    }
+    Stream<String> indentedLines;
+    if (spaces >= 0) {
+      String spaceString = " ".repeat(spaces);
+      indentedLines = lines().map(line -> spaceString + line);
+    } else {
+      indentedLines = lines().map(
+          line -> line.substring(Math.min(-spaces, line.getLeadingWhitespaceLength())));
+    }
+    return indentedLines.collect(Collectors.joining("\n", "", "\n"));
+  }
+
+  public String stripIndent() {
+    if (isEmpty()) {
+      return "";
+    }
+    List<String> lines = lines().collect(Collectors.toList());
+    int minIndent;
+    char lastChar = charAt(length() - 1);
+    String suffix = "";
+    if (lastChar != '\r' && lastChar != '\n') {
+      minIndent = Integer.MAX_VALUE;
+      for (int i = 0; i < lines.size() - 1; i++) {
+        String line = lines.get(i);
+        int leadingWhitespace = line.getLeadingWhitespaceLength();
+        // only update minIndent if not blank
+        if (leadingWhitespace < line.length()) {
+          minIndent = Math.min(minIndent, leadingWhitespace);
+        }
+      }
+      // the last line affects minIndent even if blank
+      minIndent = Math.min(minIndent, lines.get(lines.size() - 1).getLeadingWhitespaceLength());
+    } else {
+      suffix = "\n";
+      minIndent = 0;
+    }
+    final int outdent = minIndent;
+    return lines.stream().map(line -> {
+          if (line.isBlank()) {
+            return "";
+          }
+          return line.substring(outdent).stripTrailing();
+        })
+        .collect(Collectors.joining("\n", "", suffix));
+  }
+
+  public String translateEscapes() {
+    StringBuilder result = new StringBuilder();
+    int translated = 0;
+    while (translated < length()) {
+      int nextBackslash = indexOf("\\", translated);
+      if (nextBackslash == -1) {
+        result.append(substring(translated));
+        return result.toString();
+      }
+      if (nextBackslash == length() - 1) {
+        throw new IllegalArgumentException();
+      }
+      result.append(substring(translated, nextBackslash));
+      char currentChar = charAt(nextBackslash + 1);
+      translated = nextBackslash + 2;
+      switch (currentChar) {
+        case 'b':
+          result.append('\b');
+          break;
+        case 's':
+          result.append(' ');
+          break;
+        case 't':
+          result.append('\t');
+          break;
+        case 'n':
+          result.append('\n');
+          break;
+        case 'f':
+          result.append('\f');
+          break;
+        case 'r':
+          result.append('\r');
+          break;
+        case '\n':
+          // discard
+          break;
+        case '\r':
+          // discard \r and possibly \n that comes right after
+          if (translated < length() && charAt(translated) == '\n') {
+            translated++;
+          }
+          break;
+        case '"':
+          result.append('"');
+          break;
+        case '\'':
+          result.append('\'');
+          break;
+        case '\\':
+          result.append('\\');
+          break;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+          int unicode = currentChar - '0';
+          char nextChar = charAt(translated);
+          while (nextChar >= '0' && nextChar < '8' && unicode < 32) {
+            unicode = (unicode << 3) + (nextChar - '0');
+            translated++;
+            nextChar = translated < length() ? charAt(translated) : 0;
+          }
+          result.append((char) unicode);
+          break;
+        default:
+          throw new IllegalArgumentException();
+      }
+    }
+    return result.toString();
+  }
+
   private class LinesSpliterator extends Spliterators.AbstractSpliterator<String> {
     private int nextIndex = 0;
     private int rPosition = -1;

user/super/com/google/gwt/emul/java/util/BitSet.java

@@ -18,6 +18,9 @@
 
 import static javaemul.internal.InternalPreconditions.checkArraySize;
 
+import java.util.function.IntConsumer;
+import java.util.stream.IntStream;
+import java.util.stream.StreamSupport;
 import javaemul.internal.ArrayHelper;
 import javaemul.internal.LongUtils;
 
@@ -37,6 +40,37 @@ public class BitSet {
 
   private final int[] array;
 
+  private class BitSetSpliterator implements Spliterator.OfInt {
+    int nextBitIndex = 0;
+
+    @Override
+    public boolean tryAdvance(IntConsumer action) {
+      int nextBit = nextSetBit(nextBitIndex);
+      if (nextBit >= 0) {
+        nextBitIndex = nextBit + 1;
+        action.accept(nextBit);
+        return true;
+      }
+      return false;
+    }
+
+    @Override
+    public Spliterator.OfInt trySplit() {
+      return null;
+    }
+
+    @Override
+    public long estimateSize() {
+      return size();
+    }
+
+    @Override
+    public int characteristics() {
+      return Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED
+          | Spliterator.DISTINCT | Spliterator.SORTED;
+    }
+  }
+
   public BitSet() {
     array = new int[0];
   }
@@ -604,6 +638,11 @@ public int nextSetBit(int fromIndex) {
     return bitIndex(index) + Integer.numberOfTrailingZeros(word);
   }
 
+  public IntStream stream() {
+    Spliterator.OfInt spliterator = new BitSetSpliterator();
+    return StreamSupport.intStream(spliterator, false);
+  }
+
   public int previousClearBit(int fromIndex) {
     if (fromIndex == -1) {
       return -1;

user/super/com/google/gwt/emul/java/util/Map.java

@@ -276,6 +276,13 @@ static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V>
       return (Comparator<Map.Entry<K, V>> & Serializable)
           (a, b) -> cmp.compare(a.getValue(), b.getValue());
     }
+
+    static <K,V> Map.Entry<K,V> copyOf(Map.Entry<? extends K,? extends V> e) {
+      if (e instanceof AbstractMap.SimpleImmutableEntry) {
+        return (Entry<K, V>) e;
+      }
+      return entry(e.getKey(), e.getValue());
+    }
   }
 
   void clear();

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

@@ -16,6 +16,7 @@
 
 package java.util.stream;
 
+import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -33,6 +34,7 @@
 import java.util.Set;
 import java.util.StringJoiner;
 import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -71,6 +73,30 @@ public static <T, A, R, RR> Collector<T, A, RR> collectingAndThen(
         downstream.finisher().andThen(finisher));
   }
 
+  public static <T,R1,R2,R> Collector<T,?,R> teeing(Collector<? super T,?,R1> downstream1,
+      Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger) {
+    return teeing2(downstream1, downstream2, merger);
+  }
+
+  private static <T,R1,R2,R,X,Y> Collector<T,?,R> teeing2(Collector<? super T,X,R1> downstream1,
+      Collector<? super T,Y,R2> downstream2, BiFunction<? super R1,? super R2,R> merger) {
+     return Collector.of(
+        () -> new AbstractMap.SimpleEntry<>(downstream1.supplier().get(),
+            downstream2.supplier().get()),
+        (a,b) -> {
+          downstream1.accumulator().accept(a.getKey(), b);
+          downstream2.accumulator().accept(a.getValue(), b);
+        },
+        (a,b) -> {
+          X part = downstream1.combiner().apply(a.getKey(), b.getKey());
+          Y part2 = downstream2.combiner().apply(a.getValue(), b.getValue());
+          return new AbstractMap.SimpleEntry<>(part, part2);
+        },
+        (e) -> merger.apply(downstream1.finisher().apply(e.getKey()),
+            downstream2.finisher().apply(e.getValue()))
+     );
+  }
+
   public static <T> Collector<T,?,Long> counting() {
     // Using Long::sum here fails in JDT
     return reducing(0L, item -> 1L, (a, b) -> (Long) a.longValue() + b.longValue());

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

@@ -58,6 +58,15 @@ default DoubleStream.Builder add(double t) {
     DoubleStream build();
   }
 
+  /**
+   * See <a
+   * href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/stream/DoubleStream.DoubleMapMultiConsumer.html">
+   * the official Java API doc</a> for details.
+   */
+  interface DoubleMapMultiConsumer {
+    void accept(double value, DoubleConsumer consumer);
+  }
+
   static Builder builder() {
     return new Builder() {
       private double[] items = new double[0];
@@ -317,5 +326,13 @@ public boolean tryAdvance(DoubleConsumer action) {
     return StreamSupport.doubleStream(spliterator, false);
   }
 
+  default DoubleStream mapMulti(DoubleStream.DoubleMapMultiConsumer mapper) {
+    return flatMap(element -> {
+      Builder builder = builder();
+      mapper.accept(element, (DoubleConsumer) builder::add);
+      return builder.build();
+    });
+  }
+
   double[] toArray();
 }