diff --git a/build_tools/doctool/src/com/google/doctool/custom/JavaEmulSummaryDoclet.java b/build_tools/doctool/src/com/google/doctool/custom/JavaEmulSummaryDoclet.java
index ba0d8eb0f27..b3605f8db04 100644
--- a/build_tools/doctool/src/com/google/doctool/custom/JavaEmulSummaryDoclet.java
+++ b/build_tools/doctool/src/com/google/doctool/custom/JavaEmulSummaryDoclet.java
@@ -16,281 +16,510 @@
 
 package com.google.doctool.custom;
 
-import jdk.javadoc.doclet.Doclet;
-import jdk.javadoc.doclet.DocletEnvironment;
-import jdk.javadoc.doclet.Reporter;
-
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.PackageElement;
-import javax.lang.model.type.ArrayType;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-import javax.tools.Diagnostic;
-import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.io.PrintWriter;
+import java.io.UncheckedIOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Optional;
+import java.util.Properties;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.tools.Diagnostic;
+
+import jdk.javadoc.doclet.Doclet;
+import jdk.javadoc.doclet.DocletEnvironment;
+import jdk.javadoc.doclet.Reporter;
+
 /**
  * A doclet for listing the specified classes and
  * their methods and constructors.
  */
 public class JavaEmulSummaryDoclet implements Doclet {
 
-    public static final String OPT_OUTFILE = "-outfile";
-    private static final String JAVADOC_URL = "https://docs.oracle.com/en/java/javase/11/docs/api/";
+  public static final String OPT_OUT_FILE = "-outFile";
+  public static final String OPT_MISSING_FILE = "-missingFile";
+  public static final String OPT_TRIAGE_FILE = "-triageFile";
+  public static final String OPT_MISSING_PROPERTIES_DIR = "-missingProperties";
+  // should be aligned with the latest version that's tested by CI
+  private static final int MAX_JRE_VERSION = 22;
+  // Lowest version for which missing method detection is reliable.
+  // The tool can run with older versions, but will ignore missing methods.
+  private static final int MIN_JRE_VERSION = 17;
+  private static final int CURRENT_JRE_VERSION = Runtime.version().feature();
+  private static final String JAVADOC_URL = "https://docs.oracle.com/en/java/javase/"
+      + CURRENT_JRE_VERSION + "/docs/api/";
+  private static final List<String> DEPRECATED = List.of(
+      "java.lang.Character#isJavaLetter(char)",
+      "java.lang.Character#isJavaLetterOrDigit(char)",
+      "java.lang.String#getBytes(int, int, byte[], int)",
+      "java.lang.Class#isUnnamedClass()" // exists in 21 as a preview, removed
+  );
+  private enum Status {
+    OPEN("\u23F3", "Planned to be implemented, patches or reviews welcome"),
+    EVALUATING("\uD83E\uDD14", "Evaluating feasibility"),
+    EXTERNAL("\uD83E\uDDE9", "Workaround available via external library"),
+    WONTFIX("\u274C", "Won't be implemented");
+    final String title;
+    final String icon;
+    Status(String icon, String title) {
+      this.icon = icon;
+      this.title = title;
+    }
+  }
+
+  private Reporter reporter;
+  private String outputFile;
+  private String missingFile;
+  private String triageFile;
+  private String missingPropertiesDir;
+
+  private final Map<String, String> issueToSignatures = new HashMap<>();
+  private final Map<String, String> issueToTitle = new HashMap<>();
+  private final Map<String, String> issueStatus = new HashMap<>();
+  private final List<String> triage = new ArrayList<>();
+
+  @Override
+  public boolean run(DocletEnvironment env) {
+    loadMissingMemberLists();
+    try (PrintWriter pwPresent = createPrintWriter(outputFile);
+         PrintWriter pwMissing = createPrintWriter(missingFile)) {
+      pwPresent.println("<ol class=\"toc\" id=\"pageToc\">");
+      getSpecifiedPackages(env)
+          .forEach(pack ->
+              pwPresent.format("  <li><a href=\"#Package_%s\">%s</a></li>\n",
+                  pack.getQualifiedName().toString().replace('.', '_'),
+                  pack.getQualifiedName().toString()));
+
+      pwPresent.println("</ol>\n");
+      Set<String> allClasses = getSpecifiedPackages(env)
+        .flatMap(pack -> pack.getEnclosedElements().stream()
+        .flatMap(clazz -> withInnerClasses(clazz, pack)))
+        .collect(Collectors.toSet());
+      getSpecifiedPackages(env).forEach(pack -> {
+        Optional<Module> matchingModuleName = ModuleLayer.boot().modules().stream()
+            .filter(m -> m.getPackages().contains(pack.getQualifiedName().toString()))
+            .findFirst();
+
+        pwPresent.format("<h2 id=\"Package_%s\">Package %s</h2>%n<dl>%n",
+            pack.getQualifiedName().toString().replace('.', '_'),
+            pack.getQualifiedName().toString());
+        pwMissing.format("<h2 id=\"Package_%s\">Package %s</h2>%n<dl>%n",
+            pack.getQualifiedName().toString().replace('.', '_'),
+            pack.getQualifiedName().toString());
+
+        String packURL = JAVADOC_URL
+            + matchingModuleName.map(m -> m.getName() + "/").orElse("")
+            + pack.getQualifiedName().toString().replace(".", "/") + "/";
+
+        pack.getEnclosedElements()
+            .stream()
+            .filter(element -> env.isSelected(element) && env.isIncluded(element))
+            .filter(element -> element.getModifiers().contains(Modifier.PUBLIC))
+            .sorted(Comparator.comparing((Element o) -> o.getSimpleName()
+                .toString()))
+            .forEach(cls -> emitClassDocs(env, pwPresent, pwMissing,
+                packURL, cls, pack.getQualifiedName().toString() + ".", allClasses));
+
+        pwPresent.println("</dl>\n");
+        pwMissing.println("</dl>\n");
+      });
+      if (!triage.isEmpty() && CURRENT_JRE_VERSION >= MIN_JRE_VERSION) {
+        Files.writeString(Path.of(triageFile),
+            "members=" + String.join("\\\n", triage));
+        throw new IllegalStateException("Missing methods found, check triage.properties " +
+            "and split it into gh*.properties files");
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
 
-    private Reporter reporter;
-    private String outputFile;
+    return true;
+  }
 
-    @Override
-    public boolean run(DocletEnvironment env) {
-        try {
+  private PrintWriter createPrintWriter(String filePath) throws IOException {
+    Path path = Path.of(filePath);
+    Files.createDirectories(path.getParent());
+    OutputStream fwPresent = Files.newOutputStream(path);
+    return new PrintWriter(fwPresent, true);
+  }
 
-            File outFile = new File(outputFile);
-            outFile.getParentFile().mkdirs();
-            try (FileWriter fw = new FileWriter(outFile);
-                 PrintWriter pw = new PrintWriter(fw, true)) {
-
-                pw.println("<ol class=\"toc\" id=\"pageToc\">");
-                getSpecifiedPackages(env)
-                        .forEach(pack -> {
-                            pw.format("  <li><a href=\"#Package_%s\">%s</a></li>\n",
-                                    pack.getQualifiedName()
-                                            .toString().replace('.', '_'),
-                                    pack.getQualifiedName().toString());
-                        });
-
-                pw.println("</ol>\n");
-
-                getSpecifiedPackages(env).forEach(pack -> {
-                    Optional<Module> matchingModuleName = ModuleLayer.boot().modules().stream()
-                            .filter(m -> m.getPackages().contains(pack.getQualifiedName().toString()))
-                            .findFirst();
-
-                    pw.format("<h2 id=\"Package_%s\">Package %s</h2>\n",
-                            pack.getQualifiedName().toString().replace('.', '_'),
-                            pack.getQualifiedName().toString());
-                    pw.println("<dl>");
-
-                    String packURL = JAVADOC_URL
-                            + matchingModuleName.map(m -> m.getName() + "/").orElse("")
-                            + pack.getQualifiedName().toString().replace(".", "/") + "/";
-
-                    Iterator<? extends Element> classesIterator = pack.getEnclosedElements()
-                            .stream()
-                            .filter(element -> env.isSelected(element) && env.isIncluded(element))
-                            .filter(element -> element.getModifiers().contains(Modifier.PUBLIC))
-                            .sorted(Comparator.comparing((Element o) -> o.getSimpleName()
-                                    .toString()))
-                            .iterator();
-
-                    while (classesIterator.hasNext()) {
-                        Element cls = classesIterator.next();
-                        // Each class links to Oracle's main JavaDoc
-                        emitClassDocs(env, pw, packURL, cls);
-                        if (classesIterator.hasNext()) {
-                            pw.print("\n");
-                        }
-                    }
-
-                    pw.println("</dl>\n");
-                });
-            }
-        } catch (IOException e) {
-            throw new RuntimeException(e);
+  private void loadMissingMemberLists() {
+    final Properties properties = new Properties();
+    try (Stream<Path> str = Files.list(Path.of(missingPropertiesDir))) {
+      str.filter(file -> !file.getFileName().toString().startsWith("triage")).forEach(file -> {
+        try {
+          properties.clear();
+          properties.load(Files.newInputStream(file));
+          String issue = file.getFileName().toString().replaceAll("gh|\\.properties", "");
+          issueToSignatures.put(issue, (String) properties.get("members"));
+          issueToTitle.put(issue, (String) properties.get("title"));
+          issueStatus.put(issue, (String) properties.getOrDefault("status", "open"));
+        } catch (IOException ex) {
+          throw new UncheckedIOException(ex);
         }
-
-        return true;
+      });
+    } catch (IOException ex) {
+      throw new UncheckedIOException(ex);
+    }
+  }
+
+  private Stream<String> withInnerClasses(Element clazz, PackageElement pack) {
+    return Stream.concat(
+      Stream.of(pack.getQualifiedName() + "." + clazz.getSimpleName().toString()),
+      clazz.getEnclosedElements().stream()
+        .map(inner -> pack.getQualifiedName()
+          + "." + clazz.getSimpleName() + "$" + inner.getSimpleName()));
+  }
+
+  private void emitClassDocs(DocletEnvironment env, PrintWriter pwPresent,
+                 PrintWriter pwMissing, String packURL, Element cls,
+                 String pack, Set<String> allClasses) {
+    pwPresent.format("%n  <dt><a href=\"%s%s.html\">%s</a></dt>\n", packURL,
+        qualifiedSimpleName(cls), qualifiedSimpleName(cls));
+    if ("JsException".equals(cls.getSimpleName().toString())) {
+      return;
+    }
+    // Print out all fields
+    List<String> fields = cls.getEnclosedElements()
+        .stream()
+        .filter(element -> element.getKind().isField())
+        .filter(field -> field.getModifiers().contains(Modifier.PUBLIC))
+        .map(field -> field.getSimpleName().toString())
+        .collect(Collectors.toList());
+
+    if (!fields.isEmpty()) {
+      pwPresent.format("  <dd style='margin-bottom: 0.5em;'><strong>Fields:</strong> %s</dd>\n",
+          String.join(", ", fields));
     }
 
-    private void emitClassDocs(DocletEnvironment env, PrintWriter pw, String packURL, Element cls) {
-        pw.format("  <dt><a href=\"%s%s.html\">%s</a></dt>\n", packURL,
-                qualifiedSimpleName(cls), qualifiedSimpleName(cls));
+    List<String> constructors = cls.getEnclosedElements()
+        .stream()
+        .filter(element -> ElementKind.CONSTRUCTOR == element.getKind())
+        .filter(member -> member.getModifiers().contains(Modifier.PUBLIC))
+        .map(member -> (ExecutableElement) member)
+        .map(executableElement ->
+            flatSignature(t -> simpleParamName(env, t), cls, executableElement))
+        .collect(Collectors.toList());
 
-        // Print out all fields
-        String fields = cls.getEnclosedElements()
-                .stream()
-                .filter(element -> element.getKind().isField())
-                .filter(field -> field.getModifiers().contains(Modifier.PUBLIC))
-                .map(field -> field.getSimpleName().toString())
-                .collect(Collectors.joining(", "));
+    List<String> methods = getMethodNames(cls, t -> simpleParamName(env, t));
 
-        if (!fields.isEmpty()) {
-            pw.format("  <dd style='margin-bottom: 0.5em;'>%s</dd>\n", fields);
-        }
+    List<String> erasedMethods = getMethodNames(cls, t -> erasedParamName(env, t));
 
-        List<String> constructors = cls.getEnclosedElements()
-                .stream()
-                .filter(element -> ElementKind.CONSTRUCTOR == element.getKind())
-                .filter(member -> member.getModifiers().contains(Modifier.PUBLIC))
-                .map(member -> (ExecutableElement) member)
-                .map(executableElement -> flatSignature(env, cls, executableElement))
-                .collect(Collectors.toList());
-
-        List<String> methods = cls.getEnclosedElements()
-                .stream()
-                .filter(element -> ElementKind.METHOD == element.getKind())
-                .filter(member -> member.getModifiers().contains(Modifier.PUBLIC))
-                .map(member -> (ExecutableElement) member)
-                .map(executableElement -> flatSignature(env, cls, executableElement))
-                .collect(Collectors.toList());
-
-        List<String> members = new ArrayList<>(constructors);
-        members.addAll(methods);
-
-        // Print out all constructors and methods
-        if (!members.isEmpty()) {
-            pw.format("  <dd>%s</dd>\n", createMemberList(members));
-        }
-
-        Iterator<? extends Element> classesIterator = cls.getEnclosedElements()
-                .stream()
-                .filter(element -> element.getKind().isClass()
-                        || element.getKind().isInterface()
-                        || ElementKind.ENUM == element.getKind())
-                .filter(element -> element.getModifiers().contains(Modifier.PUBLIC))
-                .sorted(Comparator.comparing((Element o) -> o.getSimpleName().toString()))
-                .iterator();
-        if (classesIterator.hasNext()) {
-            pw.print("\n");
-        }
-        while (classesIterator.hasNext()) {
-            Element innerCls = classesIterator.next();
-            // Each class links to Sun's main JavaDoc
-            emitClassDocs(env, pw, packURL, innerCls);
-            if (classesIterator.hasNext()) {
-                pw.print("\n");
-            }
-        }
+    if (!constructors.isEmpty()) {
+      pwPresent.format("  <dd><strong>Constructors:</strong> %s</dd>\n",
+        createMemberList(constructors));
     }
-
-    private String createMemberList(Collection<String> members) {
-        StringBuilder sb = new StringBuilder();
-        Iterator<String> iter = members.iterator();
-        while (iter.hasNext()) {
-            String member = iter.next();
-            sb.append(member);
-            if (iter.hasNext()) {
-                sb.append(", ");
-            }
-        }
-        return sb.toString();
+    // Print out all constructors and methods
+    if (!methods.isEmpty()) {
+      pwPresent.format("  <dd><strong>Methods:</strong> %s</dd>\n",
+        createMemberList(methods));
     }
-
-    private String qualifiedSimpleName(Element element) {
-        String elementName = element.getSimpleName().toString();
-        if (ElementKind.PACKAGE != element.getEnclosingElement().getKind()) {
-            return qualifiedSimpleName(element.getEnclosingElement()) + "." + elementName;
-        }
-        return elementName;
+    String[] parts = (pack + cls.getSimpleName()).split("\\$");
+    List<String> missingMembers = new ArrayList<>();
+    Class<?> c;
+    try {
+      c = Class.forName(parts[0]);
+    } catch (ClassNotFoundException e) {
+      c = null;
     }
-
-    private String flatSignature(DocletEnvironment env, Element parent, ExecutableElement member) {
-        return (ElementKind.CONSTRUCTOR == member.getKind()
-                ? parent.getSimpleName().toString()
-                : member.getSimpleName().toString()) +
-                "(" + member.getParameters()
-                .stream()
-                .map(Element::asType)
-                .map(t -> simpleParamName(env, t))
-                .collect(Collectors.joining(", ")) + ")";
+    if (c != null && parts.length > 1) {
+      c = Arrays.stream(c.getDeclaredClasses())
+        .filter(inner -> inner.getSimpleName().equals(cls.getSimpleName().toString()))
+        .findFirst().orElse(null);
+    }
+    if (c == null) {
+      if (CURRENT_JRE_VERSION >= MAX_JRE_VERSION) {
+        throw new RuntimeException("Class does not exist in JRE: " + parts[0]);
+      } else {
+        System.out.format("Class %s not supported in Java %s%n", parts[0], CURRENT_JRE_VERSION);
+        return;
+      }
+    }
+    Class<?> superclass = c.getSuperclass() != null ? c.getSuperclass() : Object.class;
+    List<Method> superMethods = new ArrayList<>(Arrays.asList(superclass.getMethods()));
+
+    for (Class<?> parentInterface: c.getInterfaces()) {
+      if (!allClasses.contains(parentInterface.getTypeName())) {
+        System.out.println("Missing interface for " + c + ": " + parentInterface.getTypeName());
+      }
+      superMethods.addAll(Arrays.asList(parentInterface.getMethods()));
+    }
+    for (Method method: c.getDeclaredMethods()) {
+      String reflectionSignature = getReflectionSignature(method);
+      if (java.lang.reflect.Modifier.isPublic(method.getModifiers())
+          && !erasedMethods.contains(reflectionSignature)
+          && !DEPRECATED.contains(pack + cls.getSimpleName() + "#" + reflectionSignature)
+          && !reflectionSignature.matches("of\\(Enum(, Enum)+\\)")
+          && superMethods.stream().noneMatch(m ->
+              nameAndParamCount(m).equals(nameAndParamCount(method)))) {
+        missingMembers.add(reflectionSignature);
+      } else if (!"".equals(getStatus(pack + cls.getSimpleName() + "#" + reflectionSignature))) {
+        System.out.println("No longer missing: " + reflectionSignature);
+      }
+    }
+    for (Field field: c.getFields()) {
+      if (java.lang.reflect.Modifier.isPublic(field.getModifiers())
+          && !fields.contains(field.getName())
+          && !isFieldFromSuper(field, c)) {
+        missingMembers.add(field.getName());
+      }
     }
 
-    private String simpleParamName(DocletEnvironment env, TypeMirror type) {
-        if (type.getKind().isPrimitive() || TypeKind.TYPEVAR == type.getKind()) {
-            return String.valueOf(type);
-        } else if (TypeKind.ARRAY == type.getKind()) {
-            return simpleParamName(env, ((ArrayType) type).getComponentType()) + "[]";
-        } else {
-            return qualifiedSimpleName(env.getTypeUtils().asElement(type));
+    if (!missingMembers.isEmpty()) {
+      Map<String, List<String>> missingMemberGroups = missingMembers.stream()
+          .collect(Collectors.groupingBy(signature ->
+              getStatus(pack + cls.getSimpleName() + "#" + signature)));
+      if (missingMemberGroups.containsKey("")) {
+        missingMemberGroups.get("").stream()
+            .map(s -> pack + cls.getSimpleName() + "#" + s)
+            .forEach(triage::add);
+      }
+      pwMissing.format("%n  <dt><a href=\"%s%s.html\">%s</a></dt>%n", packURL,
+        qualifiedSimpleName(cls), qualifiedSimpleName(cls));
+      for (Map.Entry<String, List<String>> entry: missingMemberGroups.entrySet()) {
+        pwMissing.format("  <dd><strong><a href=\"https://github.com/gwtproject/gwt/issues/%s\">%s</a>:</strong> %s</dd>%n",
+          entry.getKey(),
+          getIssueTitle(entry.getKey()),
+          createMemberList(entry.getValue()));
+      }
+    }
+    Iterator<? extends Element> classesIterator = cls.getEnclosedElements()
+        .stream()
+        .filter(element -> element.getKind().isClass()
+            || element.getKind().isInterface()
+            || ElementKind.ENUM == element.getKind())
+        .filter(element -> element.getModifiers().contains(Modifier.PUBLIC))
+        .sorted(Comparator.comparing((Element o) -> o.getSimpleName().toString()))
+        .iterator();
+    if (classesIterator.hasNext()) {
+      pwPresent.print("\n");
+    }
+    while (classesIterator.hasNext()) {
+      Element innerCls = classesIterator.next();
+      // Each class links to Sun's main JavaDoc
+      emitClassDocs(env, pwPresent, pwMissing, packURL, innerCls,
+        pack + cls.getSimpleName() + "$", allClasses);
+      if (classesIterator.hasNext()) {
+        pwPresent.print("\n");
+      }
+    }
+  }
+  private Object getIssueTitle(String key) {
+    if (key.isEmpty()) {
+      return "Needs triage";
+    }
+    String title = issueToTitle.get(key);
+    Status status = Status.valueOf(issueStatus.get(key).toUpperCase(Locale.ROOT));
+    return "<span title=\"" + status.title + "\">" + status.icon
+        + "</span>#" + key + (title == null ? "" : " (" + title + ")");
+  }
+
+  private boolean isFieldFromSuper(Field field, Class<?> c) {
+    for (Class<?> parentInterface: c.getInterfaces()) {
+      for (Field parent : parentInterface.getFields()) {
+        if (parent.equals(field)) {
+          return true;
         }
+      }
     }
-
-    @Override
-    public void init(Locale locale, Reporter reporter) {
-        this.reporter = reporter;
+    Class<?> superClass = c.getSuperclass();
+    while (superClass != null) {
+      for (Field parent : superClass.getFields()) {
+        if (parent.equals(field)) {
+          return true;
+        }
+      }
+      superClass = superClass.getSuperclass();
     }
-
-    @Override
-    public String getName() {
-        return "JreEmulationSummaryDoclet";
+    return false;
+  }
+
+  private String getStatus(String methodRef) {
+    for (String category: issueToSignatures.keySet()) {
+      if (issueToSignatures.get(category).contains(methodRef)) {
+        return category;
+      }
     }
-
-    @Override
-    public Set<? extends Option> getSupportedOptions() {
-        Option[] options = {
-                new Option() {
-
-                    @Override
-                    public int getArgumentCount() {
-                        return 1;
-                    }
-
-                    @Override
-                    public String getDescription() {
-                        return "JRE emulation summary Doc location";
-                    }
-
-                    @Override
-                    public Kind getKind() {
-                        return Kind.STANDARD;
-                    }
-
-                    @Override
-                    public List<String> getNames() {
-                        return List.of(OPT_OUTFILE);
-                    }
-
-                    @Override
-                    public String getParameters() {
-                        return "file";
-                    }
-
-                    @Override
-                    public boolean process(String opt, List<String> arguments) {
-                        if (arguments.isEmpty()) {
-                            reporter.print(Diagnostic.Kind.ERROR,
-                                    "You must specify an output filepath with "
-                                            + OPT_OUTFILE);
-                            return false;
-                        }
-                        reporter.print(Diagnostic.Kind.NOTE,
-                                "JRE emulation summary Doclet Option : "
-                                + arguments.get(0));
-                        outputFile = arguments.get(0);
-                        return true;
-                    }
-                }
-        };
-        return new HashSet<>(Arrays.asList(options));
+    return "";
+  }
+
+  private List<String> getMethodNames(Element cls, Function<TypeMirror, String> typeNamer) {
+    return cls.getEnclosedElements()
+      .stream()
+      .filter(element -> ElementKind.METHOD == element.getKind())
+      .filter(member -> member.getModifiers().contains(Modifier.PUBLIC))
+      .map(member -> (ExecutableElement) member)
+      .map(executableElement -> flatSignature(typeNamer, cls, executableElement))
+      .collect(Collectors.toList());
+  }
+
+  private String nameAndParamCount(Method m) {
+    return m.getName() + ":" + m.getParameterCount();
+  }
+
+  private String getReflectionSignature(Method method) {
+    return method.getName() + "(" + Arrays.stream(method.getParameters())
+      .map(param -> param.getType().getSimpleName())
+      .collect(Collectors.joining(", ")) + ")";
+  }
+
+  private String createMemberList(Collection<String> members) {
+    return String.join(", ", members);
+  }
+
+  private String qualifiedSimpleName(Element element) {
+    String elementName = element.getSimpleName().toString();
+    if (ElementKind.PACKAGE != element.getEnclosingElement().getKind()) {
+      return qualifiedSimpleName(element.getEnclosingElement()) + "." + elementName;
     }
-
-    @Override
-    public SourceVersion getSupportedSourceVersion() {
-        return SourceVersion.latestSupported();
+    return elementName;
+  }
+
+  private String flatSignature(Function<TypeMirror, String> namer,
+       Element parent, ExecutableElement member) {
+    return (ElementKind.CONSTRUCTOR == member.getKind()
+        ? parent.getSimpleName().toString()
+        : member.getSimpleName().toString()) +
+        "(" + member.getParameters()
+        .stream()
+        .map(Element::asType)
+        .map(namer)
+        .collect(Collectors.joining(", ")) + ")";
+  }
+
+  private String simpleParamName(DocletEnvironment env, TypeMirror type) {
+    if (type.getKind().isPrimitive() || TypeKind.TYPEVAR == type.getKind()) {
+      return String.valueOf(type);
+    } else if (TypeKind.ARRAY == type.getKind()) {
+      return simpleParamName(env, ((ArrayType) type).getComponentType()) + "[]";
+    } else {
+      return qualifiedSimpleName(env.getTypeUtils().asElement(type));
     }
-
-    private Stream<PackageElement> getSpecifiedPackages(DocletEnvironment root) {
-        return root.getSpecifiedElements()
-                .stream()
-                .filter(element -> ElementKind.PACKAGE == element.getKind())
-                .map(element -> (PackageElement) element);
+  }
+
+  private String erasedParamName(DocletEnvironment env, TypeMirror type) {
+    if (TypeKind.TYPEVAR == type.getKind()) {
+      TypeMirror upperBound = ((TypeVariable) type).getUpperBound();
+      return erasedParamName(env, upperBound);
+    } else if (type.getKind().isPrimitive()) {
+      return String.valueOf(type);
+    } else if (TypeKind.ARRAY == type.getKind()) {
+      return erasedParamName(env, ((ArrayType) type).getComponentType()) + "[]";
+    } else {
+      return env.getTypeUtils().asElement(type).getSimpleName().toString();
     }
+  }
+
+  @Override
+  public void init(Locale locale, Reporter reporter) {
+    this.reporter = reporter;
+  }
+
+  @Override
+  public String getName() {
+    return "JreEmulationSummaryDoclet";
+  }
+
+  @Override
+  public Set<? extends Option> getSupportedOptions() {
+    Option[] options = {
+        new Option() {
+
+          @Override
+          public int getArgumentCount() {
+            return 1;
+          }
+
+          @Override
+          public String getDescription() {
+            return "JRE emulation summary Doc location";
+          }
+
+          @Override
+          public Kind getKind() {
+            return Kind.STANDARD;
+          }
+
+          @Override
+          public List<String> getNames() {
+            return List.of(OPT_OUT_FILE, OPT_MISSING_FILE, OPT_TRIAGE_FILE,
+                OPT_MISSING_PROPERTIES_DIR);
+          }
+
+          @Override
+          public String getParameters() {
+            return "file";
+          }
+
+          @Override
+          public boolean process(String opt, List<String> arguments) {
+            if (arguments.isEmpty()) {
+              reporter.print(Diagnostic.Kind.ERROR,
+                  "Argument must be a path: " + opt);
+              return false;
+            }
+            String value = arguments.get(0);
+            reporter.print(Diagnostic.Kind.NOTE,
+              "JRE emulation summary Doclet Option " + opt + ":" + value);
+            switch (opt) {
+              case OPT_OUT_FILE:
+                outputFile = value;
+                break;
+              case OPT_MISSING_FILE:
+                missingFile = value;
+                break;
+              case OPT_TRIAGE_FILE:
+                triageFile = value;
+                break;
+              case OPT_MISSING_PROPERTIES_DIR:
+                missingPropertiesDir = value;
+                break;
+              default:
+                throw new IllegalArgumentException("Invalid option " + opt);
+            }
+            return true;
+          }
+        }
+    };
+    return new HashSet<>(Arrays.asList(options));
+  }
+
+  @Override
+  public SourceVersion getSupportedSourceVersion() {
+    return SourceVersion.latestSupported();
+  }
+
+  private Stream<PackageElement> getSpecifiedPackages(DocletEnvironment root) {
+    return root.getSpecifiedElements()
+        .stream()
+        .filter(element -> ElementKind.PACKAGE == element.getKind())
+        .map(element -> (PackageElement) element);
+  }
 }
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10130.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10130.properties
new file mode 100644
index 00000000000..12e9f0e7c8a
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10130.properties
@@ -0,0 +1 @@
+members=java.math.BigDecimal#TWO
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10210.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10210.properties
new file mode 100644
index 00000000000..65a961197c1
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10210.properties
@@ -0,0 +1,22 @@
+title=Threads
+status=wontfix
+members=java.util.concurrent.Executors#newFixedThreadPool(int)\
+java.util.concurrent.Executors#newFixedThreadPool(int, ThreadFactory)\
+java.util.concurrent.Executors#newSingleThreadExecutor(ThreadFactory)\
+java.util.concurrent.Executors#newSingleThreadExecutor()\
+java.util.concurrent.Executors#newCachedThreadPool(ThreadFactory)\
+java.util.concurrent.Executors#newCachedThreadPool()\
+java.util.concurrent.Executors#newSingleThreadScheduledExecutor(ThreadFactory)\
+java.util.concurrent.Executors#newSingleThreadScheduledExecutor()\
+java.util.concurrent.Executors#newScheduledThreadPool(int, ThreadFactory)\
+java.util.concurrent.Executors#newScheduledThreadPool(int)\
+java.util.concurrent.Executors#defaultThreadFactory()\
+java.util.concurrent.Executors#privilegedThreadFactory()\
+java.util.concurrent.Executors#newThreadPerTaskExecutor(ThreadFactory)\
+java.util.concurrent.Executors#newVirtualThreadPerTaskExecutor()\
+java.util.logging.LogRecord#getThreadID()\
+java.util.logging.LogRecord#setThreadID(int)\
+java.util.logging.LogRecord#getLongThreadID()\
+java.util.logging.LogRecord#setLongThreadID(long)\
+java.util.concurrent.TimeUnit#timedJoin(Thread, long)\
+java.util.concurrent.ExecutorService#awaitTermination(long, TimeUnit)
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10211.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10211.properties
new file mode 100644
index 00000000000..18091804a3c
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10211.properties
@@ -0,0 +1,25 @@
+title=Access to system resources
+status=wontfix
+members=java.lang.System#getenv(String)\
+java.lang.System#getenv()\
+java.lang.System#getLogger(String, ResourceBundle)\
+java.util.logging.LogRecord#getResourceBundleName()\
+java.util.logging.LogRecord#setResourceBundleName(String)\
+java.util.logging.LogRecord#setResourceBundle(ResourceBundle)\
+java.util.logging.LogRecord#getResourceBundle()\
+java.lang.System#exit(int)\
+java.lang.System#runFinalization()\
+java.lang.System#load(String)\
+java.lang.System#getSecurityManager()\
+java.lang.System#loadLibrary(String)\
+java.lang.System#console()\
+java.lang.System#inheritedChannel()\
+java.lang.System#setSecurityManager(SecurityManager)\
+java.beans.Beans#isGuiAvailable()\
+java.beans.Beans#setDesignTime(boolean)\
+java.beans.Beans#setGuiAvailable(boolean)\
+java.security.MessageDigest#getInstance(String, String)\
+java.security.MessageDigest#getInstance(String, Provider)\
+java.lang.System#setIn(InputStream)\
+java.lang.System#mapLibraryName(String)\
+java.security.MessageDigest#getProvider()
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10212.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10212.properties
new file mode 100644
index 00000000000..fedf353c19e
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10212.properties
@@ -0,0 +1,6 @@
+title=Write access to properties
+status=wontfix
+members=java.lang.System#getProperties()\
+java.lang.System#setProperties(Properties)\
+java.lang.System#setProperty(String, String)\
+java.lang.System#clearProperty(String)
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10213.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10213.properties
new file mode 100644
index 00000000000..a0c81428f84
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10213.properties
@@ -0,0 +1,9 @@
+title=Read access to properties
+status=evaluating
+members=java.lang.Integer#getInteger(String, Integer)\
+java.lang.Integer#getInteger(String)\
+java.lang.Integer#getInteger(String, int)\
+java.lang.Long#getLong(String, long)\
+java.lang.Long#getLong(String)\
+java.lang.Long#getLong(String, Long)\
+java.lang.Boolean#getBoolean(String)
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10214.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10214.properties
new file mode 100644
index 00000000000..88e0dec6020
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10214.properties
@@ -0,0 +1,24 @@
+members=java.util.random.RandomGenerator#getDefault()\
+java.util.random.RandomGenerator#of(String)\
+java.util.random.RandomGenerator#nextDouble(double)\
+java.util.random.RandomGenerator#nextDouble(double, double)\
+java.util.random.RandomGenerator#nextInt(int, int)\
+java.util.random.RandomGenerator#ints(int, int)\
+java.util.random.RandomGenerator#ints()\
+java.util.random.RandomGenerator#ints(long)\
+java.util.random.RandomGenerator#ints(long, int, int)\
+java.util.random.RandomGenerator#longs(long, long, long)\
+java.util.random.RandomGenerator#longs(long, long)\
+java.util.random.RandomGenerator#longs()\
+java.util.random.RandomGenerator#longs(long)\
+java.util.random.RandomGenerator#doubles()\
+java.util.random.RandomGenerator#doubles(long, double, double)\
+java.util.random.RandomGenerator#doubles(double, double)\
+java.util.random.RandomGenerator#doubles(long)\
+java.util.random.RandomGenerator#nextLong(long, long)\
+java.util.random.RandomGenerator#nextLong(long)\
+java.util.random.RandomGenerator#nextFloat(float)\
+java.util.random.RandomGenerator#nextFloat(float, float)\
+java.util.random.RandomGenerator#nextGaussian(double, double)\
+java.util.random.RandomGenerator#isDeprecated()\
+java.util.random.RandomGenerator#nextExponential()
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10215.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10215.properties
new file mode 100644
index 00000000000..5f057cf189d
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10215.properties
@@ -0,0 +1,51 @@
+members=java.util.Arrays#compare(boolean[], int, int, boolean[], int, int)\
+java.util.Arrays#compare(byte[], byte[])\
+java.util.Arrays#compare(byte[], int, int, byte[], int, int)\
+java.util.Arrays#compare(boolean[], boolean[])\
+java.util.Arrays#compare(Object[], int, int, Object[], int, int, Comparator)\
+java.util.Arrays#compare(double[], int, int, double[], int, int)\
+java.util.Arrays#compare(Comparable[], Comparable[])\
+java.util.Arrays#compare(Comparable[], int, int, Comparable[], int, int)\
+java.util.Arrays#compare(int[], int, int, int[], int, int)\
+java.util.Arrays#compare(Object[], Object[], Comparator)\
+java.util.Arrays#compare(int[], int[])\
+java.util.Arrays#compare(long[], long[])\
+java.util.Arrays#compare(long[], int, int, long[], int, int)\
+java.util.Arrays#compare(float[], float[])\
+java.util.Arrays#compare(float[], int, int, float[], int, int)\
+java.util.Arrays#compare(double[], double[])\
+java.util.Arrays#compare(char[], int, int, char[], int, int)\
+java.util.Arrays#compare(char[], char[])\
+java.util.Arrays#compare(short[], int, int, short[], int, int)\
+java.util.Arrays#compare(short[], short[])\
+java.util.Arrays#equals(double[], int, int, double[], int, int)\
+java.util.Arrays#equals(boolean[], int, int, boolean[], int, int)\
+java.util.Arrays#equals(Object[], int, int, Object[], int, int, Comparator)\
+java.util.Arrays#equals(Object[], Object[], Comparator)\
+java.util.Arrays#equals(Object[], int, int, Object[], int, int)\
+java.util.Arrays#equals(float[], int, int, float[], int, int)\
+java.util.Arrays#equals(int[], int, int, int[], int, int)\
+java.util.Arrays#equals(long[], int, int, long[], int, int)\
+java.util.Arrays#equals(byte[], int, int, byte[], int, int)\
+java.util.Arrays#equals(char[], int, int, char[], int, int)\
+java.util.Arrays#equals(short[], int, int, short[], int, int)\
+java.util.Arrays#mismatch(short[], int, int, short[], int, int)\
+java.util.Arrays#mismatch(int[], int[])\
+java.util.Arrays#mismatch(boolean[], int, int, boolean[], int, int)\
+java.util.Arrays#mismatch(long[], int, int, long[], int, int)\
+java.util.Arrays#mismatch(long[], long[])\
+java.util.Arrays#mismatch(int[], int, int, int[], int, int)\
+java.util.Arrays#mismatch(byte[], int, int, byte[], int, int)\
+java.util.Arrays#mismatch(boolean[], boolean[])\
+java.util.Arrays#mismatch(byte[], byte[])\
+java.util.Arrays#mismatch(char[], char[])\
+java.util.Arrays#mismatch(char[], int, int, char[], int, int)\
+java.util.Arrays#mismatch(short[], short[])\
+java.util.Arrays#mismatch(Object[], Object[])\
+java.util.Arrays#mismatch(Object[], int, int, Object[], int, int)\
+java.util.Arrays#mismatch(Object[], Object[], Comparator)\
+java.util.Arrays#mismatch(Object[], int, int, Object[], int, int, Comparator)\
+java.util.Arrays#mismatch(float[], float[])\
+java.util.Arrays#mismatch(float[], int, int, float[], int, int)\
+java.util.Arrays#mismatch(double[], double[])\
+java.util.Arrays#mismatch(double[], int, int, double[], int, int)\
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10216.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10216.properties
new file mode 100644
index 00000000000..84aaebc0a00
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10216.properties
@@ -0,0 +1,4 @@
+title=Raw bits
+status=wontfix
+members=java.lang.Double#doubleToRawLongBits(double)\
+java.lang.Float#floatToRawIntBits(float)
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10217.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10217.properties
new file mode 100644
index 00000000000..e043981c54f
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10217.properties
@@ -0,0 +1,132 @@
+title=Concurrent APIs
+members=java.util.concurrent.ConcurrentHashMap#forEach(long, BiConsumer)\
+java.util.concurrent.ConcurrentHashMap#forEach(long, BiFunction, Consumer)\
+java.util.concurrent.ConcurrentHashMap#keySet(Object)\
+java.util.concurrent.ConcurrentHashMap#mappingCount()\
+java.util.concurrent.ConcurrentHashMap#newKeySet(int)\
+java.util.concurrent.ConcurrentHashMap#search(long, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduce(long, BiFunction, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceToDouble(long, ToDoubleBiFunction, double, DoubleBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceToLong(long, ToLongBiFunction, long, LongBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceToInt(long, ToIntBiFunction, int, IntBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#forEachKey(long, Consumer)\
+java.util.concurrent.ConcurrentHashMap#forEachKey(long, Function, Consumer)\
+java.util.concurrent.ConcurrentHashMap#searchKeys(long, Function)\
+java.util.concurrent.ConcurrentHashMap#reduceKeys(long, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceKeys(long, Function, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceKeysToDouble(long, ToDoubleFunction, double, DoubleBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceKeysToLong(long, ToLongFunction, long, LongBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceKeysToInt(long, ToIntFunction, int, IntBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#forEachValue(long, Function, Consumer)\
+java.util.concurrent.ConcurrentHashMap#forEachValue(long, Consumer)\
+java.util.concurrent.ConcurrentHashMap#searchValues(long, Function)\
+java.util.concurrent.ConcurrentHashMap#reduceValues(long, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceValues(long, Function, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceValuesToDouble(long, ToDoubleFunction, double, DoubleBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceValuesToLong(long, ToLongFunction, long, LongBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceValuesToInt(long, ToIntFunction, int, IntBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#forEachEntry(long, Consumer)\
+java.util.concurrent.ConcurrentHashMap#forEachEntry(long, Function, Consumer)\
+java.util.concurrent.ConcurrentHashMap#searchEntries(long, Function)\
+java.util.concurrent.ConcurrentHashMap#reduceEntries(long, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceEntries(long, Function, BiFunction)\
+java.util.concurrent.ConcurrentHashMap#reduceEntriesToDouble(long, ToDoubleFunction, double, DoubleBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceEntriesToLong(long, ToLongFunction, long, LongBinaryOperator)\
+java.util.concurrent.ConcurrentHashMap#reduceEntriesToInt(long, ToIntFunction, int, IntBinaryOperator)\
+java.util.concurrent.Executors#newWorkStealingPool()\
+java.util.concurrent.Executors#newWorkStealingPool(int)\
+java.util.concurrent.Executors#unconfigurableExecutorService(ExecutorService)\
+java.util.concurrent.Executors#unconfigurableScheduledExecutorService(ScheduledExecutorService)\
+java.util.concurrent.Executors#privilegedCallable(Callable)\
+java.util.concurrent.Executors#privilegedCallableUsingCurrentClassLoader(Callable)\
+java.util.concurrent.Executors#callable(PrivilegedAction)\
+java.util.concurrent.Executors#callable(PrivilegedExceptionAction)\
+java.util.concurrent.atomic.AtomicBoolean#getOpaque()\
+java.util.concurrent.atomic.AtomicBoolean#setOpaque(boolean)\
+java.util.concurrent.atomic.AtomicBoolean#getAcquire()\
+java.util.concurrent.atomic.AtomicBoolean#setRelease(boolean)\
+java.util.concurrent.atomic.AtomicBoolean#compareAndExchange(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#compareAndExchangeAcquire(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#compareAndExchangeRelease(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetPlain(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetAcquire(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetRelease(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetVolatile(boolean, boolean)\
+java.util.concurrent.atomic.AtomicBoolean#getPlain()\
+java.util.concurrent.atomic.AtomicBoolean#setPlain(boolean)\
+java.util.concurrent.atomic.AtomicInteger#getOpaque()\
+java.util.concurrent.atomic.AtomicInteger#setOpaque(int)\
+java.util.concurrent.atomic.AtomicInteger#getAcquire()\
+java.util.concurrent.atomic.AtomicInteger#setRelease(int)\
+java.util.concurrent.atomic.AtomicInteger#compareAndExchange(int, int)\
+java.util.concurrent.atomic.AtomicInteger#compareAndExchangeAcquire(int, int)\
+java.util.concurrent.atomic.AtomicInteger#compareAndExchangeRelease(int, int)\
+java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetPlain(int, int)\
+java.util.concurrent.atomic.AtomicInteger#weakCompareAndSet(int, int)\
+java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetAcquire(int, int)\
+java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetRelease(int, int)\
+java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetVolatile(int, int)\
+java.util.concurrent.atomic.AtomicInteger#getAndUpdate(IntUnaryOperator)\
+java.util.concurrent.atomic.AtomicInteger#updateAndGet(IntUnaryOperator)\
+java.util.concurrent.atomic.AtomicInteger#getAndAccumulate(int, IntBinaryOperator)\
+java.util.concurrent.atomic.AtomicInteger#accumulateAndGet(int, IntBinaryOperator)\
+java.util.concurrent.atomic.AtomicInteger#getPlain()\
+java.util.concurrent.atomic.AtomicInteger#setPlain(int)\
+java.util.concurrent.atomic.AtomicLong#getOpaque()\
+java.util.concurrent.atomic.AtomicLong#setOpaque(long)\
+java.util.concurrent.atomic.AtomicLong#getAcquire()\
+java.util.concurrent.atomic.AtomicLong#setRelease(long)\
+java.util.concurrent.atomic.AtomicLong#compareAndExchange(long, long)\
+java.util.concurrent.atomic.AtomicLong#compareAndExchangeAcquire(long, long)\
+java.util.concurrent.atomic.AtomicLong#compareAndExchangeRelease(long, long)\
+java.util.concurrent.atomic.AtomicLong#weakCompareAndSetPlain(long, long)\
+java.util.concurrent.atomic.AtomicLong#weakCompareAndSet(long, long)\
+java.util.concurrent.atomic.AtomicLong#weakCompareAndSetAcquire(long, long)\
+java.util.concurrent.atomic.AtomicLong#weakCompareAndSetRelease(long, long)\
+java.util.concurrent.atomic.AtomicLong#weakCompareAndSetVolatile(long, long)\
+java.util.concurrent.atomic.AtomicLong#getAndUpdate(LongUnaryOperator)\
+java.util.concurrent.atomic.AtomicLong#updateAndGet(LongUnaryOperator)\
+java.util.concurrent.atomic.AtomicLong#getAndAccumulate(long, LongBinaryOperator)\
+java.util.concurrent.atomic.AtomicLong#accumulateAndGet(long, LongBinaryOperator)\
+java.util.concurrent.atomic.AtomicLong#getPlain()\
+java.util.concurrent.atomic.AtomicLong#setPlain(long)\
+java.util.concurrent.atomic.AtomicReference#getOpaque()\
+java.util.concurrent.atomic.AtomicReference#setOpaque(Object)\
+java.util.concurrent.atomic.AtomicReference#getAcquire()\
+java.util.concurrent.atomic.AtomicReference#setRelease(Object)\
+java.util.concurrent.atomic.AtomicReference#compareAndExchange(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#compareAndExchangeAcquire(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#compareAndExchangeRelease(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#weakCompareAndSetPlain(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#weakCompareAndSetAcquire(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#weakCompareAndSetRelease(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#weakCompareAndSetVolatile(Object, Object)\
+java.util.concurrent.atomic.AtomicReference#getAndUpdate(UnaryOperator)\
+java.util.concurrent.atomic.AtomicReference#updateAndGet(UnaryOperator)\
+java.util.concurrent.atomic.AtomicReference#getAndAccumulate(Object, BinaryOperator)\
+java.util.concurrent.atomic.AtomicReference#accumulateAndGet(Object, BinaryOperator)\
+java.util.concurrent.atomic.AtomicReference#getPlain()\
+java.util.concurrent.atomic.AtomicReference#setPlain(Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#getOpaque(int)\
+java.util.concurrent.atomic.AtomicReferenceArray#setOpaque(int, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#getAcquire(int)\
+java.util.concurrent.atomic.AtomicReferenceArray#setRelease(int, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#compareAndExchange(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#compareAndExchangeAcquire(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#compareAndExchangeRelease(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetPlain(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetAcquire(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetRelease(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetVolatile(int, Object, Object)\
+java.util.concurrent.atomic.AtomicReferenceArray#getAndUpdate(int, UnaryOperator)\
+java.util.concurrent.atomic.AtomicReferenceArray#updateAndGet(int, UnaryOperator)\
+java.util.concurrent.atomic.AtomicReferenceArray#getAndAccumulate(int, Object, BinaryOperator)\
+java.util.concurrent.atomic.AtomicReferenceArray#accumulateAndGet(int, Object, BinaryOperator)\
+java.util.concurrent.atomic.AtomicReferenceArray#getPlain(int)\
+java.util.concurrent.atomic.AtomicReferenceArray#setPlain(int, Object)\
+java.util.stream.Collectors#groupingByConcurrent(Function, Collector)\
+java.util.stream.Collectors#groupingByConcurrent(Function, Supplier, Collector)\
+java.util.stream.Collectors#groupingByConcurrent(Function)\
+java.util.stream.Collectors#toConcurrentMap(Function, Function)\
+java.util.stream.Collectors#toConcurrentMap(Function, Function, BinaryOperator, Supplier)\
+java.util.stream.Collectors#toConcurrentMap(Function, Function, BinaryOperator)\
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10218.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10218.properties
new file mode 100644
index 00000000000..21f52416491
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10218.properties
@@ -0,0 +1,16 @@
+title=Emulation of java.nio
+status=external
+members=java.security.MessageDigest#update(ByteBuffer)\
+java.util.BitSet#valueOf(ByteBuffer)\
+java.util.BitSet#valueOf(LongBuffer)\
+java.nio.charset.Charset#newDecoder()\
+java.nio.charset.Charset#newEncoder()\
+java.nio.charset.Charset#encode(String)\
+java.nio.charset.Charset#decode(ByteBuffer)\
+java.nio.charset.Charset#encode(CharBuffer)\
+java.nio.charset.Charset#canEncode()\
+java.nio.charset.Charset#contains(Charset)\
+java.nio.charset.Charset#isRegistered()\
+java.nio.charset.Charset#aliases()\
+java.nio.charset.Charset#isSupported(String)\
+java.nio.charset.Charset#displayName()
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10219.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10219.properties
new file mode 100644
index 00000000000..6ba78b0ec16
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10219.properties
@@ -0,0 +1,7 @@
+members=java.nio.charset.StandardCharsets#US_ASCII\
+java.nio.charset.StandardCharsets#UTF_16BE\
+java.nio.charset.StandardCharsets#UTF_16LE\
+java.nio.charset.StandardCharsets#UTF_16\
+java.nio.charset.StandardCharsets#UTF_32BE\
+java.nio.charset.StandardCharsets#UTF_32LE\
+java.nio.charset.StandardCharsets#UTF_32
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10220.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10220.properties
new file mode 100644
index 00000000000..436a3ce0884
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10220.properties
@@ -0,0 +1,48 @@
+title=Logging
+status=evaluating
+members=java.lang.System#getLogger(String)\
+java.lang.Throwable#printStackTrace(PrintWriter)\
+java.util.logging.Formatter#getHead(Handler)\
+java.util.logging.Formatter#getTail(Handler)\
+java.util.logging.Handler#getEncoding()\
+java.util.logging.Handler#getFilter()\
+java.util.logging.Handler#setEncoding(String)\
+java.util.logging.Handler#setFilter(Filter)\
+java.util.logging.Handler#setErrorManager(ErrorManager)\
+java.util.logging.Handler#getErrorManager()\
+java.util.logging.Level#getResourceBundleName()\
+java.util.logging.Level#getLocalizedName()\
+java.util.logging.LogManager#getProperty(String)\
+java.util.logging.LogManager#checkAccess()\
+java.util.logging.LogManager#reset()\
+java.util.logging.LogManager#readConfiguration(InputStream)\
+java.util.logging.LogManager#readConfiguration()\
+java.util.logging.LogManager#updateConfiguration(Function)\
+java.util.logging.LogManager#updateConfiguration(InputStream, Function)\
+java.util.logging.LogManager#getLoggingMXBean()\
+java.util.logging.LogManager#addConfigurationListener(Runnable)\
+java.util.logging.LogManager#removeConfigurationListener(Runnable)\
+java.util.logging.LogRecord#getSequenceNumber()\
+java.util.logging.LogRecord#setSequenceNumber(long)\
+java.util.logging.LogRecord#getSourceClassName()\
+java.util.logging.LogRecord#getSourceMethodName()\
+java.util.logging.LogRecord#getParameters()\
+java.util.logging.LogRecord#setParameters(Object[])\
+java.util.logging.LogRecord#setSourceClassName(String)\
+java.util.logging.LogRecord#setSourceMethodName(String)\
+java.util.logging.Logger#getLogger(String, String)\
+java.util.logging.Logger#getFilter()\
+java.util.logging.Logger#setFilter(Filter)\
+java.util.logging.Logger#getResourceBundleName()\
+java.util.logging.Logger#getAnonymousLogger(String)\
+java.util.logging.Logger#getAnonymousLogger()\
+java.util.logging.Logger#setResourceBundle(ResourceBundle)\
+java.util.logging.Logger#getResourceBundle()\
+java.util.logging.Logger#entering(String, String, Object)\
+java.util.logging.Logger#entering(String, String)\
+java.util.logging.Logger#entering(String, String, Object[])\
+java.util.logging.Logger#exiting(String, String, Object)\
+java.util.logging.Logger#exiting(String, String)\
+java.util.logging.Logger#throwing(String, String, Throwable)\
+java.util.logging.Logger#global\
+java.util.logging.LogManager#LOGGING_MXBEAN_NAME
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10221.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10221.properties
new file mode 100644
index 00000000000..1ade99b83b9
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10221.properties
@@ -0,0 +1,16 @@
+title=Miscellaneous Java 17 omissions
+members=java.util.Objects#checkIndex(long, long)\
+java.util.Objects#checkFromIndexSize(long, long, long)\
+java.util.Objects#checkFromToIndex(long, long, long)\
+java.lang.Integer#parseInt(CharSequence, int, int, int)\
+java.util.Arrays#compareUnsigned(short[], short[])\
+java.util.Arrays#compareUnsigned(byte[], int, int, byte[], int, int)\
+java.util.Arrays#compareUnsigned(byte[], byte[])\
+java.util.Arrays#compareUnsigned(long[], long[])\
+java.util.Arrays#compareUnsigned(int[], int, int, int[], int, int)\
+java.util.Arrays#compareUnsigned(long[], int, int, long[], int, int)\
+java.util.Arrays#compareUnsigned(short[], int, int, short[], int, int)\
+java.util.Arrays#compareUnsigned(int[], int[])\
+java.lang.Double#toHexString(double)\
+java.lang.Float#toHexString(float)\
+java.lang.System#lineSeparator()
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh10228.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10228.properties
new file mode 100644
index 00000000000..10d11b05aac
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh10228.properties
@@ -0,0 +1,77 @@
+title=Not triaged omissions for Java 18 - 23
+members=java.io.PrintStream#charset()\
+java.lang.Character#isEmoji(int)\
+java.lang.Character#isEmojiPresentation(int)\
+java.lang.Character#isEmojiModifier(int)\
+java.lang.Character#isEmojiModifierBase(int)\
+java.lang.Character#isEmojiComponent(int)\
+java.lang.Character#isExtendedPictographic(int)\
+java.lang.Double#PRECISION\
+java.lang.Float#float16ToFloat(short)\
+java.lang.Float#floatToFloat16(float)\
+java.lang.Float#PRECISION\
+java.lang.Integer#expand(int, int)\
+java.lang.Integer#compress(int, int)\
+java.lang.Long#expand(long, long)\
+java.lang.Long#compress(long, long)\
+java.lang.Math#unsignedMultiplyHigh(long, long)\
+java.lang.Math#clamp(float, float, float)\
+java.lang.Math#clamp(long, long, long)\
+java.lang.Math#clamp(double, double, double)\
+java.lang.Math#clamp(long, int, int)\
+java.lang.Math#ceilDiv(long, long)\
+java.lang.Math#ceilDiv(long, int)\
+java.lang.Math#ceilDiv(int, int)\
+java.lang.Math#ceilMod(long, long)\
+java.lang.Math#ceilMod(long, int)\
+java.lang.Math#ceilMod(int, int)\
+java.lang.Math#divideExact(int, int)\
+java.lang.Math#divideExact(long, long)\
+java.lang.Math#floorDivExact(long, long)\
+java.lang.Math#floorDivExact(int, int)\
+java.lang.Math#ceilDivExact(long, long)\
+java.lang.Math#ceilDivExact(int, int)\
+java.lang.Math#TAU\
+java.lang.StrictMath#unsignedMultiplyHigh(long, long)\
+java.lang.StrictMath#clamp(float, float, float)\
+java.lang.StrictMath#clamp(double, double, double)\
+java.lang.StrictMath#clamp(long, long, long)\
+java.lang.StrictMath#clamp(long, int, int)\
+java.lang.StrictMath#ceilDiv(long, long)\
+java.lang.StrictMath#ceilDiv(long, int)\
+java.lang.StrictMath#ceilDiv(int, int)\
+java.lang.StrictMath#ceilMod(long, long)\
+java.lang.StrictMath#ceilMod(long, int)\
+java.lang.StrictMath#ceilMod(int, int)\
+java.lang.StrictMath#divideExact(int, int)\
+java.lang.StrictMath#divideExact(long, long)\
+java.lang.StrictMath#floorDivExact(int, int)\
+java.lang.StrictMath#floorDivExact(long, long)\
+java.lang.StrictMath#ceilDivExact(long, long)\
+java.lang.StrictMath#ceilDivExact(int, int)\
+java.lang.StrictMath#TAU\
+java.lang.String#indexOf(String, int, int)\
+java.lang.String#indexOf(int, int, int)\
+java.lang.String#splitWithDelimiters(String, int)\
+java.math.BigInteger#parallelMultiply(BigInteger)\
+java.nio.charset.Charset#forName(String, Charset)\
+java.util.Collections#shuffle(List, RandomGenerator)\
+java.util.Collections#unmodifiableSequencedCollection(SequencedCollection)\
+java.util.Collections#unmodifiableSequencedSet(SequencedSet)\
+java.util.Collections#unmodifiableSequencedMap(SequencedMap)\
+java.util.Collections#newSequencedSetFromMap(SequencedMap)\
+java.util.HashMap#newHashMap(int)\
+java.util.HashSet#newHashSet(int)\
+java.util.LinkedHashMap#newLinkedHashMap(int)\
+java.util.LinkedHashSet#newLinkedHashSet(int)\
+java.util.Locale#of(String, String)\
+java.util.Locale#of(String, String, String)\
+java.util.Locale#of(String)\
+java.util.Locale#availableLocales()\
+java.util.Locale#caseFoldLanguageTag(String)\
+java.util.Objects#toIdentityString(Object)\
+java.util.Random#from(RandomGenerator)\
+java.util.concurrent.Future#state()\
+java.util.concurrent.Future#resultNow()\
+java.util.concurrent.Future#exceptionNow()\
+java.util.stream.Stream#gather(Gatherer)
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh1989.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh1989.properties
new file mode 100644
index 00000000000..26eeb93ea63
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh1989.properties
@@ -0,0 +1,99 @@
+title=Unicode
+members=java.lang.Character#getName(int)\
+java.lang.Character#isJavaIdentifierStart(char)\
+java.lang.Character#isJavaIdentifierStart(int)\
+java.lang.Character#isJavaIdentifierPart(char)\
+java.lang.Character#isJavaIdentifierPart(int)\
+java.lang.Character#toString(int)\
+java.lang.Character#reverseBytes(char)\
+java.lang.Character#isDigit(int)\
+java.lang.Character#isLowerCase(int)\
+java.lang.Character#isUpperCase(int)\
+java.lang.Character#isSurrogate(char)\
+java.lang.Character#highSurrogate(int)\
+java.lang.Character#lowSurrogate(int)\
+java.lang.Character#toLowerCase(int)\
+java.lang.Character#toUpperCase(int)\
+java.lang.Character#getType(char)\
+java.lang.Character#getType(int)\
+java.lang.Character#isLetter(int)\
+java.lang.Character#isLetterOrDigit(int)\
+java.lang.Character#isTitleCase(int)\
+java.lang.Character#isDefined(int)\
+java.lang.Character#isDefined(char)\
+java.lang.Character#isIdeographic(int)\
+java.lang.Character#isSpaceChar(int)\
+java.lang.Character#isSpaceChar(char)\
+java.lang.Character#isUnicodeIdentifierStart(int)\
+java.lang.Character#isUnicodeIdentifierStart(char)\
+java.lang.Character#isUnicodeIdentifierPart(int)\
+java.lang.Character#isUnicodeIdentifierPart(char)\
+java.lang.Character#isIdentifierIgnorable(int)\
+java.lang.Character#isIdentifierIgnorable(char)\
+java.lang.Character#toTitleCase(int)\
+java.lang.Character#toTitleCase(char)\
+java.lang.Character#digit(int, int)\
+java.lang.Character#getNumericValue(int)\
+java.lang.Character#getNumericValue(char)\
+java.lang.Character#isISOControl(char)\
+java.lang.Character#isISOControl(int)\
+java.lang.Character#getDirectionality(int)\
+java.lang.Character#getDirectionality(char)\
+java.lang.Character#isMirrored(char)\
+java.lang.Character#isMirrored(int)\
+java.lang.Character#isAlphabetic(int)\
+java.lang.Character#codePointOf(String)\
+java.lang.Character#UNASSIGNED\
+java.lang.Character#UPPERCASE_LETTER\
+java.lang.Character#LOWERCASE_LETTER\
+java.lang.Character#TITLECASE_LETTER\
+java.lang.Character#MODIFIER_LETTER\
+java.lang.Character#OTHER_LETTER\
+java.lang.Character#NON_SPACING_MARK\
+java.lang.Character#ENCLOSING_MARK\
+java.lang.Character#COMBINING_SPACING_MARK\
+java.lang.Character#DECIMAL_DIGIT_NUMBER\
+java.lang.Character#LETTER_NUMBER\
+java.lang.Character#OTHER_NUMBER\
+java.lang.Character#SPACE_SEPARATOR\
+java.lang.Character#LINE_SEPARATOR\
+java.lang.Character#PARAGRAPH_SEPARATOR\
+java.lang.Character#CONTROL\
+java.lang.Character#FORMAT\
+java.lang.Character#PRIVATE_USE\
+java.lang.Character#SURROGATE\
+java.lang.Character#DASH_PUNCTUATION\
+java.lang.Character#START_PUNCTUATION\
+java.lang.Character#END_PUNCTUATION\
+java.lang.Character#CONNECTOR_PUNCTUATION\
+java.lang.Character#OTHER_PUNCTUATION\
+java.lang.Character#MATH_SYMBOL\
+java.lang.Character#CURRENCY_SYMBOL\
+java.lang.Character#MODIFIER_SYMBOL\
+java.lang.Character#OTHER_SYMBOL\
+java.lang.Character#INITIAL_QUOTE_PUNCTUATION\
+java.lang.Character#FINAL_QUOTE_PUNCTUATION\
+java.lang.Character#DIRECTIONALITY_UNDEFINED\
+java.lang.Character#DIRECTIONALITY_LEFT_TO_RIGHT\
+java.lang.Character#DIRECTIONALITY_RIGHT_TO_LEFT\
+java.lang.Character#DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC\
+java.lang.Character#DIRECTIONALITY_EUROPEAN_NUMBER\
+java.lang.Character#DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR\
+java.lang.Character#DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR\
+java.lang.Character#DIRECTIONALITY_ARABIC_NUMBER\
+java.lang.Character#DIRECTIONALITY_COMMON_NUMBER_SEPARATOR\
+java.lang.Character#DIRECTIONALITY_NONSPACING_MARK\
+java.lang.Character#DIRECTIONALITY_BOUNDARY_NEUTRAL\
+java.lang.Character#DIRECTIONALITY_PARAGRAPH_SEPARATOR\
+java.lang.Character#DIRECTIONALITY_SEGMENT_SEPARATOR\
+java.lang.Character#DIRECTIONALITY_WHITESPACE\
+java.lang.Character#DIRECTIONALITY_OTHER_NEUTRALS\
+java.lang.Character#DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING\
+java.lang.Character#DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE\
+java.lang.Character#DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING\
+java.lang.Character#DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE\
+java.lang.Character#DIRECTIONALITY_POP_DIRECTIONAL_FORMAT\
+java.lang.Character#DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE\
+java.lang.Character#DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE\
+java.lang.Character#DIRECTIONALITY_FIRST_STRONG_ISOLATE\
+java.lang.Character#DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh3946.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh3946.properties
new file mode 100644
index 00000000000..1c294ce8d92
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh3946.properties
@@ -0,0 +1,86 @@
+title=Localization
+status=evaluating
+members=java.io.PrintStream#format(String, Object[])\
+java.io.PrintStream#format(Locale, String, Object[])\
+java.io.PrintStream#printf(Locale, String, Object[])\
+java.io.PrintStream#printf(String, Object[])\
+java.lang.String#format(String, Object[])\
+java.lang.String#format(Locale, String, Object[])\
+java.util.logging.Logger#log(Level, String, Object)\
+java.util.logging.Logger#log(Level, String, Object[])\
+java.util.logging.Logger#logp(Level, String, String, String, Object)\
+java.util.logging.Logger#logp(Level, String, String, Throwable, Supplier)\
+java.util.logging.Logger#logp(Level, String, String, String, Throwable)\
+java.util.logging.Logger#logp(Level, String, String, String)\
+java.util.logging.Logger#logp(Level, String, String, String, Object[])\
+java.util.logging.Logger#logp(Level, String, String, Supplier)\
+java.util.logging.Logger#logrb(Level, String, String, ResourceBundle, String, Object[])\
+java.util.logging.Logger#logrb(Level, ResourceBundle, String, Object[])\
+java.util.logging.Logger#logrb(Level, String, String, String, String, Throwable)\
+java.util.logging.Logger#logrb(Level, String, String, ResourceBundle, String, Throwable)\
+java.util.logging.Logger#logrb(Level, ResourceBundle, String, Throwable)\
+java.util.logging.Logger#logrb(Level, String, String, String, String)\
+java.util.logging.Logger#logrb(Level, String, String, String, String, Object)\
+java.util.logging.Logger#logrb(Level, String, String, String, String, Object[])\
+java.util.Locale#clone()\
+java.util.Locale#getDefault(Category)\
+java.util.Locale#lookup(List, Collection)\
+java.util.Locale#filter(List, Collection)\
+java.util.Locale#filter(List, Collection, FilteringMode)\
+java.util.Locale#getLanguage()\
+java.util.Locale#getDisplayName()\
+java.util.Locale#getDisplayName(Locale)\
+java.util.Locale#getAvailableLocales()\
+java.util.Locale#getUnicodeLocaleType(String)\
+java.util.Locale#getCountry()\
+java.util.Locale#stripExtensions()\
+java.util.Locale#hasExtensions()\
+java.util.Locale#getVariant()\
+java.util.Locale#getScript()\
+java.util.Locale#setDefault(Category, Locale)\
+java.util.Locale#setDefault(Locale)\
+java.util.Locale#getUnicodeLocaleAttributes()\
+java.util.Locale#getUnicodeLocaleKeys()\
+java.util.Locale#getDisplayLanguage()\
+java.util.Locale#getDisplayLanguage(Locale)\
+java.util.Locale#getDisplayScript(Locale)\
+java.util.Locale#getDisplayScript()\
+java.util.Locale#getDisplayCountry()\
+java.util.Locale#getDisplayCountry(Locale)\
+java.util.Locale#getDisplayVariant()\
+java.util.Locale#getDisplayVariant(Locale)\
+java.util.Locale#filterTags(List, Collection)\
+java.util.Locale#filterTags(List, Collection, FilteringMode)\
+java.util.Locale#lookupTag(List, Collection)\
+java.util.Locale#getISOCountries(IsoCountryCode)\
+java.util.Locale#getISOCountries()\
+java.util.Locale#getISOLanguages()\
+java.util.Locale#getExtension(char)\
+java.util.Locale#getExtensionKeys()\
+java.util.Locale#toLanguageTag()\
+java.util.Locale#forLanguageTag(String)\
+java.util.Locale#getISO3Language()\
+java.util.Locale#getISO3Country()\
+java.nio.charset.Charset#displayName(Locale)\
+java.lang.String#formatted(Object[])\
+java.util.Locale#FRENCH\
+java.util.Locale#GERMAN\
+java.util.Locale#ITALIAN\
+java.util.Locale#JAPANESE\
+java.util.Locale#KOREAN\
+java.util.Locale#CHINESE\
+java.util.Locale#SIMPLIFIED_CHINESE\
+java.util.Locale#TRADITIONAL_CHINESE\
+java.util.Locale#FRANCE\
+java.util.Locale#GERMANY\
+java.util.Locale#ITALY\
+java.util.Locale#JAPAN\
+java.util.Locale#KOREA\
+java.util.Locale#UK\
+java.util.Locale#CANADA\
+java.util.Locale#CANADA_FRENCH\
+java.util.Locale#CHINA\
+java.util.Locale#PRC\
+java.util.Locale#TAIWAN\
+java.util.Locale#PRIVATE_USE_EXTENSION\
+java.util.Locale#UNICODE_LOCALE_EXTENSION
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh611.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh611.properties
new file mode 100644
index 00000000000..ac1cc8a4107
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh611.properties
@@ -0,0 +1,17 @@
+title=Time
+status=external
+members=java.util.concurrent.TimeUnit#convert(Duration)\
+java.util.concurrent.TimeUnit#of(ChronoUnit)\
+java.util.concurrent.TimeUnit#sleep(long)\
+java.util.concurrent.TimeUnit#timedWait(Object, long)\
+java.util.concurrent.TimeUnit#toChronoUnit()\
+java.util.logging.LogRecord#getInstant()\
+java.util.logging.LogRecord#setInstant(Instant)\
+java.sql.Date#valueOf(LocalDate)\
+java.sql.Date#toLocalDate()\
+java.sql.Time#valueOf(LocalTime)\
+java.sql.Time#toLocalTime()\
+java.sql.Timestamp#valueOf(LocalDateTime)\
+java.sql.Timestamp#toLocalDateTime()\
+java.util.Date#from(Instant)\
+java.util.Date#toInstant()
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh9630.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9630.properties
new file mode 100644
index 00000000000..14a6b9975f1
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9630.properties
@@ -0,0 +1,88 @@
+title=Reflection
+status=wontfix
+members=java.lang.StackTraceElement#isNativeMethod()\
+java.lang.StackTraceElement#getModuleName()\
+java.lang.StackTraceElement#getModuleVersion()\
+java.lang.StackTraceElement#getClassLoaderName()\
+java.lang.Class#forName(String, boolean, ClassLoader)\
+java.lang.Class#forName(String)\
+java.lang.Class#forName(Module, String)\
+java.lang.Class#getModule()\
+java.lang.Class#getProtectionDomain()\
+java.lang.Class#isAssignableFrom(Class)\
+java.lang.Class#isInstance(Object)\
+java.lang.Class#getModifiers()\
+java.lang.Class#isHidden()\
+java.lang.Class#cast(Object)\
+java.lang.Class#isAnnotation()\
+java.lang.Class#isRecord()\
+java.lang.Class#getClassLoader()\
+java.lang.Class#newInstance()\
+java.lang.Class#getInterfaces()\
+java.lang.Class#getEnclosingClass()\
+java.lang.Class#getResourceAsStream(String)\
+java.lang.Class#getResource(String)\
+java.lang.Class#getPackageName()\
+java.lang.Class#getMethod(String, Class[])\
+java.lang.Class#getNestHost()\
+java.lang.Class#getPermittedSubclasses()\
+java.lang.Class#toGenericString()\
+java.lang.Class#isSynthetic()\
+java.lang.Class#getGenericSuperclass()\
+java.lang.Class#getPackage()\
+java.lang.Class#getGenericInterfaces()\
+java.lang.Class#getSigners()\
+java.lang.Class#getEnclosingMethod()\
+java.lang.Class#getEnclosingConstructor()\
+java.lang.Class#getDeclaringClass()\
+java.lang.Class#isAnonymousClass()\
+java.lang.Class#isLocalClass()\
+java.lang.Class#isMemberClass()\
+java.lang.Class#getClasses()\
+java.lang.Class#getFields()\
+java.lang.Class#getMethods()\
+java.lang.Class#getConstructors()\
+java.lang.Class#getField(String)\
+java.lang.Class#getConstructor(Class[])\
+java.lang.Class#getDeclaredClasses()\
+java.lang.Class#getDeclaredFields()\
+java.lang.Class#getRecordComponents()\
+java.lang.Class#getDeclaredMethods()\
+java.lang.Class#getDeclaredConstructors()\
+java.lang.Class#getDeclaredField(String)\
+java.lang.Class#getDeclaredMethod(String, Class[])\
+java.lang.Class#getDeclaredConstructor(Class[])\
+java.lang.Class#asSubclass(Class)\
+java.lang.Class#getAnnotatedSuperclass()\
+java.lang.Class#getAnnotatedInterfaces()\
+java.lang.Class#isNestmateOf(Class)\
+java.lang.Class#getNestMembers()\
+java.lang.Class#isSealed()\
+java.lang.Class#forPrimitiveName(String)\
+java.lang.Class#accessFlags()\
+java.util.Collections#checkedCollection(Collection, Class)\
+java.util.Collections#checkedQueue(Queue, Class)\
+java.util.Collections#checkedSet(Set, Class)\
+java.util.Collections#checkedSortedSet(SortedSet, Class)\
+java.util.Collections#checkedNavigableSet(NavigableSet, Class)\
+java.util.Collections#checkedList(List, Class)\
+java.util.Collections#checkedMap(Map, Class, Class)\
+java.util.Collections#checkedSortedMap(SortedMap, Class, Class)\
+java.util.Collections#checkedNavigableMap(NavigableMap, Class, Class)\
+java.beans.Beans#getInstanceOf(Object, Class)\
+java.beans.Beans#isInstanceOf(Object, Class)\
+java.beans.Beans#instantiate(ClassLoader, String, BeanContext, AppletInitializer)\
+java.beans.Beans#instantiate(ClassLoader, String)\
+java.beans.Beans#instantiate(ClassLoader, String, BeanContext)\
+java.lang.reflect.Array#newInstance(Class, int)\
+java.lang.reflect.Array#newInstance(Class, int[])\
+java.lang.reflect.Type#getTypeName()\
+java.util.Arrays#copyOf(Object[], int, Class)\
+java.util.Arrays#copyOfRange(Object[], int, int, Class)\
+java.io.Externalizable#writeExternal(ObjectOutput)\
+java.io.Externalizable#readExternal(ObjectInput)\
+java.lang.constant.Constable#describeConstable()\
+java.lang.constant.ConstantDesc#resolveConstantDesc(Lookup)\
+java.lang.invoke.TypeDescriptor#descriptorString()\
+java.lang.invoke.TypeDescriptor$OfField#componentType()\
+java.lang.invoke.TypeDescriptor$OfField#arrayType()
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh9643.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9643.properties
new file mode 100644
index 00000000000..88e055f72f4
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9643.properties
@@ -0,0 +1,17 @@
+title=Unsigned emulation
+members=java.lang.Byte#toUnsignedLong(byte)\
+java.lang.Byte#toUnsignedInt(byte)\
+java.lang.Byte#compareUnsigned(byte, byte)\
+java.lang.Integer#compareUnsigned(int, int)\
+java.lang.Integer#toUnsignedString(int, int)\
+java.lang.Integer#toUnsignedString(int)\
+java.lang.Integer#divideUnsigned(int, int)\
+java.lang.Integer#remainderUnsigned(int, int)\
+java.lang.Integer#parseUnsignedInt(String, int)\
+java.lang.Integer#parseUnsignedInt(CharSequence, int, int, int)\
+java.lang.Integer#parseUnsignedInt(String)\
+java.lang.Integer#toUnsignedLong(int)\
+java.lang.Short#toUnsignedLong(short)\
+java.lang.Short#toUnsignedInt(short)\
+java.lang.Short#compareUnsigned(short, short)
+
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh9909.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9909.properties
new file mode 100644
index 00000000000..142f1258c99
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9909.properties
@@ -0,0 +1,16 @@
+long.title=Emulation of long
+members=java.lang.Long#compareUnsigned(long, long)\
+java.lang.Long#toUnsignedString(long, int)\
+java.lang.Long#toUnsignedString(long)\
+java.lang.Long#parseLong(CharSequence, int, int, int)\
+java.lang.Long#divideUnsigned(long, long)\
+java.lang.Long#remainderUnsigned(long, long)\
+java.lang.Long#parseUnsignedLong(String, int)\
+java.lang.Long#parseUnsignedLong(CharSequence, int, int, int)\
+java.lang.Long#parseUnsignedLong(String)\
+java.lang.Math#multiplyHigh(long, long)\
+java.lang.StrictMath#multiplyHigh(long, long)\
+java.lang.StrictMath#fma(float, float, float)\
+java.lang.StrictMath#fma(double, double, double)\
+java.lang.Math#fma(double, double, double)\
+java.lang.Math#fma(float, float, float)
\ No newline at end of file
diff --git a/build_tools/doctool/src/com/google/doctool/custom/missing/gh9964.properties b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9964.properties
new file mode 100644
index 00000000000..77716348412
--- /dev/null
+++ b/build_tools/doctool/src/com/google/doctool/custom/missing/gh9964.properties
@@ -0,0 +1,3 @@
+members=java.math.BigDecimal#sqrt(MathContext)\
+java.math.BigInteger#sqrt()\
+java.math.BigInteger#sqrtAndRemainder()
\ No newline at end of file
diff --git a/doc/build.xml b/doc/build.xml
index 1b777b094ad..20c7e4d64a9 100644
--- a/doc/build.xml
+++ b/doc/build.xml
@@ -148,8 +148,14 @@
                  packagenames="${JAVA_PKGS}"
                  docletpath="${project.build}/../build_tools/doctool/bin"
                  doclet="com.google.doctool.custom.JavaEmulSummaryDoclet">
-          <arg value="-outfile" />
+          <arg value="-outFile" />
           <arg value="${project.build}/emul-ezt/fragment.html" />
+          <arg value="-missingFile" />
+          <arg value="${project.build}/emul-ezt/fragment-missing.html" />
+          <arg value="-triageFile" />
+          <arg value="${project.build}/emul-ezt/triage.properties" />
+          <arg value="-missingProperties" />
+          <arg value="${gwt.root}/build_tools/doctool/src/com/google/doctool/custom/missing" />
         </javadoc>
       </sequential>
     </outofdate>
diff --git a/eclipse/settings/code-style/gwt-checkstyle.xml b/eclipse/settings/code-style/gwt-checkstyle.xml
index 048e31ee2bf..f4b2127ba1e 100644
--- a/eclipse/settings/code-style/gwt-checkstyle.xml
+++ b/eclipse/settings/code-style/gwt-checkstyle.xml
@@ -22,6 +22,7 @@ Description:
         <property name="severity" value="error"/>
     </module>
     <module name="LineLength">
+        <property name="fileExtensions" value="java"/>
         <property name="max" value="100"/>
         <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://"/>
     </module>
diff --git a/tools/api-checker/config/gwt212_213userapi.conf b/tools/api-checker/config/gwt212_213userapi.conf
index b43799d8949..5cf1735e586 100644
--- a/tools/api-checker/config/gwt212_213userapi.conf
+++ b/tools/api-checker/config/gwt212_213userapi.conf
@@ -170,3 +170,5 @@ javax.annotation MISSING
 javax.annotation.processing MISSING
 org.junit.runner.RunWith MISSING
 org.junit.runners.Suite.SuiteClasses MISSING
+# Was never supposed to be public
+java.security.SHA256Digest MISSING
diff --git a/user/super/com/google/gwt/emul/java/io/ByteArrayInputStream.java b/user/super/com/google/gwt/emul/java/io/ByteArrayInputStream.java
index 6bdebc052f7..5f695a2f425 100644
--- a/user/super/com/google/gwt/emul/java/io/ByteArrayInputStream.java
+++ b/user/super/com/google/gwt/emul/java/io/ByteArrayInputStream.java
@@ -184,7 +184,7 @@ public long skip(long byteCount) {
             return 0;
         }
         int temp = pos;
-        pos = this.count - pos < byteCount ? this.count : (int) (pos + byteCount);
+        pos = this.count < pos + byteCount ? this.count : (int) (pos + byteCount);
         return pos - temp;
     }
 }
diff --git a/user/super/com/google/gwt/emul/java/io/InputStream.java b/user/super/com/google/gwt/emul/java/io/InputStream.java
index 5d25c9e388c..b46ea938633 100644
--- a/user/super/com/google/gwt/emul/java/io/InputStream.java
+++ b/user/super/com/google/gwt/emul/java/io/InputStream.java
@@ -21,6 +21,8 @@
 
 import static javaemul.internal.InternalPreconditions.checkNotNull;
 
+import java.util.Arrays;
+
 /**
  * A readable source of bytes.
  *
@@ -203,6 +205,69 @@ public int read(byte[] buffer, int byteOffset, int byteCount) throws IOException
         return byteCount;
     }
 
+    public byte[] readAllBytes() throws IOException {
+        return readNBytes(0, Integer.MAX_VALUE);
+    }
+
+    public byte[] readNBytes(int len) throws IOException {
+        return readNBytes(0, len);
+    }
+
+    public byte[] readNBytes(int off, int len) throws IOException {
+        if (len == 0) {
+            return new byte[0];
+        }
+        skipNBytes(off);
+        int capacity = Math.min(len, Math.max(2048, available()));
+        byte[] buffer = new byte[capacity];
+        int pos = 0;
+        while (pos <= len) {
+            int chunk = read(buffer, pos, capacity - pos);
+            if (chunk == 0) {
+                break;
+            }
+            pos += chunk;
+            if (pos == capacity) {
+                capacity = Math.min(len, 2 * capacity);
+                buffer = Arrays.copyOf(buffer, capacity);
+            }
+        }
+
+        return pos < len ? Arrays.copyOf(buffer, pos) : buffer;
+    }
+
+    public int readNBytes(byte[] buffer, int off, int len) throws IOException {
+        if (len == 0) {
+            return 0;
+        }
+        skipNBytes(off);
+        int pos = 0;
+        while (pos <= len) {
+            int chunk = read(buffer, pos, len);
+            if (chunk == 0) {
+                break;
+            }
+            pos += chunk;
+        }
+
+        return pos;
+    }
+
+    public void skipNBytes(long n) throws IOException {
+        long skipped = 0;
+        while (skipped < n) {
+            long chunk = skip(n);
+            if (chunk == 0) {
+                if (read() >= 0) {
+                    skipped++;
+                } else {
+                    throw new IOException("End of stream reached");
+                }
+            }
+            skipped += chunk;
+        }
+    }
+
     /**
      * Resets this stream to the last marked location. Throws an
      * {@code IOException} if the number of bytes read since the mark has been
@@ -256,4 +321,31 @@ public long skip(long byteCount) throws IOException {
         }
         return skipped;
     }
+
+    public void transferTo(OutputStream writer) throws IOException {
+        byte[] buffer = new byte[2048];
+        int read;
+        while ((read = read(buffer)) > 0) {
+            writer.write(buffer, 0, read);
+        }
+    }
+
+    public static InputStream nullInputStream() {
+        return new InputStream() {
+            private boolean closed;
+
+            @Override
+            public int read() throws IOException {
+                if (closed) {
+                    throw new IOException("Already closed");
+                }
+                return -1;
+            }
+
+            @Override
+            public void close() {
+                closed = true;
+            }
+        };
+    }
 }
diff --git a/user/super/com/google/gwt/emul/java/io/PrintStream.java b/user/super/com/google/gwt/emul/java/io/PrintStream.java
index a47fb8c98b3..4e4dcbd634a 100644
--- a/user/super/com/google/gwt/emul/java/io/PrintStream.java
+++ b/user/super/com/google/gwt/emul/java/io/PrintStream.java
@@ -145,6 +145,10 @@ public void close() {
     }
   }
 
+  public void writeBytes(byte[] buffer) {
+    write(buffer, 0, buffer.length);
+  }
+
   @Override
   public void write(byte[] buffer, int offset, int length) {
     // Force buffer null check first!
diff --git a/user/super/com/google/gwt/emul/java/io/Reader.java b/user/super/com/google/gwt/emul/java/io/Reader.java
index 63216ad3a92..fa71d88b690 100644
--- a/user/super/com/google/gwt/emul/java/io/Reader.java
+++ b/user/super/com/google/gwt/emul/java/io/Reader.java
@@ -99,4 +99,31 @@ public long skip(long n) throws IOException {
     }
     return n - remaining;
   }
+
+  public void transferTo(Writer writer) throws IOException {
+    char[] buffer = new char[1024];
+    int read;
+    while ((read = read(buffer)) > 0) {
+      writer.write(buffer, 0, read);
+    }
+  }
+
+  public static Reader nullReader() {
+    return new Reader() {
+      private boolean closed;
+
+      @Override
+      public int read(char[] cbuf, int off, int len) throws IOException {
+        if (closed) {
+          throw new IOException("Already closed");
+        }
+        return 0;
+      }
+
+      @Override
+      public void close() throws IOException {
+        closed = true;
+      }
+    };
+  }
 }
diff --git a/user/super/com/google/gwt/emul/java/security/MessageDigest.java b/user/super/com/google/gwt/emul/java/security/MessageDigest.java
index c706c2ab36a..9bdf8bb819b 100644
--- a/user/super/com/google/gwt/emul/java/security/MessageDigest.java
+++ b/user/super/com/google/gwt/emul/java/security/MessageDigest.java
@@ -17,6 +17,8 @@
 
 import static javaemul.internal.Coercions.ensureInt;
 
+import java.util.Arrays;
+
 /**
  * Message Digest algorithm - <a href=
  * "http://java.sun.com/j2se/1.4.2/docs/api/java/security/MessageDigest.html"
@@ -265,6 +267,15 @@ protected void engineReset() {
       remainder = 64;
     }
 
+    public Object clone() {
+      Md5Digest copy = new Md5Digest();
+      copy.buffer = Arrays.copyOf(buffer, buffer.length);
+      copy.state = Arrays.copyOf(state, state.length);
+      copy.counter = counter;
+      copy.remainder = remainder;
+      return copy;
+    }
+
     @Override
     protected void engineUpdate(byte input) {
       // TODO(jat): better implementation
diff --git a/user/super/com/google/gwt/emul/java/security/MessageDigestSpi.java b/user/super/com/google/gwt/emul/java/security/MessageDigestSpi.java
index 0a075159e1a..338d74309ee 100644
--- a/user/super/com/google/gwt/emul/java/security/MessageDigestSpi.java
+++ b/user/super/com/google/gwt/emul/java/security/MessageDigestSpi.java
@@ -36,6 +36,10 @@ protected int engineDigest(byte[] buf, int offset, int len)
     System.arraycopy(digest, 0, buf, offset, digest.length);
     return digest.length;
   }
+
+  public Object clone() throws CloneNotSupportedException {
+    throw new CloneNotSupportedException();
+  }
   
   protected int engineGetDigestLength() {
     return 0;
diff --git a/user/super/com/google/gwt/emul/java/security/SHA256Digest.java b/user/super/com/google/gwt/emul/java/security/SHA256Digest.java
index 20b0b700792..cade1be2ee9 100644
--- a/user/super/com/google/gwt/emul/java/security/SHA256Digest.java
+++ b/user/super/com/google/gwt/emul/java/security/SHA256Digest.java
@@ -20,7 +20,7 @@
 /**
  * SHA256 implementation for GWT.
  */
-public class SHA256Digest extends MessageDigest {
+class SHA256Digest extends MessageDigest {
 
   private static final int WORD_LENGTH = 32;
   private static final int[] K = {
@@ -66,6 +66,16 @@ protected void engineReset() {
     byteCounter = 0;
   }
 
+  public Object clone() {
+    SHA256Digest copy = new SHA256Digest();
+    copy.wordBuffer = Arrays.copyOf(wordBuffer, wordBuffer.length);
+    copy.blockBuffer = Arrays.copyOf(blockBuffer, blockBuffer.length);
+    copy.wordOff = wordOff;
+    copy.byteCounter = byteCounter;
+    copy.blockOff = blockOff;
+    return copy;
+  }
+
   @Override
   protected void engineUpdate(byte input) {
     wordBuffer[wordOff] = input;
diff --git a/user/super/com/google/gwt/emul/java/util/Collections.java b/user/super/com/google/gwt/emul/java/util/Collections.java
index a5bfd207a4b..691c0665cb8 100644
--- a/user/super/com/google/gwt/emul/java/util/Collections.java
+++ b/user/super/com/google/gwt/emul/java/util/Collections.java
@@ -802,6 +802,109 @@ public SortedMap<K, V> tailMap(K fromKey) {
     }
   }
 
+  static class UnmodifiableNavigableMap<K, V> extends UnmodifiableSortedMap<K, V>
+      implements NavigableMap<K, V> {
+
+    private final NavigableMap<K, V> navigableMap;
+
+    public UnmodifiableNavigableMap(NavigableMap<K, V> navigableMap) {
+      super(navigableMap);
+      this.navigableMap = navigableMap;
+    }
+
+    @Override
+    public Entry<K, V> lowerEntry(K key) {
+      return navigableMap.lowerEntry(key);
+    }
+
+    @Override
+    public K lowerKey(K key) {
+      return navigableMap.lowerKey(key);
+    }
+
+    @Override
+    public Entry<K, V> floorEntry(K key) {
+      return navigableMap.floorEntry(key);
+    }
+
+    @Override
+    public K floorKey(K key) {
+      return navigableMap.floorKey(key);
+    }
+
+    @Override
+    public Entry<K, V> ceilingEntry(K key) {
+      return navigableMap.ceilingEntry(key);
+    }
+
+    @Override
+    public K ceilingKey(K key) {
+      return navigableMap.ceilingKey(key);
+    }
+
+    @Override
+    public Entry<K, V> higherEntry(K key) {
+      return navigableMap.higherEntry(key);
+    }
+
+    @Override
+    public K higherKey(K key) {
+      return navigableMap.higherKey(key);
+    }
+
+    @Override
+    public Entry<K, V> firstEntry() {
+      return navigableMap.firstEntry();
+    }
+
+    @Override
+    public Entry<K, V> lastEntry() {
+      return navigableMap.lastEntry();
+    }
+
+    @Override
+    public Entry<K, V> pollFirstEntry() {
+      return navigableMap.pollFirstEntry();
+    }
+
+    @Override
+    public Entry<K, V> pollLastEntry() {
+      return navigableMap.pollLastEntry();
+    }
+
+    @Override
+    public NavigableMap<K, V> descendingMap() {
+      return new UnmodifiableNavigableMap<>(navigableMap.descendingMap());
+    }
+
+    @Override
+    public NavigableSet<K> navigableKeySet() {
+      return new UnmodifiableNavigableSet<K>(navigableMap.navigableKeySet());
+    }
+
+    @Override
+    public NavigableSet<K> descendingKeySet() {
+      return null;
+    }
+
+    @Override
+    public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive,
+        K toKey, boolean toInclusive) {
+      return new UnmodifiableNavigableMap<>(navigableMap
+          .subMap(fromKey, fromInclusive, toKey, toInclusive));
+    }
+
+    @Override
+    public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
+      return new UnmodifiableNavigableMap<>(navigableMap.headMap(toKey, inclusive));
+    }
+
+    @Override
+    public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
+      return new UnmodifiableNavigableMap<>(navigableMap.tailMap(fromKey, inclusive));
+    }
+  }
+
   static class UnmodifiableSortedSet<E> extends UnmodifiableSet<E> implements
       SortedSet<E> {
     private SortedSet<E> sortedSet;
@@ -854,6 +957,73 @@ public SortedSet<E> tailSet(E fromElement) {
     }
   }
 
+  private static class UnmodifiableNavigableSet<T> extends UnmodifiableSortedSet<T>
+      implements NavigableSet<T> {
+    private NavigableSet<T> navigableSet;
+
+    public UnmodifiableNavigableSet(NavigableSet<T> sortedSet) {
+      super(sortedSet);
+      this.navigableSet = sortedSet;
+    }
+
+    @Override
+    public T lower(T t) {
+      return navigableSet.lower(t);
+    }
+
+    @Override
+    public T floor(T t) {
+      return navigableSet.floor(t);
+    }
+
+    @Override
+    public T ceiling(T t) {
+      return navigableSet.ceiling(t);
+    }
+
+    @Override
+    public T higher(T t) {
+      return navigableSet.higher(t);
+    }
+
+    @Override
+    public T pollFirst() {
+      return navigableSet.pollFirst();
+    }
+
+    @Override
+    public T pollLast() {
+      return navigableSet.pollLast();
+    }
+
+    @Override
+    public NavigableSet<T> descendingSet() {
+      return new UnmodifiableNavigableSet<>(navigableSet.descendingSet());
+    }
+
+    @Override
+    public Iterator<T> descendingIterator() {
+      return navigableSet.descendingIterator();
+    }
+
+    @Override
+    public NavigableSet<T> subSet(T fromElement, boolean fromInclusive, T toElement,
+        boolean toInclusive) {
+      return new UnmodifiableNavigableSet<>(
+          navigableSet.subSet(fromElement,  fromInclusive, toElement, toInclusive));
+    }
+
+    @Override
+    public NavigableSet<T> headSet(T toElement, boolean inclusive) {
+      return new UnmodifiableNavigableSet<>(navigableSet.headSet(toElement, inclusive));
+    }
+
+    @Override
+    public NavigableSet<T> tailSet(T fromElement, boolean inclusive) {
+      return new UnmodifiableNavigableSet<>(navigableSet.tailSet(fromElement, inclusive));
+    }
+  }
+
   private static class UnmodifiableCollectionIterator<T> implements Iterator<T> {
     private final Iterator<? extends T> it;
 
@@ -1124,6 +1294,20 @@ public T nextElement() {
     };
   }
 
+  public static <T> Enumeration<T> emptyEnumeration() {
+    return new Enumeration<T>() {
+      @Override
+      public boolean hasMoreElements() {
+        return false;
+      }
+
+      @Override
+      public T nextElement() {
+        throw new NoSuchElementException();
+      }
+    };
+  }
+
   public static <T> void fill(List<? super T> list, T obj) {
     for (ListIterator<? super T> it = list.listIterator(); it.hasNext();) {
       it.next();
@@ -1373,6 +1557,57 @@ public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> set) {
     return new UnmodifiableSortedSet<T>(set);
   }
 
+  public static <K,V> NavigableMap unmodifiableNavigableMap(NavigableMap<K, V> map) {
+    return new UnmodifiableNavigableMap<>(map);
+  }
+
+  public static <T> NavigableSet unmodifiableNavigableSet(NavigableSet<T> set) {
+    return new UnmodifiableNavigableSet<>(set);
+  }
+
+  public static <E> SortedSet<E> emptySortedSet() {
+    return new UnmodifiableSortedSet<E>(new TreeSet<>());
+  }
+
+  public static <K, V> SortedMap<K,V> emptySortedMap() {
+    return new UnmodifiableSortedMap<>(new TreeMap<>());
+  }
+
+  public static <E> NavigableSet<E> emptyNavigableSet() {
+    return new UnmodifiableNavigableSet<E>(new TreeSet<>());
+  }
+
+  public static <K, V> NavigableMap<K,V> emptyNavigableMap() {
+    return new UnmodifiableNavigableMap<>(new TreeMap<>());
+  }
+
+  public static int indexOfSubList(List<?> source, List<?> target) {
+    for (int start = 0; start <= source.size() - target.size(); start++) {
+      if (sublistMatch(source, target, start)) {
+        return start;
+      }
+    }
+    return -1;
+  }
+
+  private static boolean sublistMatch(List<?> source, List<?> target, int start) {
+    for (int idx = 0; idx < target.size(); idx++) {
+      if (!Objects.equals(target.get(idx), source.get(idx + start))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public static int lastIndexOfSubList(List<?> source, List<?> target) {
+    for (int start = source.size() - target.size(); start >= 0; start--) {
+      if (sublistMatch(source, target, start)) {
+        return start;
+      }
+    }
+    return -1;
+  }
+
   /**
    * Computes hash code without preserving elements order (e.g. HashSet).
    */