diff --git a/doc/keepanno-guide.md b/doc/keepanno-guide.md
index 4f7665a..c41aa8b 100644
--- a/doc/keepanno-guide.md
+++ b/doc/keepanno-guide.md
@@ -31,7 +31,7 @@
 
 
 
-## Introduction<a id="introduction"></a>
+## Introduction<a name="introduction"></a>
 
 When using a Java/Kotlin shrinker such as R8 or Proguard, developers must inform
 the shrinker about parts of the program that are used either externally from the
@@ -50,7 +50,7 @@
 independent from keep rules and have a hopefully more clear and direct meaning.
 
 
-## Build configuration<a id="build-configuration"></a>
+## Build configuration<a name="build-configuration"></a>
 
 To use the keep annotations your build must include the library of
 annotations. It is currently built as part of each R8 build and if used with R8,
@@ -77,7 +77,7 @@
 ```
 
 
-## Annotating code using reflection<a id="using-reflection"></a>
+## Annotating code using reflection<a name="using-reflection"></a>
 
 The keep annotation library defines a family of annotations depending on your
 use case. You should generally prefer [@UsesReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsesReflection.html) where applicable.
@@ -85,7 +85,7 @@
 of such use cases are detailed below.
 
 
-### Invoking methods<a id="using-reflection-methods"></a>
+### Invoking methods<a name="using-reflection-methods"></a>
 
 For example, if your program is reflectively invoking a method, you
 should annotate the method that is doing the reflection. The annotation must describe the
@@ -117,7 +117,7 @@
 
 
 
-### Accessing fields<a id="using-reflection-fields"></a>
+### Accessing fields<a name="using-reflection-fields"></a>
 
 For example, if your program is reflectively accessing the fields on a class, you should
 annotate the method that is doing the reflection.
@@ -152,17 +152,153 @@
 
 
 
-## Annotating code used by reflection (or via JNI)<a id="used-by-reflection"></a>
+## Annotating code used by reflection (or via JNI)<a name="used-by-reflection"></a>
 
-TODO
+Sometimes reflecting code cannot be annotated. For example, the reflection can
+be done in native code or in a library outside your control. In such cases you
+can annotate the code that is being used by reflection with either
+[@UsedByReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html) or [@UsedByNative](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByNative.html). These two annotations are equivalent.
+Use the one that best matches why the annotation is needed.
+
+Let's consider some code with reflection outside our control.
+For example, the same field printing as in the above example might be part of a library.
+
+In this example, the `MyClassWithFields` is a class you are passing to the
+field-printing utility of the library. Since the library is reflectively accessing each field
+we annotate them with the [@UsedByReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html) annotation.
+
+We could additionally add the [@UsedByReflection.constraints](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html#constraints()) property as we did previously.
+We elide it here for brevity.
 
 
-## Annotating APIs<a id="apis"></a>
+```
+public class MyClassWithFields implements PrintableFieldInterface {
+  @UsedByReflection final int intField = 42;
 
-TODO
+  @UsedByReflection String stringField = "Hello!";
+}
+
+public static void run() throws Exception {
+  new FieldValuePrinterLibrary().printFieldValues(new MyClassWithFields());
+}
+```
 
 
-## Migrating rules to annotations<a id="migrating-rules"></a>
+Rather than annotate the individual fields we can annotate the holder and add a specification
+similar to the [@KeepTarget](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepTarget.html). The [@UsedByReflection.kind](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html#kind()) specifies that only the fields are
+used reflectively. In particular, the "field printer" example we are considering here does not
+make reflective assumptions about the holder class, so we should not constrain it.
+
+To be more precise let's add the [@UsedByReflection.constraints](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html#constraints()) property now. This specifies
+that the fields are looked up, their names are used/assumed and their values are read.
+
+
+```
+@UsedByReflection(
+    kind = KeepItemKind.ONLY_FIELDS,
+    constraints = {KeepConstraint.LOOKUP, KeepConstraint.NAME, KeepConstraint.FIELD_GET})
+public class MyClassWithFields implements PrintableFieldInterface {
+  final int intField = 42;
+  String stringField = "Hello!";
+}
+```
+
+
+Our use of [@UsedByReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html) is still not as flexible as the original [@UsesReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsesReflection.html). In
+particular, if we change our code to no longer have any call to the library method
+`printFieldValues` the shrinker will still keep all of the fields on our annotated class.
+
+This is because the [@UsesReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsesReflection.html) implicitly encodes as a precondition that the annotated
+method is actually used in the program. If not, the [@UsesReflection](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsesReflection.html) annotation is not
+"active".
+
+Luckily we can specify the same precondition using [@UsedByReflection.preconditions](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/UsedByReflection.html#preconditions()).
+
+
+```
+@UsedByReflection(
+    preconditions = {
+      @KeepCondition(
+          classConstant = FieldValuePrinterLibrary.class,
+          methodName = "printFieldValues")
+    },
+    kind = KeepItemKind.ONLY_FIELDS,
+    constraints = {KeepConstraint.LOOKUP, KeepConstraint.NAME, KeepConstraint.FIELD_GET})
+public class MyClassWithFields implements PrintableFieldInterface {
+  final int intField = 42;
+  String stringField = "Hello!";
+}
+```
+
+
+
+## Annotating APIs<a name="apis"></a>
+
+If your code is being shrunk before release as a library, or if you have an API
+surface that is used via dynamic loading at runtime, then you need to keep the
+API surface. For that you should use the [@KeepForApi](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepForApi.html) annotation.
+
+When annotating a class the default for [@KeepForApi](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepForApi.html) is to keep the class as well as all of its
+public and protected members:
+
+
+```
+@KeepForApi
+public class MyApi {
+  public void thisPublicMethodIsKept() {
+    /* ... */
+  }
+
+  protected void thisProtectedMethodIsKept() {
+    /* ... */
+  }
+
+  void thisPackagePrivateMethodIsNotKept() {
+    /* ... */
+  }
+
+  private void thisPrivateMethodIsNotKept() {
+    /* ... */
+  }
+}
+```
+
+
+The default can be changed using the [@KeepForApi.memberAccess](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepForApi.html#memberAccess()) property:
+
+
+```
+@KeepForApi(
+    memberAccess = {
+      MemberAccessFlags.PUBLIC,
+      MemberAccessFlags.PROTECTED,
+      MemberAccessFlags.PACKAGE_PRIVATE
+    })
+```
+
+
+The [@KeepForApi](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepForApi.html) annotation can also be placed directly on members and avoid keeping
+unannotated members. The holder class is implicitly kept. When annotating the members
+directly, the access does not matter as illustrated here by annotating a package private method:
+
+
+```
+public class MyOtherApi {
+
+  public void notKept() {
+    /* ... */
+  }
+
+  @KeepForApi
+  void isKept() {
+    /* ... */
+  }
+}
+```
+
+
+
+## Migrating rules to annotations<a name="migrating-rules"></a>
 
 There is no automatic migration of keep rules. Keep annotations often invert the
 direction and rules have no indication of where the reflection is taking
@@ -202,7 +338,7 @@
 
 
 
-## My use case is not covered!<a id="other-uses"></a>
+## My use case is not covered!<a name="other-uses"></a>
 
 The annotation library is in active development and not all use cases are
 described here or supported. Reach out to the R8 team by
@@ -210,7 +346,7 @@
 Describe your use case and we will look at how best to support it.
 
 
-## Troubleshooting<a id="troubleshooting"></a>
+## Troubleshooting<a name="troubleshooting"></a>
 
 If an annotation is not working as expected it may be helpful to inspect the
 rules that have been extracted for the annotation. This can be done by
diff --git a/doc/keepanno-guide.template.md b/doc/keepanno-guide.template.md
index 6e3efde..104bf02 100644
--- a/doc/keepanno-guide.template.md
+++ b/doc/keepanno-guide.template.md
@@ -86,12 +86,43 @@
 
 ## [Annotating code used by reflection (or via JNI)](used-by-reflection)
 
-TODO
+Sometimes reflecting code cannot be annotated. For example, the reflection can
+be done in native code or in a library outside your control. In such cases you
+can annotate the code that is being used by reflection with either
+`@UsedByReflection` or `@UsedByNative`. These two annotations are equivalent.
+Use the one that best matches why the annotation is needed.
+
+Let's consider some code with reflection outside our control.
+[[[INCLUDE DOC:UsedByReflectionFieldPrinterOnFields]]]
+
+[[[INCLUDE CODE:UsedByReflectionFieldPrinterOnFields]]]
+
+[[[INCLUDE DOC:UsedByReflectionFieldPrinterOnClass]]]
+
+[[[INCLUDE CODE:UsedByReflectionFieldPrinterOnClass]]]
+
+[[[INCLUDE DOC:UsedByReflectionFieldPrinterConditional]]]
+
+[[[INCLUDE CODE:UsedByReflectionFieldPrinterConditional]]]
 
 
 ## [Annotating APIs](apis)
 
-TODO
+If your code is being shrunk before release as a library, or if you have an API
+surface that is used via dynamic loading at runtime, then you need to keep the
+API surface. For that you should use the `@KeepForApi` annotation.
+
+[[[INCLUDE DOC:ApiClass]]]
+
+[[[INCLUDE CODE:ApiClass]]]
+
+[[[INCLUDE DOC:ApiClassMemberAccess]]]
+
+[[[INCLUDE CODE:ApiClassMemberAccess]]]
+
+[[[INCLUDE DOC:ApiMember]]]
+
+[[[INCLUDE CODE:ApiMember]]]
 
 
 ## [Migrating rules to annotations](migrating-rules)
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepBinding.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepBinding.java
index b98f4ab..177990e 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepBinding.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepBinding.java
@@ -431,11 +431,27 @@
    * <p>If none, and other properties define this item as a field, the default matches any field
    * name.
    *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
    * @return The exact field name of the field.
    */
   String fieldName() default "";
 
   /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
    * Define the field-type pattern by a fully qualified type.
    *
    * <p>Mutually exclusive with all method properties.
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java
index bab5ca7..a35d08b 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java
@@ -432,13 +432,37 @@
    * <p>If none, and other properties define this item as a field, the default matches any field
    * name.
    *
-   * <p>Mutually exclusive with the property `memberFromBinding` also defining field-name.
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldNamePattern
+   *   <li>memberFromBinding
+   * </ul>
    *
    * @return The exact field name of the field.
    */
   String fieldName() default "";
 
   /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldName
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
    * Define the field-type pattern by a fully qualified type.
    *
    * <p>Mutually exclusive with all method properties.
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepForApi.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepForApi.java
index 9d097f0..4b56b2e 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepForApi.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepForApi.java
@@ -210,11 +210,27 @@
    * <p>If none, and other properties define this item as a field, the default matches any field
    * name.
    *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
    * @return The exact field name of the field.
    */
   String fieldName() default "";
 
   /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
    * Define the field-type pattern by a fully qualified type.
    *
    * <p>Mutually exclusive with all method properties.
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java
index d601a6a..e2ebc3b 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java
@@ -529,13 +529,37 @@
    * <p>If none, and other properties define this item as a field, the default matches any field
    * name.
    *
-   * <p>Mutually exclusive with the property `memberFromBinding` also defining field-name.
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldNamePattern
+   *   <li>memberFromBinding
+   * </ul>
    *
    * @return The exact field name of the field.
    */
   String fieldName() default "";
 
   /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldName
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
    * Define the field-type pattern by a fully qualified type.
    *
    * <p>Mutually exclusive with all method properties.
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByNative.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByNative.java
index 229d0f1..f025c0e 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByNative.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByNative.java
@@ -253,11 +253,27 @@
    * <p>If none, and other properties define this item as a field, the default matches any field
    * name.
    *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
    * @return The exact field name of the field.
    */
   String fieldName() default "";
 
   /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
    * Define the field-type pattern by a fully qualified type.
    *
    * <p>Mutually exclusive with all method properties.
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByReflection.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByReflection.java
index 7b8fa8e..8076e51 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByReflection.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/UsedByReflection.java
@@ -253,11 +253,27 @@
    * <p>If none, and other properties define this item as a field, the default matches any field
    * name.
    *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
    * @return The exact field name of the field.
    */
   String fieldName() default "";
 
   /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
    * Define the field-type pattern by a fully qualified type.
    *
    * <p>Mutually exclusive with all method properties.
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java
index 7f03de2..91751e6 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java
@@ -829,9 +829,6 @@
         if (!descriptor.equals(itemDescriptor)) {
           throw parsingContext.error("must reference its class context " + className);
         }
-        if (itemPattern.isMemberItemPattern() && items.size() == 1) {
-          throw parsingContext.error("kind must include its class");
-        }
         if (!holderPattern.getInstanceOfPattern().isAny()) {
           throw parsingContext.error("cannot define an 'extends' pattern.");
         }
@@ -1567,6 +1564,7 @@
   private static class FieldDeclaration extends Declaration<KeepFieldPattern> {
 
     private final ParsingContext parsingContext;
+    private final StringPatternParser nameParser;
     private final FieldTypeParser typeParser;
     private KeepFieldAccessPattern.Builder accessBuilder = null;
     private KeepFieldPattern.Builder builder = null;
@@ -1574,12 +1572,16 @@
 
     public FieldDeclaration(ParsingContext parsingContext) {
       this.parsingContext = parsingContext;
+      nameParser = new StringPatternParser(parsingContext.group(Item.fieldNameGroup));
+      nameParser.setProperty(Item.fieldName, StringProperty.EXACT);
+      nameParser.setProperty(Item.fieldNamePattern, StringProperty.PATTERN);
+
       typeParser = new FieldTypeParser(parsingContext.group(Item.fieldTypeGroup));
       typeParser.setProperty(Item.fieldTypePattern, TypeProperty.TYPE_PATTERN);
       typeParser.setProperty(Item.fieldType, TypeProperty.TYPE_NAME);
       typeParser.setProperty(Item.fieldTypeConstant, TypeProperty.TYPE_CONSTANT);
 
-      parsers = Collections.singletonList(typeParser);
+      parsers = ImmutableList.of(nameParser, typeParser);
     }
 
     @Override
@@ -1603,6 +1605,9 @@
       if (accessBuilder != null) {
         getBuilder().setAccessPattern(accessBuilder.build());
       }
+      if (!nameParser.isDefault()) {
+        getBuilder().setNamePattern(KeepFieldNamePattern.fromStringPattern(nameParser.getValue()));
+      }
       if (!typeParser.isDefault()) {
         getBuilder().setTypePattern(typeParser.getValue());
       }
@@ -1610,15 +1615,6 @@
     }
 
     @Override
-    boolean tryParse(String name, Object value) {
-      if (name.equals(Item.fieldName) && value instanceof String) {
-        getBuilder().setNamePattern(KeepFieldNamePattern.exact((String) value));
-        return true;
-      }
-      return super.tryParse(name, value);
-    }
-
-    @Override
     AnnotationVisitor tryParseArray(String name) {
       if (name.equals(Item.fieldAccess)) {
         accessBuilder = KeepFieldAccessPattern.builder();
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java
index c714960..332e101 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.keepanno.ast.KeepConsequences;
 import com.android.tools.r8.keepanno.ast.KeepEdge;
 import com.android.tools.r8.keepanno.ast.KeepEdgeException;
-import com.android.tools.r8.keepanno.ast.KeepFieldNamePattern.KeepFieldNameExactPattern;
 import com.android.tools.r8.keepanno.ast.KeepFieldPattern;
 import com.android.tools.r8.keepanno.ast.KeepItemPattern;
 import com.android.tools.r8.keepanno.ast.KeepMemberItemPattern;
@@ -187,9 +186,9 @@
   }
 
   private void writeField(KeepFieldPattern field, AnnotationVisitor targetVisitor) {
-    KeepFieldNameExactPattern exactFieldName = field.getNamePattern().asExact();
+    String exactFieldName = field.getNamePattern().asExactString();
     if (exactFieldName != null) {
-      targetVisitor.visit(Item.fieldName, exactFieldName.getName());
+      targetVisitor.visit(Item.fieldName, exactFieldName);
     } else {
       throw new Unimplemented();
     }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/AnnotationConstants.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/AnnotationConstants.java
index c489701..f0bdccf 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/AnnotationConstants.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/AnnotationConstants.java
@@ -94,7 +94,9 @@
     public static final String methodParameters = "methodParameters";
     public static final String methodParameterTypePatterns = "methodParameterTypePatterns";
     public static final String fieldAccess = "fieldAccess";
+    public static final String fieldNameGroup = "field-name";
     public static final String fieldName = "fieldName";
+    public static final String fieldNamePattern = "fieldNamePattern";
     public static final String fieldTypeGroup = "field-type";
     public static final String fieldType = "fieldType";
     public static final String fieldTypeConstant = "fieldTypeConstant";
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldNamePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldNamePattern.java
index 0945764..5223e60 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldNamePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldNamePattern.java
@@ -3,96 +3,44 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.keepanno.ast;
 
-public abstract class KeepFieldNamePattern {
+public class KeepFieldNamePattern {
+
+  private static final KeepFieldNamePattern ANY = new KeepFieldNamePattern(KeepStringPattern.any());
 
   public static KeepFieldNamePattern any() {
-    return Any.getInstance();
+    return ANY;
   }
 
   public static KeepFieldNamePattern exact(String methodName) {
-    return new KeepFieldNameExactPattern(methodName);
+    return fromStringPattern(KeepStringPattern.exact(methodName));
   }
 
-  private KeepFieldNamePattern() {}
+  public static KeepFieldNamePattern fromStringPattern(KeepStringPattern pattern) {
+    if (pattern.isAny()) {
+      return ANY;
+    }
+    return new KeepFieldNamePattern(pattern);
+  }
+
+  private final KeepStringPattern pattern;
+
+  private KeepFieldNamePattern(KeepStringPattern pattern) {
+    this.pattern = pattern;
+  }
+
+  public KeepStringPattern asStringPattern() {
+    return pattern;
+  }
 
   public boolean isAny() {
-    return false;
+    return ANY == this;
   }
 
   public final boolean isExact() {
-    return asExact() != null;
+    return pattern.isExact();
   }
 
-  public KeepFieldNameExactPattern asExact() {
-    return null;
-  }
-
-  private static class Any extends KeepFieldNamePattern {
-    private static final Any INSTANCE = new Any();
-
-    public static Any getInstance() {
-      return INSTANCE;
-    }
-
-    @Override
-    public boolean isAny() {
-      return true;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      return this == obj;
-    }
-
-    @Override
-    public int hashCode() {
-      return System.identityHashCode(this);
-    }
-
-    @Override
-    public String toString() {
-      return "*";
-    }
-  }
-
-  public static class KeepFieldNameExactPattern extends KeepFieldNamePattern {
-    private final String name;
-
-    public KeepFieldNameExactPattern(String name) {
-      assert name != null;
-      this.name = name;
-    }
-
-    @Override
-    public KeepFieldNameExactPattern asExact() {
-      return this;
-    }
-
-    public String getName() {
-      return name;
-    }
-
-    @Override
-    @SuppressWarnings("EqualsGetClass")
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      KeepFieldNameExactPattern that = (KeepFieldNameExactPattern) o;
-      return name.equals(that.name);
-    }
-
-    @Override
-    public int hashCode() {
-      return name.hashCode();
-    }
-
-    @Override
-    public String toString() {
-      return name;
-    }
+  public String asExactString() {
+    return pattern.asExactString();
   }
 }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java
index 6843e61..b79b616 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java
@@ -3,17 +3,27 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.keepanno.ast;
 
+public class KeepMethodNamePattern {
 
-public abstract class KeepMethodNamePattern {
   private static final String INIT_STRING = "<init>";
   private static final String CLINIT_STRING = "<clinit>";
+  private static final KeepMethodNamePattern ANY =
+      new KeepMethodNamePattern(KeepStringPattern.any());
+  private static final KeepMethodNamePattern INSTANCE_INIT =
+      new KeepMethodNamePattern(KeepStringPattern.exact(INIT_STRING));
+  private static final KeepMethodNamePattern CLASS_INIT =
+      new KeepMethodNamePattern(KeepStringPattern.exact(CLINIT_STRING));
 
   public static KeepMethodNamePattern any() {
-    return SomePattern.ANY;
+    return KeepMethodNamePattern.ANY;
   }
 
-  public static KeepMethodNamePattern initializer() {
-    return SomePattern.INSTANCE_INIT;
+  public static KeepMethodNamePattern instanceInitializer() {
+    return KeepMethodNamePattern.INSTANCE_INIT;
+  }
+
+  public static KeepMethodNamePattern classInitializer() {
+    return KeepMethodNamePattern.CLASS_INIT;
   }
 
   public static KeepMethodNamePattern exact(String methodName) {
@@ -22,98 +32,70 @@
 
   public static KeepMethodNamePattern fromStringPattern(KeepStringPattern pattern) {
     if (pattern.isAny()) {
-      return SomePattern.ANY;
+      return KeepMethodNamePattern.ANY;
     }
     if (pattern.isExact()) {
       String exact = pattern.asExactString();
       if (INIT_STRING.equals(exact)) {
-        return SomePattern.INSTANCE_INIT;
+        return KeepMethodNamePattern.INSTANCE_INIT;
       }
       if (CLINIT_STRING.equals(exact)) {
-        return SomePattern.CLASS_INIT;
+        return KeepMethodNamePattern.CLASS_INIT;
       }
     }
-    return new SomePattern(pattern);
+    return new KeepMethodNamePattern(pattern);
   }
 
-  private KeepMethodNamePattern() {}
+  private final KeepStringPattern pattern;
 
-  public abstract boolean isAny();
+  private KeepMethodNamePattern(KeepStringPattern pattern) {
+    assert pattern != null;
+    this.pattern = pattern;
+  }
 
-  public abstract boolean isInstanceInitializer();
+  public KeepStringPattern asStringPattern() {
+    return pattern;
+  }
 
-  public abstract boolean isClassInitializer();
-
-  public abstract boolean isExact();
-
-  public abstract String asExactString();
-
-  public abstract KeepStringPattern asStringPattern();
-
-  private static class SomePattern extends KeepMethodNamePattern {
-    private static final SomePattern ANY = new SomePattern(KeepStringPattern.any());
-    private static final KeepMethodNamePattern INSTANCE_INIT =
-        new SomePattern(KeepStringPattern.exact("<init>"));
-    private static final KeepMethodNamePattern CLASS_INIT =
-        new SomePattern(KeepStringPattern.exact("<clinit>"));
-
-    private final KeepStringPattern pattern;
-
-    public SomePattern(KeepStringPattern pattern) {
-      assert pattern != null;
-      this.pattern = pattern;
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
     }
-
-    @Override
-    public KeepStringPattern asStringPattern() {
-      return pattern;
+    if (!(o instanceof KeepMethodNamePattern)) {
+      return false;
     }
+    KeepMethodNamePattern that = (KeepMethodNamePattern) o;
+    return pattern.equals(that.pattern);
+  }
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (!(o instanceof SomePattern)) {
-        return false;
-      }
-      SomePattern that = (SomePattern) o;
-      return pattern.equals(that.pattern);
-    }
+  @Override
+  public int hashCode() {
+    return pattern.hashCode();
+  }
 
-    @Override
-    public int hashCode() {
-      return pattern.hashCode();
-    }
+  @Override
+  public String toString() {
+    return pattern.toString();
+  }
 
-    @Override
-    public String toString() {
-      return pattern.toString();
-    }
+  public boolean isAny() {
+    return ANY == this;
+  }
 
-    @Override
-    public boolean isAny() {
-      return ANY == this;
-    }
+  public boolean isClassInitializer() {
+    return CLASS_INIT == this;
+  }
 
-    @Override
-    public boolean isClassInitializer() {
-      return CLASS_INIT == this;
-    }
+  public boolean isInstanceInitializer() {
+    return INSTANCE_INIT == this;
+  }
 
-    @Override
-    public boolean isInstanceInitializer() {
-      return INSTANCE_INIT == this;
-    }
+  public boolean isExact() {
+    return pattern.isExact();
+  }
 
-    @Override
-    public boolean isExact() {
-      return pattern.isExact();
-    }
-
-    @Override
-    public String asExactString() {
-      return pattern.asExactString();
-    }
+  public String asExactString() {
+    return pattern.asExactString();
   }
 }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/keeprules/RulePrintingUtils.java b/src/keepanno/java/com/android/tools/r8/keepanno/keeprules/RulePrintingUtils.java
index f16d9dd..7737744 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/keeprules/RulePrintingUtils.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/keeprules/RulePrintingUtils.java
@@ -176,9 +176,7 @@
   }
 
   private static RulePrinter printFieldName(RulePrinter builder, KeepFieldNamePattern namePattern) {
-    return namePattern.isAny()
-        ? builder.appendStar()
-        : builder.append(namePattern.asExact().getName());
+    return printStringPattern(builder, namePattern.asStringPattern());
   }
 
   private static RulePrinter printMethodName(
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index ad074ed..32d16c3 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -907,7 +907,9 @@
           }
         }
       }
-
+      if (options.androidResourceProguardMapStrings != null) {
+        resourceShrinkerBuilder.setProguardMapStrings(options.androidResourceProguardMapStrings);
+      }
       LegacyResourceShrinker shrinker = resourceShrinkerBuilder.build();
       ShrinkerResult shrinkerResult;
       if (options.resourceShrinkerConfiguration.isOptimizedShrinking()) {
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 405f214..2b20068 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -1177,13 +1177,21 @@
     MapConsumer mapConsumer =
         wrapExistingMapConsumerIfNotNull(
             internal.mapConsumer, partitionMapConsumer, MapConsumerToPartitionMapConsumer::new);
-    internal.mapConsumer =
+    mapConsumer =
         wrapExistingMapConsumerIfNotNull(
             mapConsumer,
             stringConsumer,
             nonNullStringConsumer ->
                 ProguardMapStringConsumer.builder().setStringConsumer(stringConsumer).build());
 
+    internal.mapConsumer =
+        wrapExistingMapConsumerIfNotNull(
+            mapConsumer,
+            androidResourceConsumer,
+            nonNulStringConsumer ->
+                ProguardMapStringConsumer.builder()
+                    .setStringConsumer(new ResourceShrinkerMapStringConsumer(internal))
+                    .build());
     // Amend the usage information consumer with options from the proguard configuration.
     internal.usageInformationConsumer =
         wrapStringConsumer(
@@ -1308,6 +1316,27 @@
     return optionConsumer;
   }
 
+  private static class ResourceShrinkerMapStringConsumer implements StringConsumer {
+
+    private final InternalOptions internal;
+    private StringBuilder resultBuilder = new StringBuilder();
+
+    public ResourceShrinkerMapStringConsumer(InternalOptions internal) {
+      this.internal = internal;
+    }
+
+    @Override
+    public void accept(String string, DiagnosticsHandler handler) {
+      resultBuilder.append(string);
+    }
+
+    @Override
+    public void finished(DiagnosticsHandler handler) {
+      internal.androidResourceProguardMapStrings = StringUtils.splitLines(resultBuilder.toString());
+      resultBuilder = null;
+    }
+  }
+
   private static class StandardOutConsumer extends StringConsumer.ForwardingConsumer {
 
     public StandardOutConsumer(StringConsumer consumer) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java b/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java
index d26c44c..2d8cc3e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java
@@ -244,6 +244,10 @@
     return get(Opcodes.MUL);
   }
 
+  public boolean mayHaveNewArrayEmpty() {
+    return get(Opcodes.NEW_ARRAY_EMPTY);
+  }
+
   public boolean mayHaveNewArrayFilled() {
     return get(Opcodes.NEW_ARRAY_FILLED);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java
index 2a93788..df8d38a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java
@@ -96,15 +96,12 @@
       BasicBlock block = worklist.next();
       hasChanged |= simplifyArrayConstructionBlock(block, worklist, code, appView.options());
     }
-    if (hasChanged) {
-      code.removeRedundantBlocks();
-    }
     return CodeRewriterResult.hasChanged(hasChanged);
   }
 
   @Override
   protected boolean shouldRewriteCode(IRCode code) {
-    return true;
+    return code.metadata().mayHaveNewArrayEmpty();
   }
 
   private boolean simplifyArrayConstructionBlock(
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java
index e269dc1..28a40a5 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java
@@ -31,11 +31,14 @@
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
+import com.android.tools.r8.utils.BooleanBox;
 import com.android.tools.r8.utils.InternalOptions.RewriteArrayOptions;
 import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
+import java.util.ArrayList;
 import java.util.IdentityHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -61,31 +64,63 @@
   protected CodeRewriterResult rewriteCode(IRCode code) {
     assert !mayHaveRedundantBlocks;
     assert toRemove == NOTHING;
-    BasicBlockIterator blockIterator = code.listIterator();
     CodeRewriterResult result = noChange();
-    while (blockIterator.hasNext()) {
-      BasicBlock block = blockIterator.next();
-      BasicBlockInstructionListIterator instructionIterator = block.listIterator(code);
-      while (instructionIterator.hasNext()) {
-        Instruction instruction = instructionIterator.next();
-        if (instruction.isNewArrayFilled()) {
-          result =
-              processInstruction(
-                  code, blockIterator, instructionIterator, instruction.asNewArrayFilled(), result);
+    BooleanBox pendingRewrites = new BooleanBox(true);
+    while (pendingRewrites.get()) {
+      pendingRewrites.set(false);
+      BasicBlockIterator blockIterator = code.listIterator();
+      while (blockIterator.hasNext()) {
+        BasicBlock block = blockIterator.next();
+        BasicBlockInstructionListIterator instructionIterator = block.listIterator(code);
+        while (instructionIterator.hasNext()) {
+          Instruction instruction = instructionIterator.next();
+          if (instruction.isNewArrayFilled()) {
+            result =
+                processInstruction(
+                    code,
+                    blockIterator,
+                    instructionIterator,
+                    instruction.asNewArrayFilled(),
+                    result,
+                    pendingRewrites);
+          }
         }
       }
-    }
-    if (!toRemove.isEmpty()) {
-      InstructionListIterator it = code.instructionListIterator();
-      while (it.hasNext()) {
-        if (toRemove.contains(it.next())) {
-          it.remove();
-          mayHaveRedundantBlocks = true;
+      if (!toRemove.isEmpty()) {
+        Set<Instruction> additionalToRemove = SetUtils.newIdentityHashSet();
+        InstructionListIterator it = code.instructionListIterator();
+        while (it.hasNext()) {
+          Instruction next = it.next();
+          if (toRemove.contains(next)) {
+            // Also remove constants used by the removed NewArrayFilled.
+            if (next.isNewArrayFilled()) {
+              next.inValues()
+                  .forEach(
+                      value -> {
+                        if (value.hasSingleUniqueUser()) {
+                          additionalToRemove.add(value.getDefinition());
+                        }
+                      });
+            }
+            it.remove();
+            mayHaveRedundantBlocks = true;
+          }
+        }
+        if (!additionalToRemove.isEmpty()) {
+          InstructionListIterator itAdditional = code.instructionListIterator();
+          while (itAdditional.hasNext()) {
+            Instruction next = itAdditional.next();
+            if (additionalToRemove.contains(next)) {
+              itAdditional.remove();
+              mayHaveRedundantBlocks = true;
+            }
+          }
         }
       }
-    }
-    if (mayHaveRedundantBlocks) {
-      code.removeRedundantBlocks();
+      toRemove = NOTHING;
+      if (mayHaveRedundantBlocks) {
+        code.removeRedundantBlocks();
+      }
     }
     return result;
   }
@@ -95,12 +130,49 @@
     return code.metadata().mayHaveNewArrayFilled();
   }
 
+  private boolean isNewArrayFilledOfConstants(NewArrayFilled newArrayFilled) {
+    for (Value inValue : newArrayFilled.inValues()) {
+      if (!inValue.isConstNumber() && !inValue.isConstString() && !inValue.isConstClass()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean isDefinedByNewArrayFilledOfConstants(Value value) {
+    if (!value.isDefinedByInstructionSatisfying(Instruction::isNewArrayFilled)) {
+      return false;
+    }
+    return isNewArrayFilledOfConstants(value.definition.asNewArrayFilled());
+  }
+
+  public NewArrayFilled copyConstantsNewArrayFilled(IRCode code, NewArrayFilled original) {
+    assert isNewArrayFilledOfConstants(original);
+    Value newValue = code.createValue(original.getOutType(), original.getLocalInfo());
+    List<Value> newArguments = new ArrayList<>(original.inValues().size());
+    for (Value value : original.inValues()) {
+      if (value.isConstNumber()) {
+        newArguments.add(
+            ConstNumber.copyOf(code, value.getDefinition().asConstNumber()).outValue());
+      } else if (value.isConstString()) {
+        newArguments.add(
+            ConstString.copyOf(code, value.getDefinition().asConstString()).outValue());
+      } else if (value.isConstClass()) {
+        newArguments.add(ConstClass.copyOf(code, value.getDefinition().asConstClass()).outValue());
+      } else {
+        assert false;
+      }
+    }
+    return new NewArrayFilled(original.getArrayType(), newValue, newArguments);
+  }
+
   private CodeRewriterResult processInstruction(
       IRCode code,
       BasicBlockIterator blockIterator,
       BasicBlockInstructionListIterator instructionIterator,
       NewArrayFilled newArrayFilled,
-      CodeRewriterResult result) {
+      CodeRewriterResult result,
+      BooleanBox pendingRewrites) {
     if (canUseNewArrayFilled(newArrayFilled)) {
       return result;
     }
@@ -108,13 +180,59 @@
       instructionIterator.removeOrReplaceByDebugLocalRead();
     } else if (canUseNewArrayFilledData(newArrayFilled)) {
       rewriteToNewArrayFilledData(code, blockIterator, instructionIterator, newArrayFilled);
+    } else if (newArrayFilled.outValue().hasSingleUniqueUser()
+        && newArrayFilled.outValue().singleUniqueUser().isNewArrayFilled()
+        && isNewArrayFilledOfConstants(newArrayFilled)) {
+      if (canUseNewArrayFilled(newArrayFilled.outValue().singleUniqueUser().asNewArrayFilled())) {
+        // The NewArrayFilled user is supported, so rewrite here.
+        rewriteToArrayPuts(code, blockIterator, instructionIterator, newArrayFilled);
+      } else {
+        // The NewArrayFilled user is not supported so leave for rewriting after that.
+        //
+        // The effect of this is that when the user of this NewArrayFilled is rewritten to puts,
+        // the NewArrayFilled construction is copied to the use site
+        //
+        //  Input:
+        //
+        //   v0 <-  Const X
+        //   v1 <-  NewArrayFilled(v0)
+        //   v2 <-  Const Y
+        //   v3 <-  NewArrayFilled(v2)
+        //   v4 <-  NewArrayFilled(v1, v3)
+        //
+        // After rewriting the user (v0 - v3 are unused and removed):
+        //
+        //   v4 <-  NewArrayEmpty(...)
+        //   v5 <-  Const X
+        //   v6 <-  NewArrayFilled(v5)
+        //          APut v4, <Const 0>, v6
+        //   v7 <-  Const Y
+        //   v8 <-  NewArrayFilled(v7)
+        //          APut v4, <Const 1>, v8
+        //
+        // Setting pending rewrites cause the copied NewArrayFilled to be rewritten in their new
+        // location in the fixpoint:
+        //
+        //   v4 <-  NewArrayEmpty(...)
+        //   v9 <-  NewArrayEmpty(...)
+        //   v10 <- Const X
+        //          APut v9, <Const 0>, v10
+        //          APut v4, <Const 0>, v9
+        //   v11 <- NewArrayEmpty(...)
+        //   v12 <- Const Y
+        //          APut v11, <Const 0>, v12
+        //          APut v4, <Const 1>, v11
+        //
+        // If the NewArrayFilled which gets moved is supported then the second rewriting in the
+        // fixpoint does not happen.
+        pendingRewrites.set(true);
+      }
     } else {
       rewriteToArrayPuts(code, blockIterator, instructionIterator, newArrayFilled);
     }
     return CodeRewriterResult.HAS_CHANGED;
   }
 
-  @SuppressWarnings("ReferenceEquality")
   private boolean canUseNewArrayFilled(NewArrayFilled newArrayFilled) {
     if (!options.isGeneratingDex()) {
       return false;
@@ -125,7 +243,7 @@
     }
     // filled-new-array is implemented only for int[] and Object[].
     DexType arrayType = newArrayFilled.getArrayType();
-    if (arrayType == dexItemFactory.intArrayType) {
+    if (arrayType.isIdenticalTo(dexItemFactory.intArrayType)) {
       // For int[], using filled-new-array is usually smaller than filled-array-data.
       // filled-new-array supports up to 5 registers before it's filled-new-array/range.
       if (size > rewriteArrayOptions.maxSizeForFilledNewArrayOfInts) {
@@ -143,7 +261,7 @@
       if (size > rewriteArrayOptions.maxSizeForFilledNewArrayOfReferences) {
         return false;
       }
-      if (arrayType == dexItemFactory.stringArrayType) {
+      if (arrayType.isIdenticalTo(dexItemFactory.stringArrayType)) {
         return rewriteArrayOptions.canUseFilledNewArrayOfStrings();
       }
       if (!rewriteArrayOptions.canUseFilledNewArrayOfNonStringObjects()) {
@@ -155,7 +273,7 @@
       }
       // Check that all arguments to the array is the array type or that the array is type Object[].
       if (rewriteArrayOptions.canHaveSubTypesInFilledNewArrayBug()
-          && arrayType != dexItemFactory.objectArrayType
+          && arrayType.isNotIdenticalTo(dexItemFactory.objectArrayType)
           && !arrayType.isPrimitiveArrayType()) {
         DexType arrayElementType = arrayType.toArrayElementType(dexItemFactory);
         for (Value elementValue : newArrayFilled.inValues()) {
@@ -169,9 +287,8 @@
     return false;
   }
 
-  @SuppressWarnings("ReferenceEquality")
   private boolean canStoreElementInNewArrayFilled(TypeElement valueType, DexType elementType) {
-    if (elementType == dexItemFactory.objectType) {
+    if (elementType.isIdenticalTo(dexItemFactory.objectType)) {
       return true;
     }
     if (valueType.isNullType() && !elementType.isPrimitiveType()) {
@@ -512,7 +629,9 @@
         || !(elementValue.isConstString()
             || elementValue.isConstNumber()
             || elementValue.isConstClass()
-            || elementValue.isDefinedByInstructionSatisfying(Instruction::isStaticGet))) {
+            || elementValue.isDefinedByInstructionSatisfying(Instruction::isStaticGet)
+            || (isDefinedByNewArrayFilledOfConstants(elementValue)
+                && !instructionIterator.getBlock().hasCatchHandlers()))) {
       return elementValue;
     }
 
@@ -534,6 +653,14 @@
     } else if (elementValue.isDefinedByInstructionSatisfying(Instruction::isStaticGet)) {
       copy = StaticGet.copyOf(code, elementValue.getDefinition().asStaticGet());
       constantMaterializingInstructionCache.putNewValue(copy.asStaticGet().outValue());
+    } else if (isDefinedByNewArrayFilledOfConstants(elementValue)) {
+      copy = copyConstantsNewArrayFilled(code, elementValue.getDefinition().asNewArrayFilled());
+      assert !instructionIterator.getBlock().hasCatchHandlers();
+      for (Value inValue : copy.asNewArrayFilled().inValues()) {
+        instructionIterator.add(inValue.getDefinition());
+        inValue.getDefinition().setBlock(instructionIterator.getBlock());
+        inValue.getDefinition().setPosition(newArrayEmpty.getPosition());
+      }
     } else {
       assert false;
       return elementValue;
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
index 26d9e87..8100e4e 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
@@ -5,6 +5,7 @@
 
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 import static com.android.tools.r8.utils.MapUtils.ignoreKey;
+import static com.google.common.base.Predicates.alwaysFalse;
 
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
@@ -16,6 +17,7 @@
 import com.android.tools.r8.graph.DexEncodedMember;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItem;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexReference;
@@ -28,15 +30,22 @@
 import com.android.tools.r8.graph.lens.NonIdentityGraphLens;
 import com.android.tools.r8.shaking.KeepFieldInfo.Joiner;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.MapUtils;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.Streams;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.IdentityHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 // Non-mutable collection of keep information pertaining to a program.
@@ -253,6 +262,8 @@
 
   public abstract KeepInfoCollection mutate(Consumer<MutableKeepInfoCollection> mutator);
 
+  public abstract void writeToDirectory(Path directory) throws IOException;
+
   // Mutation interface for building up the keep info.
   public static class MutableKeepInfoCollection extends KeepInfoCollection {
 
@@ -611,5 +622,53 @@
             }
           });
     }
+
+    @Override
+    public void writeToDirectory(Path directory) throws IOException {
+      writePropertyToFile(
+          directory.resolve("no-horizontal-class-merging.txt"),
+          classInfo -> !classInfo.internalIsHorizontalClassMergingAllowed(),
+          alwaysFalse(),
+          alwaysFalse());
+      writePropertyToFile(
+          directory.resolve("no-optimization.txt"),
+          classInfo -> !classInfo.internalIsOptimizationAllowed(),
+          fieldInfo -> !fieldInfo.internalIsOptimizationAllowed(),
+          methodInfo -> !methodInfo.internalIsOptimizationAllowed());
+      writePropertyToFile(
+          directory.resolve("no-shrinking.txt"),
+          classInfo -> !classInfo.internalIsShrinkingAllowed(),
+          fieldInfo -> !fieldInfo.internalIsShrinkingAllowed(),
+          methodInfo -> !methodInfo.internalIsShrinkingAllowed());
+    }
+
+    private void writePropertyToFile(
+        Path path,
+        Predicate<KeepClassInfo> classInfoPredicate,
+        Predicate<KeepFieldInfo> fieldInfoPredicate,
+        Predicate<KeepMethodInfo> methodInfoPredicate)
+        throws IOException {
+      List<DexReference> lines = new ArrayList<>();
+      keepClassInfo.forEach(
+          (clazz, info) -> {
+            if (classInfoPredicate.test(info)) {
+              lines.add(clazz);
+            }
+          });
+      keepFieldInfo.forEach(
+          (field, info) -> {
+            if (fieldInfoPredicate.test(info)) {
+              lines.add(field);
+            }
+          });
+      keepMethodInfo.forEach(
+          (method, info) -> {
+            if (methodInfoPredicate.test(info)) {
+              lines.add(method);
+            }
+          });
+      lines.sort(DexReference::compareTo);
+      Files.write(path, ListUtils.map(lines, DexItem::toSourceString));
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java b/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
index 79b6f5f..2279a8e 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
@@ -253,7 +253,6 @@
     if (getMemberRules() != null) {
       memberRules =
           getMemberRules().stream()
-              .filter(rule -> rule.getRuleType().includesMethods())
               .map(memberRule -> memberRule.materialize(dexItemFactory))
               .collect(Collectors.toList());
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 7dc92f2..d13b3d0 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.shaking;
 
+import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 import static com.google.common.base.Predicates.alwaysFalse;
 
 import com.android.tools.r8.androidapi.ComputedApiLevel;
@@ -154,8 +155,9 @@
       retainReachableInterfacesFrom(type, reachableInterfaces);
     }
     if (!reachableInterfaces.isEmpty()) {
+      boolean pinnedHolder = !appView.getKeepInfo(clazz).isOptimizationAllowed(appView.options());
       removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(
-          clazz.superType, reachableInterfaces);
+          pinnedHolder, clazz.superType, reachableInterfaces, clazz);
     }
     if (reachableInterfaces.isEmpty()) {
       clazz.interfaces = DexTypeList.empty();
@@ -165,7 +167,7 @@
   }
 
   private void removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(
-      DexType type, Set<DexType> interfaces) {
+      boolean pinnedRoot, DexType type, Set<DexType> interfaces, DexProgramClass context) {
     DexClass clazz = appView.definitionFor(type);
     if (clazz == null) {
       return;
@@ -176,13 +178,22 @@
       return;
     }
     for (DexType itf : clazz.interfaces) {
+      if (pinnedRoot) {
+        DexProgramClass itfClass = asProgramClassOrNull(appView.definitionFor(itf, context));
+        if (itfClass == null
+            || !appView.getKeepInfo(itfClass).isOptimizationAllowed(appView.options())) {
+          // If root-holder and interface are pinned then retain the interface on the root-holder.
+          continue;
+        }
+      }
       if (interfaces.remove(itf) && interfaces.isEmpty()) {
         return;
       }
     }
     if (clazz.superType != null) {
       assert !interfaces.isEmpty();
-      removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(clazz.superType, interfaces);
+      removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(
+          pinnedRoot, clazz.superType, interfaces, context);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 26a4087..011fbfb 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -201,6 +201,8 @@
   public CancelCompilationChecker cancelCompilationChecker = null;
   public AndroidResourceProvider androidResourceProvider = null;
   public AndroidResourceConsumer androidResourceConsumer = null;
+  public List<String> androidResourceProguardMapStrings = null;
+
   public ResourceShrinkerConfiguration resourceShrinkerConfiguration =
       ResourceShrinkerConfiguration.DEFAULT_CONFIGURATION;
   public ResourceAccessAnalysis resourceAccessAnalysis = null;
diff --git a/src/resourceshrinker/java/com/android/build/shrinker/obfuscation/ProguardMappingsRecorder.kt b/src/resourceshrinker/java/com/android/build/shrinker/obfuscation/ProguardMappingsRecorder.kt
index dd538c7..2e2aaca 100644
--- a/src/resourceshrinker/java/com/android/build/shrinker/obfuscation/ProguardMappingsRecorder.kt
+++ b/src/resourceshrinker/java/com/android/build/shrinker/obfuscation/ProguardMappingsRecorder.kt
@@ -24,9 +24,12 @@
 /**
  * Records obfuscation mappings from single file in proguard format.
  *
- * @param mappingsFile path to proguard.map file.
+ * @param mapping file lines or the mapping file path.
  */
-class ProguardMappingsRecorder(private val mappingsFile: Path) : ObfuscationMappingsRecorder {
+class ProguardMappingsRecorder(private val mappingLines: List<String>) : ObfuscationMappingsRecorder {
+
+    constructor(mappingsFile: Path)
+      : this(Files.readAllLines(mappingsFile, StandardCharsets.UTF_8));
 
     override fun recordObfuscationMappings(model: ResourceShrinkerModel) {
         model.obfuscatedClasses = extractObfuscatedResourceClasses()
@@ -41,9 +44,8 @@
         // com.package.R -> a.b:
         // com.package.R$style -> a.b.a:
         //     int Toolbar_android_gravity -> i1
-
         val builder = ObfuscatedClasses.Builder()
-        Files.readAllLines(mappingsFile, StandardCharsets.UTF_8).forEach { line ->
+        mappingLines.forEach { line ->
             when {
                 isMethodMapping(line) -> builder.addMethodMapping(extractMethodMapping(line))
                 isClassMapping(line) -> builder.addClassMapping(extractClassMapping(line))
diff --git a/src/resourceshrinker/java/com/android/build/shrinker/r8integration/LegacyResourceShrinker.java b/src/resourceshrinker/java/com/android/build/shrinker/r8integration/LegacyResourceShrinker.java
index ad7ddfb..1c0a875 100644
--- a/src/resourceshrinker/java/com/android/build/shrinker/r8integration/LegacyResourceShrinker.java
+++ b/src/resourceshrinker/java/com/android/build/shrinker/r8integration/LegacyResourceShrinker.java
@@ -15,6 +15,7 @@
 import com.android.build.shrinker.ResourceTableUtilKt;
 import com.android.build.shrinker.graph.ProtoResourcesGraphBuilder;
 import com.android.build.shrinker.graph.ResFolderFileTree;
+import com.android.build.shrinker.obfuscation.ProguardMappingsRecorder;
 import com.android.build.shrinker.r8integration.R8ResourceShrinkerState.R8ResourceShrinkerModel;
 import com.android.build.shrinker.usages.DexFileAnalysisCallback;
 import com.android.build.shrinker.usages.ProtoAndroidManifestUsageRecorderKt;
@@ -48,6 +49,7 @@
   private final Map<String, byte[]> dexInputs;
   private final List<PathAndBytes> resFolderInputs;
   private final List<PathAndBytes> xmlInputs;
+  private List<String> proguardMapStrings;
   private final List<PathAndBytes> manifest;
   private final Map<PathAndBytes, FeatureSplit> resourceTables;
 
@@ -59,6 +61,7 @@
 
     private final List<PathAndBytes> manifests = new ArrayList<>();
     private final Map<PathAndBytes, FeatureSplit> resourceTables = new HashMap<>();
+    private List<String> proguardMapStrings;
 
     private Builder() {}
 
@@ -96,7 +99,11 @@
     public LegacyResourceShrinker build() {
       assert manifests != null && resourceTables != null;
       return new LegacyResourceShrinker(
-          dexInputs, resFolderInputs, manifests, resourceTables, xmlInputs);
+          dexInputs, resFolderInputs, manifests, resourceTables, xmlInputs, proguardMapStrings);
+    }
+
+    public void setProguardMapStrings(List<String> proguardMapStrings) {
+      this.proguardMapStrings = proguardMapStrings;
     }
   }
 
@@ -105,12 +112,14 @@
       List<PathAndBytes> resFolderInputs,
       List<PathAndBytes> manifests,
       Map<PathAndBytes, FeatureSplit> resourceTables,
-      List<PathAndBytes> xmlInputs) {
+      List<PathAndBytes> xmlInputs,
+      List<String> proguardMapStrings) {
     this.dexInputs = dexInputs;
     this.resFolderInputs = resFolderInputs;
     this.manifest = manifests;
     this.resourceTables = resourceTables;
     this.xmlInputs = xmlInputs;
+    this.proguardMapStrings = proguardMapStrings;
   }
 
   public static Builder builder() {
@@ -127,6 +136,10 @@
   }
 
   public ShrinkerResult shrinkModel(R8ResourceShrinkerModel model) throws IOException {
+    if (proguardMapStrings != null) {
+      new ProguardMappingsRecorder(proguardMapStrings).recordObfuscationMappings(model);
+      proguardMapStrings = null;
+    }
     for (Entry<String, byte[]> entry : dexInputs.entrySet()) {
       // The analysis needs an origin for the dex files, synthesize an easy recognizable one.
       Path inMemoryR8 = Paths.get("in_memory_r8_" + entry.getKey() + ".dex");
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 9d47152..729f5e7 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -1787,6 +1787,20 @@
             ToolHelper.getDexVersionForApiLevel(apiLevelWithJavaTime()));
   }
 
+  public boolean canUseFilledNewArrayOfInteger(TestParameters parameters) {
+    return parameters.isDexRuntime();
+  }
+
+  public boolean canUseFilledNewArrayOfStringObjects(TestParameters parameters) {
+    return parameters.isDexRuntime()
+        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
+  }
+
+  public boolean canUseFilledNewArrayOfNonStringObjects(TestParameters parameters) {
+    return parameters.isDexRuntime()
+        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
+  }
+
   // TODO(b/131130038): Do not allow accessmodification when kept.
   public boolean isForceAccessModifyingPackagePrivateAndProtectedMethods() {
     return true;
diff --git a/src/test/java/com/android/tools/r8/androidresources/RClassStaticValuesIgnoreTest.java b/src/test/java/com/android/tools/r8/androidresources/RClassStaticValuesIgnoreTest.java
new file mode 100644
index 0000000..fdc8a87
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/androidresources/RClassStaticValuesIgnoreTest.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.androidresources;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.androidresources.AndroidResourceTestingUtils.AndroidTestResource;
+import com.android.tools.r8.androidresources.AndroidResourceTestingUtils.AndroidTestResourceBuilder;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RClassStaticValuesIgnoreTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  private static final String RClassDescriptor =
+      descriptor(RClassStaticValuesIgnoreTest.class)
+          .replace(RClassStaticValuesIgnoreTest.class.getSimpleName(), "R$string");
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection parameters() {
+    return getTestParameters().withDefaultDexRuntime().withAllApiLevels().build();
+  }
+
+  public static AndroidTestResource getTestResources(TemporaryFolder temp) throws Exception {
+    return new AndroidTestResourceBuilder()
+        .withSimpleManifestAndAppNameString()
+        .addRClassInitializeWithDefaultValues(R.string.class)
+        .build(temp);
+  }
+
+  private byte[] getRClassWithReferenceToUnused() throws IOException {
+    return transformer(ToBeRenamedToRDollarString.class)
+        .setClassDescriptor(RClassDescriptor)
+        .transform();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    AndroidTestResource testResources = getTestResources(temp);
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters)
+        .addProgramClasses(FooBar.class)
+        .addProgramClassFileData(getRClassWithReferenceToUnused())
+        .addKeepClassAndMembersRulesWithAllowObfuscation(
+            DescriptorUtils.descriptorToJavaType(RClassDescriptor))
+        .addAndroidResources(testResources)
+        .addKeepMainRule(FooBar.class)
+        .compile()
+        .inspectShrunkenResources(
+            resourceTableInspector -> {
+              resourceTableInspector.assertContainsResourceWithName("string", "bar");
+              resourceTableInspector.assertDoesNotContainResourceWithName(
+                  "string", "unused_string");
+            })
+        .run(parameters.getRuntime(), FooBar.class)
+        .assertSuccess();
+  }
+
+  public static class FooBar {
+
+    public static void main(String[] args) {
+      if (System.currentTimeMillis() == 0) {
+        System.out.println(R.string.bar);
+      }
+    }
+  }
+
+  // Simulate R class usage of unused_string
+  public static class ToBeRenamedToRDollarString {
+    public static int use_the_unused = RClassStaticValuesIgnoreTest.R.string.unused_string;
+  }
+
+  public static class R {
+    public static class string {
+
+      public static int bar;
+      public static int unused_string;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignaturePrunedInterfacesKeepTest.java b/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignaturePrunedInterfacesKeepTest.java
index 6d6b915..7cbbdf2 100644
--- a/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignaturePrunedInterfacesKeepTest.java
+++ b/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignaturePrunedInterfacesKeepTest.java
@@ -39,7 +39,8 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .setMinApi(parameters)
-        .addKeepAllClassesRule()
+        .addKeepMainRule(Main.class)
+        .addKeepClassRules(J.class, A.class, B.class)
         .addKeepAttributeSignature()
         .addKeepAttributeInnerClassesAndEnclosingMethod()
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedButKeptInterfaceTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedButKeptInterfaceTest.java
new file mode 100644
index 0000000..21f61ce
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedButKeptInterfaceTest.java
@@ -0,0 +1,77 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.unusedinterfaces;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/* Regression test for b/318787479 */
+@RunWith(Parameterized.class)
+public class UnusedButKeptInterfaceTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("A: I", "B:", "C: I");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public UnusedButKeptInterfaceTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testReference() throws Exception {
+    testForRuntime(parameters)
+        .addInnerClasses(UnusedButKeptInterfaceTest.class)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(UnusedButKeptInterfaceTest.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepClassRules(I.class, A.class, B.class, C.class)
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  interface I {}
+
+  static class A implements I {}
+
+  static class B extends A {}
+
+  static class C extends A implements I {}
+
+  static class TestClass {
+
+    static String innerName(Class<?> clazz) {
+      String typeName = clazz.getName();
+      return typeName.substring(typeName.lastIndexOf('$') + 1);
+    }
+
+    public static void main(String[] args) {
+      for (Class<?> c : Arrays.asList(A.class, B.class, C.class)) {
+        System.out.print(innerName(c) + ":");
+        for (Class<?> iface : c.getInterfaces()) {
+          System.out.print(" " + innerName(iface));
+        }
+        System.out.println();
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/doctests/ConditionalMethodRulesAndHorizontalMergingTest.java b/src/test/java/com/android/tools/r8/keepanno/ConditionalMethodRulesAndHorizontalMergingTest.java
similarity index 88%
rename from src/test/java/com/android/tools/r8/keepanno/doctests/ConditionalMethodRulesAndHorizontalMergingTest.java
rename to src/test/java/com/android/tools/r8/keepanno/ConditionalMethodRulesAndHorizontalMergingTest.java
index ee1748d..8bf2e6a 100644
--- a/src/test/java/com/android/tools/r8/keepanno/doctests/ConditionalMethodRulesAndHorizontalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/ConditionalMethodRulesAndHorizontalMergingTest.java
@@ -1,15 +1,15 @@
-// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.keepanno.doctests;
+package com.android.tools.r8.keepanno;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.keepanno.doctests.ConditionalMethodRulesAndHorizontalMergingTest.Example1.BaseClass;
-import com.android.tools.r8.keepanno.doctests.ConditionalMethodRulesAndHorizontalMergingTest.Example1.MyHiddenMethodCaller;
-import com.android.tools.r8.keepanno.doctests.ConditionalMethodRulesAndHorizontalMergingTest.Example2.MyFieldValuePrinter;
-import com.android.tools.r8.keepanno.doctests.ConditionalMethodRulesAndHorizontalMergingTest.Example2.PrintableFieldInterface;
+import com.android.tools.r8.keepanno.ConditionalMethodRulesAndHorizontalMergingTest.Example1.BaseClass;
+import com.android.tools.r8.keepanno.ConditionalMethodRulesAndHorizontalMergingTest.Example1.MyHiddenMethodCaller;
+import com.android.tools.r8.keepanno.ConditionalMethodRulesAndHorizontalMergingTest.Example2.MyFieldValuePrinter;
+import com.android.tools.r8.keepanno.ConditionalMethodRulesAndHorizontalMergingTest.Example2.PrintableFieldInterface;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
diff --git a/src/test/java/com/android/tools/r8/keepanno/FieldNameStringPatternsTest.java b/src/test/java/com/android/tools/r8/keepanno/FieldNameStringPatternsTest.java
new file mode 100644
index 0000000..520c65c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/FieldNameStringPatternsTest.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.keepanno;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.keepanno.annotations.KeepItemKind;
+import com.android.tools.r8.keepanno.annotations.KeepTarget;
+import com.android.tools.r8.keepanno.annotations.StringPattern;
+import com.android.tools.r8.keepanno.annotations.UsedByReflection;
+import com.android.tools.r8.keepanno.annotations.UsesReflection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.lang.reflect.Field;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class FieldNameStringPatternsTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("1", "2");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public FieldNameStringPatternsTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testReference() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(getInputClasses())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .enableExperimentalKeepAnnotations()
+        .addProgramClasses(getInputClasses())
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkOutput);
+  }
+
+  public List<Class<?>> getInputClasses() {
+    return ImmutableList.of(TestClass.class, A.class, B.class);
+  }
+
+  private void checkOutput(CodeInspector inspector) {
+    assertThat(inspector.clazz(B.class), isPresentAndRenamed());
+    assertThat(inspector.clazz(B.class).field("int", "bar"), isAbsent());
+    assertThat(inspector.clazz(B.class).field("int", "hiddenOneI"), isPresent());
+    assertThat(inspector.clazz(B.class).field("int", "hiddenTwoI"), isPresent());
+    assertThat(inspector.clazz(B.class).field("java.lang.String", "hiddenSomeS"), isAbsent());
+  }
+
+  static class A {
+
+    @UsesReflection(
+        @KeepTarget(
+            classConstant = B.class,
+            fieldNamePattern = @StringPattern(startsWith = "hidden", endsWith = "I")))
+    public void foo() throws Exception {
+      int counter = 1;
+      for (Field field : B.class.getDeclaredFields()) {
+        String name = field.getName();
+        if (name.startsWith("hidden")) {
+          if (name.endsWith("I")) {
+            field.set(null, counter++);
+          }
+        }
+      }
+      for (Field field : B.class.getDeclaredFields()) {
+        String name = field.getName();
+        if (name.startsWith("hidden")) {
+          if (name.endsWith("I")) {
+            System.out.println(field.get(null));
+          }
+        }
+      }
+    }
+  }
+
+  static class B {
+    static int hiddenOneI = 9;
+    static int hiddenTwoI = 18;
+    static String hiddenSomeS = "foo";
+    static int bar = 7;
+  }
+
+  static class TestClass {
+
+    @UsedByReflection(kind = KeepItemKind.CLASS_AND_METHODS)
+    public static void main(String[] args) throws Exception {
+      new A().foo();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java b/src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java
index 8a83cf9..dae2c6b 100644
--- a/src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java
@@ -250,7 +250,7 @@
 
   private KeepMemberPattern defaultInitializerPattern() {
     return KeepMethodPattern.builder()
-        .setNamePattern(KeepMethodNamePattern.initializer())
+        .setNamePattern(KeepMethodNamePattern.instanceInitializer())
         .setParametersPattern(KeepMethodParametersPattern.none())
         .setReturnTypeVoid()
         .build();
diff --git a/src/test/java/com/android/tools/r8/keepanno/doctests/ForApiDocumentationTest.java b/src/test/java/com/android/tools/r8/keepanno/doctests/ForApiDocumentationTest.java
new file mode 100644
index 0000000..7df53d6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/doctests/ForApiDocumentationTest.java
@@ -0,0 +1,210 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.keepanno.doctests;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.keepanno.annotations.KeepForApi;
+import com.android.tools.r8.keepanno.annotations.MemberAccessFlags;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ForApiDocumentationTest extends TestBase {
+
+  static final String EXPECTED_1_REF =
+      StringUtils.joinLines(
+          "thisPackagePrivateMethodIsNotKept",
+          "thisPrivateMethodIsNotKept",
+          "thisProtectedMethodIsKept",
+          "thisPublicMethodIsKept");
+
+  static final String EXPECTED_1_R8 =
+      StringUtils.joinLines("thisProtectedMethodIsKept", "thisPublicMethodIsKept");
+
+  static final String EXPECTED_2_REF =
+      StringUtils.joinLines(
+          "thisPackagePrivateMethodIsKept",
+          "thisPrivateMethodIsNotKept",
+          "thisProtectedMethodIsKept",
+          "thisPublicMethodIsKept");
+
+  static final String EXPECTED_2_R8 =
+      StringUtils.joinLines(
+          "thisPackagePrivateMethodIsKept", "thisProtectedMethodIsKept", "thisPublicMethodIsKept");
+
+  static final String EXPECTED_3_REF = StringUtils.joinLines("isKept", "notKept");
+
+  static final String EXPECTED_3_R8 = StringUtils.joinLines("isKept");
+
+  static final String EXPECTED_REF =
+      StringUtils.lines(EXPECTED_1_REF, EXPECTED_2_REF, EXPECTED_3_REF);
+
+  static final String EXPECTED_R8 = StringUtils.lines(EXPECTED_1_R8, EXPECTED_2_R8, EXPECTED_3_R8);
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public ForApiDocumentationTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testReference() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(TestClass.class)
+        .addProgramClassesAndInnerClasses(getExampleClasses())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED_REF);
+  }
+
+  @Test
+  public void testWithRuleExtraction() throws Exception {
+    testForR8(parameters.getBackend())
+        .enableExperimentalKeepAnnotations()
+        .addProgramClasses(TestClass.class)
+        .addProgramClassesAndInnerClasses(getExampleClasses())
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED_R8);
+  }
+
+  public List<Class<?>> getExampleClasses() {
+    return ImmutableList.of(Example1.class, Example2.class, Example3.class);
+  }
+
+  static class Example1 {
+
+    /* INCLUDE DOC: ApiClass
+    When annotating a class the default for `@KeepForApi` is to keep the class as well as all of its
+    public and protected members:
+    INCLUDE END */
+
+    static
+    // INCLUDE CODE: ApiClass
+    @KeepForApi
+    public class MyApi {
+      public void thisPublicMethodIsKept() {
+        /* ... */
+      }
+
+      protected void thisProtectedMethodIsKept() {
+        /* ... */
+      }
+
+      void thisPackagePrivateMethodIsNotKept() {
+        /* ... */
+      }
+
+      private void thisPrivateMethodIsNotKept() {
+        /* ... */
+      }
+    }
+
+    // INCLUDE END
+
+    static void run() throws Exception {
+      TestClass.printMethods(MyApi.class);
+    }
+  }
+
+  static class Example2 {
+
+    /* INCLUDE DOC: ApiClassMemberAccess
+    The default can be changed using the `@KeepForApi#memberAccess` property:
+    INCLUDE END */
+
+    // INCLUDE CODE: ApiClassMemberAccess
+    @KeepForApi(
+        memberAccess = {
+          MemberAccessFlags.PUBLIC,
+          MemberAccessFlags.PROTECTED,
+          MemberAccessFlags.PACKAGE_PRIVATE
+        })
+    // INCLUDE END
+    public static class MyApi {
+      public void thisPublicMethodIsKept() {
+        /* ... */
+      }
+
+      protected void thisProtectedMethodIsKept() {
+        /* ... */
+      }
+
+      void thisPackagePrivateMethodIsKept() {
+        /* ... */
+      }
+
+      private void thisPrivateMethodIsNotKept() {
+        /* ... */
+      }
+    }
+
+    static void run() throws Exception {
+      TestClass.printMethods(MyApi.class);
+    }
+  }
+
+  static class Example3 {
+
+    /* INCLUDE DOC: ApiMember
+    The `@KeepForApi` annotation can also be placed directly on members and avoid keeping
+    unannotated members. The holder class is implicitly kept. When annotating the members
+    directly, the access does not matter as illustrated here by annotating a package private method:
+    INCLUDE END */
+
+    static
+    // INCLUDE CODE: ApiMember
+    public class MyOtherApi {
+
+      public void notKept() {
+        /* ... */
+      }
+
+      @KeepForApi
+      void isKept() {
+        /* ... */
+      }
+    }
+
+    // INCLUDE END
+
+    static void run() throws Exception {
+      TestClass.printMethods(MyOtherApi.class);
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) throws Exception {
+      Example1.run();
+      Example2.run();
+      Example3.run();
+    }
+
+    static void printMethods(Class<?> clazz) {
+      List<String> names = new ArrayList<>();
+      for (Method m : clazz.getDeclaredMethods()) {
+        names.add(m.getName());
+      }
+      names.sort(String::compareTo);
+      for (String name : names) {
+        System.out.println(name);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionDocumentationTest.java b/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionDocumentationTest.java
index 0cf7639..98a2f0d 100644
--- a/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionDocumentationTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionDocumentationTest.java
@@ -6,9 +6,11 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.keepanno.annotations.KeepCondition;
 import com.android.tools.r8.keepanno.annotations.KeepConstraint;
 import com.android.tools.r8.keepanno.annotations.KeepItemKind;
 import com.android.tools.r8.keepanno.annotations.KeepTarget;
+import com.android.tools.r8.keepanno.annotations.UsedByReflection;
 import com.android.tools.r8.keepanno.annotations.UsesReflection;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
@@ -22,8 +24,17 @@
 @RunWith(Parameterized.class)
 public class UsesReflectionDocumentationTest extends TestBase {
 
+  static final String EXPECTED_METHOD_EXAMPLE = StringUtils.joinLines("on Base", "on Sub");
+  static final String EXPECTED_FIELD_EXAMPLE =
+      StringUtils.joinLines("intField = 42", "stringField = Hello!");
+
   static final String EXPECTED =
-      StringUtils.lines("on Base", "on Sub", "intField = 42", "stringField = Hello!");
+      StringUtils.lines(
+          EXPECTED_METHOD_EXAMPLE,
+          EXPECTED_FIELD_EXAMPLE,
+          EXPECTED_FIELD_EXAMPLE,
+          EXPECTED_FIELD_EXAMPLE,
+          EXPECTED_FIELD_EXAMPLE);
 
   private final TestParameters parameters;
 
@@ -58,7 +69,8 @@
   }
 
   public List<Class<?>> getExampleClasses() {
-    return ImmutableList.of(Example1.class, Example2.class);
+    return ImmutableList.of(
+        Example1.class, Example2.class, Example3.class, Example4.class, Example5.class);
   }
 
   static class Example1 {
@@ -160,11 +172,140 @@
     }
   }
 
+  static class Example3 {
+
+    interface PrintableFieldInterface {}
+
+    /* INCLUDE DOC: UsedByReflectionFieldPrinterOnFields
+    For example, the same field printing as in the above example might be part of a library.
+
+    In this example, the `MyClassWithFields` is a class you are passing to the
+    field-printing utility of the library. Since the library is reflectively accessing each field
+    we annotate them with the `@UsedByReflection` annotation.
+
+    We could additionally add the `@UsedByReflection#constraints` property as we did previously.
+    We elide it here for brevity.
+    INCLUDE END */
+
+    static
+    // INCLUDE CODE: UsedByReflectionFieldPrinterOnFields
+    public class MyClassWithFields implements PrintableFieldInterface {
+      @UsedByReflection final int intField = 42;
+
+      @UsedByReflection String stringField = "Hello!";
+    }
+
+    public static void run() throws Exception {
+      new FieldValuePrinterLibrary().printFieldValues(new MyClassWithFields());
+    }
+
+    // INCLUDE END
+
+    public static class FieldValuePrinterLibrary {
+
+      public void printFieldValues(PrintableFieldInterface objectWithFields) throws Exception {
+        for (Field field : objectWithFields.getClass().getDeclaredFields()) {
+          System.out.println(field.getName() + " = " + field.get(objectWithFields));
+        }
+      }
+    }
+  }
+
+  static class Example4 {
+
+    interface PrintableFieldInterface {}
+
+    /* INCLUDE DOC: UsedByReflectionFieldPrinterOnClass
+    Rather than annotate the individual fields we can annotate the holder and add a specification
+    similar to the `@KeepTarget`. The `@UsedByReflection#kind` specifies that only the fields are
+    used reflectively. In particular, the "field printer" example we are considering here does not
+    make reflective assumptions about the holder class, so we should not constrain it.
+
+    To be more precise let's add the `@UsedByReflection#constraints` property now. This specifies
+    that the fields are looked up, their names are used/assumed and their values are read.
+    INCLUDE END */
+
+    static
+    // INCLUDE CODE: UsedByReflectionFieldPrinterOnClass
+    @UsedByReflection(
+        kind = KeepItemKind.ONLY_FIELDS,
+        constraints = {KeepConstraint.LOOKUP, KeepConstraint.NAME, KeepConstraint.FIELD_GET})
+    public class MyClassWithFields implements PrintableFieldInterface {
+      final int intField = 42;
+      String stringField = "Hello!";
+    }
+
+    // INCLUDE END
+
+    public static void run() throws Exception {
+      new FieldValuePrinterLibrary().printFieldValues(new MyClassWithFields());
+    }
+
+    public static class FieldValuePrinterLibrary {
+
+      public void printFieldValues(PrintableFieldInterface objectWithFields) throws Exception {
+        for (Field field : objectWithFields.getClass().getDeclaredFields()) {
+          System.out.println(field.getName() + " = " + field.get(objectWithFields));
+        }
+      }
+    }
+  }
+
+  static class Example5 {
+
+    interface PrintableFieldInterface {}
+
+    /* INCLUDE DOC: UsedByReflectionFieldPrinterConditional
+    Our use of `@UsedByReflection` is still not as flexible as the original `@UsesReflection`. In
+    particular, if we change our code to no longer have any call to the library method
+    `printFieldValues` the shrinker will still keep all of the fields on our annotated class.
+
+    This is because the `@UsesReflection` implicitly encodes as a precondition that the annotated
+    method is actually used in the program. If not, the `@UsesReflection` annotation is not
+    "active".
+
+    Luckily we can specify the same precondition using `@UsedByReflection#preconditions`.
+    INCLUDE END */
+
+    static
+    // INCLUDE CODE: UsedByReflectionFieldPrinterConditional
+    @UsedByReflection(
+        preconditions = {
+          @KeepCondition(
+              classConstant = FieldValuePrinterLibrary.class,
+              methodName = "printFieldValues")
+        },
+        kind = KeepItemKind.ONLY_FIELDS,
+        constraints = {KeepConstraint.LOOKUP, KeepConstraint.NAME, KeepConstraint.FIELD_GET})
+    public class MyClassWithFields implements PrintableFieldInterface {
+      final int intField = 42;
+      String stringField = "Hello!";
+    }
+
+    // INCLUDE END
+
+    public static void run() throws Exception {
+      new FieldValuePrinterLibrary().printFieldValues(new MyClassWithFields());
+    }
+
+    public static class FieldValuePrinterLibrary {
+
+      public void printFieldValues(PrintableFieldInterface objectWithFields) throws Exception {
+        for (Field field : objectWithFields.getClass().getDeclaredFields()) {
+          System.out.println(field.getName() + " = " + field.get(objectWithFields));
+        }
+      }
+    }
+  }
+
   static class TestClass {
 
     public static void main(String[] args) throws Exception {
       Example1.run();
       Example2.run();
+      Example3.run();
+      Example4.run();
+      Example5.run();
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/keepanno/utils/KeepAnnoMarkdownGenerator.java b/src/test/java/com/android/tools/r8/keepanno/utils/KeepAnnoMarkdownGenerator.java
index 9088752..9376fa3 100644
--- a/src/test/java/com/android/tools/r8/keepanno/utils/KeepAnnoMarkdownGenerator.java
+++ b/src/test/java/com/android/tools/r8/keepanno/utils/KeepAnnoMarkdownGenerator.java
@@ -20,6 +20,7 @@
 import com.android.tools.r8.keepanno.annotations.UsedByNative;
 import com.android.tools.r8.keepanno.annotations.UsedByReflection;
 import com.android.tools.r8.keepanno.annotations.UsesReflection;
+import com.android.tools.r8.keepanno.doctests.ForApiDocumentationTest;
 import com.android.tools.r8.keepanno.doctests.MainMethodsDocumentationTest;
 import com.android.tools.r8.keepanno.doctests.UsesReflectionDocumentationTest;
 import com.android.tools.r8.keepanno.utils.KeepItemAnnotationGenerator.Generator;
@@ -92,7 +93,9 @@
             MethodAccessFlags.class,
             FieldAccessFlags.class);
     populateCodeAndDocReplacements(
-        UsesReflectionDocumentationTest.class, MainMethodsDocumentationTest.class);
+        UsesReflectionDocumentationTest.class,
+        ForApiDocumentationTest.class,
+        MainMethodsDocumentationTest.class);
   }
 
   private Map<String, String> getTypeLinkReplacements(Class<?>... classes) {
@@ -418,7 +421,7 @@
     }
 
     public String getIdAnchor() {
-      return name + "<a id=" + quote(id) + "></a>";
+      return name + "<a name=" + quote(id) + "></a>";
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/keepanno/utils/KeepItemAnnotationGenerator.java b/src/test/java/com/android/tools/r8/keepanno/utils/KeepItemAnnotationGenerator.java
index 0ab89fa..61265cb 100644
--- a/src/test/java/com/android/tools/r8/keepanno/utils/KeepItemAnnotationGenerator.java
+++ b/src/test/java/com/android/tools/r8/keepanno/utils/KeepItemAnnotationGenerator.java
@@ -821,7 +821,14 @@
                   .addParagraph(getMutuallyExclusiveForFieldProperties())
                   .addParagraph(getFieldDefaultDoc("any field name"))
                   .setDocReturn("The exact field name of the field.")
-                  .defaultEmptyString());
+                  .defaultEmptyString())
+          .addMember(
+              new GroupMember("fieldNamePattern")
+                  .setDocTitle("Define the field-name pattern by a string pattern.")
+                  .addParagraph(getMutuallyExclusiveForFieldProperties())
+                  .addParagraph(getFieldDefaultDoc("any field name"))
+                  .setDocReturn("The string pattern of the field name.")
+                  .defaultValue(StringPattern.class, DEFAULT_INVALID_STRING_PATTERN));
     }
 
     private Group createFieldTypeGroup() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index 12b507d..ba27997 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -257,6 +257,7 @@
                 testBuilder.addKeepRules(
                     "-neverinline class kotlin.jvm.internal.Intrinsics {",
                     "  *** checkNotNullParameter(...);",
+                    "  *** checkParameterIsNotNull(...);",
                     "}"))
         .inspect(
             inspector -> {
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfArraysTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfArraysTest.java
new file mode 100644
index 0000000..82ae38f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfArraysTest.java
@@ -0,0 +1,185 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.rewrite.arrays;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ArrayOfArraysTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public CompilationMode compilationMode;
+
+  @Parameters(name = "{0}, mode = {1}")
+  public static Iterable<?> data() {
+    return buildParameters(
+        getTestParameters()
+            .withDefaultCfRuntime()
+            .withDexRuntimesAndAllApiLevels()
+            .withAllApiLevelsAlsoForCf()
+            .build(),
+        CompilationMode.values());
+  }
+
+  private static final String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          "[class [B, class [S, class [I, class [J, class [C, class [F, class [D, class"
+              + " [Ljava.lang.String;, [class [B, class [S, class [I, class [J, class [C, class [F,"
+              + " class [D, class [Ljava.lang.String;]]",
+          "[class [B, class [S, class [I, class [J, class [C, class [F, class [D, class"
+              + " [Ljava.lang.String;, [class [B, class [S, class [I, class [J, class [C, class [F,"
+              + " class [D, class [Ljava.lang.String;]]");
+
+  private void inspect(MethodSubject method, int dexFilledNewArray, int cfMaxLocals) {
+    if (parameters.isDexRuntime()) {
+      assertEquals(
+          dexFilledNewArray,
+          method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+
+    } else {
+      assertEquals(
+          0, method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+      assertEquals(cfMaxLocals, method.getMethod().getCode().asCfCode().getMaxLocals());
+    }
+  }
+
+  private void inspect(CodeInspector inspector) {
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
+        2
+            + (canUseFilledNewArrayOfStringObjects(parameters) ? 2 : 0)
+            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 2 : 0),
+        2);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 2, 2);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    parameters.assumeR8TestParameters();
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .enableInliningAnnotations()
+        .addDontObfuscate()
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  public static final class TestClass {
+
+    @NeverInline
+    public static void m1() {
+      Object[] array = {
+        new byte[] {(byte) 1},
+        new short[] {(short) 1},
+        new int[] {1},
+        new long[] {1L},
+        new char[] {(char) 1},
+        new float[] {1.0f},
+        new double[] {1.0d},
+        new String[] {"one"},
+        new Object[] {
+          new byte[] {(byte) 2},
+          new short[] {(short) 2},
+          new int[] {2},
+          new long[] {2L},
+          new char[] {(char) 2},
+          new float[] {2.0f},
+          new double[] {2.0d},
+          new String[] {"two"},
+        }
+      };
+      printArray(array);
+      System.out.println();
+    }
+
+    @NeverInline
+    public static void m2() {
+      try {
+        Object[] array = {
+          new byte[] {(byte) 1},
+          new short[] {(short) 1},
+          new int[] {1},
+          new long[] {1L},
+          new char[] {(char) 1},
+          new float[] {1.0f},
+          new double[] {1.0d},
+          new String[] {"one"},
+          new Object[] {
+            new byte[] {(byte) 2},
+            new short[] {(short) 2},
+            new int[] {2},
+            new long[] {2L},
+            new char[] {(char) 2},
+            new float[] {2.0f},
+            new double[] {2.0d},
+            new String[] {"two"},
+          }
+        };
+        printArray(array);
+        System.out.println();
+      } catch (Exception e) {
+        throw new RuntimeException();
+      }
+    }
+
+    @NeverInline
+    public static void printArray(Object[] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        if (array[i].getClass().isArray()) {
+          if (array[i] instanceof Object[] && !(array[i] instanceof String[])) {
+            printArray((Object[]) array[i]);
+          } else {
+            System.out.print(array[i].getClass());
+          }
+        } else {
+          System.out.print("Unexpected " + array[i].getClass());
+        }
+      }
+      System.out.print("]");
+    }
+
+    public static void main(String[] args) {
+      m1();
+      m2();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfConstClassArraysTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfConstClassArraysTest.java
new file mode 100644
index 0000000..63fec32
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfConstClassArraysTest.java
@@ -0,0 +1,179 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.rewrite.arrays;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.rewrite.arrays.ConstClassArrayWithUniqueValuesTest.TestClass;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ArrayOfConstClassArraysTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public CompilationMode compilationMode;
+
+  @Parameters(name = "{0}, mode = {1}")
+  public static Iterable<?> data() {
+    return buildParameters(
+        getTestParameters()
+            .withDefaultCfRuntime()
+            .withDexRuntimesAndAllApiLevels()
+            .withAllApiLevelsAlsoForCf()
+            .build(),
+        CompilationMode.values());
+  }
+
+  private static final String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          "[[A, B], [C, D], [E, F, G], [H, I, J]]", "[[J, I, H], [G, F, E], [D, C], [B, A]]");
+
+  private void inspect(MethodSubject method, int dexFilledNewArray, int cfMaxLocals) {
+    if (canUseFilledNewArrayOfNonStringObjects(parameters)) {
+      assertEquals(
+          dexFilledNewArray,
+          method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+
+    } else {
+      assertEquals(
+          0, method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+      if (parameters.isCfRuntime()) {
+        assertEquals(cfMaxLocals, method.getMethod().getCode().asCfCode().getMaxLocals());
+      }
+    }
+  }
+
+  private void inspect(CodeInspector inspector) {
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5, 1);
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
+        0,
+        compilationMode.isDebug() ? 1 : 2);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    parameters.assumeR8TestParameters();
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .enableInliningAnnotations()
+        .addDontObfuscate()
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  public static final class TestClass {
+
+    @NeverInline
+    public static void m1() {
+      Class<?>[][] array = {
+        new Class<?>[] {A.class, B.class},
+        new Class<?>[] {C.class, D.class},
+        new Class<?>[] {E.class, F.class, G.class},
+        new Class<?>[] {H.class, I.class, J.class}
+      };
+      printArray(array);
+    }
+
+    @NeverInline
+    public static void m2() {
+      try {
+        Class<?>[][] array = {
+          new Class<?>[] {J.class, I.class, H.class},
+          new Class<?>[] {G.class, F.class, E.class},
+          new Class<?>[] {D.class, C.class},
+          new Class<?>[] {B.class, A.class}
+        };
+        printArray(array);
+      } catch (Exception e) {
+        throw new RuntimeException();
+      }
+    }
+
+    @NeverInline
+    public static void printArray(Class<?>[][] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        printArray(array[i]);
+      }
+      System.out.println("]");
+    }
+
+    @NeverInline
+    public static void printArray(Class<?>[] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        String simpleName = array[i].getName();
+        if (simpleName.lastIndexOf("$") > 0) {
+          simpleName = simpleName.substring(simpleName.lastIndexOf("$") + 1);
+        }
+        System.out.print(simpleName);
+      }
+      System.out.print("]");
+    }
+
+    public static void main(String[] args) {
+      m1();
+      m2();
+    }
+  }
+
+  class A {}
+
+  class B {}
+
+  class C {}
+
+  class D {}
+
+  class E {}
+
+  class F {}
+
+  class G {}
+
+  class H {}
+
+  class I {}
+
+  class J {}
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfIntArraysTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfIntArraysTest.java
new file mode 100644
index 0000000..edc54de
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfIntArraysTest.java
@@ -0,0 +1,151 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.rewrite.arrays;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ArrayOfIntArraysTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public CompilationMode compilationMode;
+
+  @Parameters(name = "{0}, mode = {1}")
+  public static Iterable<?> data() {
+    return buildParameters(
+        getTestParameters()
+            .withDefaultCfRuntime()
+            .withDexRuntimesAndAllApiLevels()
+            .withAllApiLevelsAlsoForCf()
+            .build(),
+        CompilationMode.values());
+  }
+
+  private static final String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          "[[1, 2], [3, 4], [5, 6, 7], [8, 9, 10]]", "[[10, 9, 8], [7, 6, 5], [4, 3], [2, 1]]");
+
+  private void inspect(MethodSubject method, int dexFilledNewArray, int cfMaxLocals) {
+    if (parameters.isDexRuntime()) {
+      assertEquals(
+          dexFilledNewArray,
+          method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+
+    } else {
+      assertEquals(
+          0, method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+      assertEquals(cfMaxLocals, method.getMethod().getCode().asCfCode().getMaxLocals());
+    }
+  }
+
+  private void inspect(CodeInspector inspector) {
+    // This test use smaller int arrays, where filled-new-array is preferred over filled-array-data.
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
+        4 + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0),
+        1);
+    // With catch handler the int[][] creation is not converted to filled-new-array.
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
+        4,
+        compilationMode.isDebug() ? 1 : 2);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    parameters.assumeR8TestParameters();
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .enableInliningAnnotations()
+        .addDontObfuscate()
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  public static final class TestClass {
+
+    @NeverInline
+    public static void m1() {
+      int[][] array = {
+        new int[] {1, 2}, new int[] {3, 4}, new int[] {5, 6, 7}, new int[] {8, 9, 10}
+      };
+      printArray(array);
+    }
+
+    @NeverInline
+    public static void m2() {
+      try {
+        int[][] array = {
+          new int[] {10, 9, 8}, new int[] {7, 6, 5}, new int[] {4, 3}, new int[] {2, 1}
+        };
+        printArray(array);
+      } catch (Exception e) {
+        throw new RuntimeException();
+      }
+    }
+
+    @NeverInline
+    public static void printArray(int[][] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        printArray(array[i]);
+      }
+      System.out.println("]");
+    }
+
+    @NeverInline
+    public static void printArray(int[] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        System.out.print(array[i]);
+      }
+      System.out.print("]");
+    }
+
+    public static void main(String[] args) {
+      m1();
+      m2();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfStringArraysTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfStringArraysTest.java
new file mode 100644
index 0000000..1934f24
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfStringArraysTest.java
@@ -0,0 +1,235 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.rewrite.arrays;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.rewrite.arrays.ArrayOfConstClassArraysTest.TestClass;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ArrayOfStringArraysTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public CompilationMode compilationMode;
+
+  @Parameters(name = "{0}, mode = {1}")
+  public static Iterable<?> data() {
+    return buildParameters(
+        getTestParameters()
+            .withDefaultCfRuntime()
+            .withDexRuntimesAndAllApiLevels()
+            .withAllApiLevelsAlsoForCf()
+            .build(),
+        CompilationMode.values());
+  }
+
+  private static final String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          "[[A, B], [C, D], [E, F, G], [H, I, J]]",
+          "[[J, I, H], [G, F, E], [D, C], [B, A]]",
+          "[[[A, B, C]], [[D, E, F]], [[G, H]], [[I, J]]]",
+          "[[[J, I, H]], [[G, F, E]], [[D, C]], [[B, A]]]",
+          "[[J, I, H], [G, F, E], [D, C], [B, A]]");
+
+  private void inspect(MethodSubject method, int dexFilledNewArray, int cfMaxLocals) {
+    if (parameters.isDexRuntime()) {
+      assertEquals(
+          dexFilledNewArray,
+          method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+
+    } else {
+      assertEquals(
+          0, method.streamInstructions().filter(InstructionSubject::isFilledNewArray).count());
+      assertEquals(cfMaxLocals, method.getMethod().getCode().asCfCode().getMaxLocals());
+    }
+  }
+
+  private void inspect(CodeInspector inspector) {
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
+        (canUseFilledNewArrayOfStringObjects(parameters) ? 4 : 0)
+            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0),
+        1);
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
+        0,
+        compilationMode.isDebug() ? 2 : 1);
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"),
+        (canUseFilledNewArrayOfStringObjects(parameters) ? 4 : 0)
+            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 5 : 0),
+        5);
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m4"),
+        0,
+        compilationMode.isDebug() ? 2 : 1);
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m5"),
+        (canUseFilledNewArrayOfStringObjects(parameters) ? 4 : 0)
+            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0),
+        compilationMode.isDebug() ? 6 : 4);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    parameters.assumeR8TestParameters();
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters)
+        .setMode(compilationMode)
+        .enableInliningAnnotations()
+        .addDontObfuscate()
+        .run(parameters.getRuntime(), TestClass.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  public static final class TestClass {
+
+    @NeverInline
+    public static void m1() {
+      String[][] array = {
+        new String[] {"A", "B"},
+        new String[] {"C", "D"},
+        new String[] {"E", "F", "G"},
+        new String[] {"H", "I", "J"}
+      };
+      printArray(array);
+      System.out.println();
+    }
+
+    @NeverInline
+    public static void m2() {
+      try {
+        String[][] array = {
+          new String[] {"J", "I", "H"},
+          new String[] {"G", "F", "E"},
+          new String[] {"D", "C"},
+          new String[] {"B", "A"}
+        };
+        printArray(array);
+        System.out.println();
+      } catch (Exception e) {
+        throw new RuntimeException();
+      }
+    }
+
+    @NeverInline
+    public static void m3() {
+      String[][][] array = {
+        new String[][] {new String[] {"A", "B", "C"}},
+        new String[][] {new String[] {"D", "E", "F"}},
+        new String[][] {new String[] {"G", "H"}},
+        new String[][] {new String[] {"I", "J"}}
+      };
+      printArray(array);
+      System.out.println();
+    }
+
+    @NeverInline
+    public static void m4() {
+      try {
+        String[][][] array = {
+          new String[][] {new String[] {"J", "I", "H"}},
+          new String[][] {new String[] {"G", "F", "E"}},
+          new String[][] {new String[] {"D", "C"}},
+          new String[][] {new String[] {"B", "A"}}
+        };
+        printArray(array);
+        System.out.println();
+      } catch (Exception e) {
+        throw new RuntimeException();
+      }
+    }
+
+    @NeverInline
+    public static void m5() {
+      String[] a1 = new String[] {"J", "I", "H"};
+      String[] a2 = new String[] {"G", "F", "E"};
+      String[] a3 = new String[] {"D", "C"};
+      String[] a4 = new String[] {"B", "A"};
+      try {
+        String[][] array = {a1, a2, a3, a4};
+        printArray(array);
+        System.out.println();
+      } catch (Exception e) {
+        throw new RuntimeException();
+      }
+    }
+
+    @NeverInline
+    public static void printArray(String[][][] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        printArray(array[i]);
+      }
+      System.out.print("]");
+    }
+
+    @NeverInline
+    public static void printArray(String[][] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        printArray(array[i]);
+      }
+      System.out.print("]");
+    }
+
+    @NeverInline
+    public static void printArray(String[] array) {
+      System.out.print("[");
+      for (int i = 0; i < array.length; i++) {
+        if (i != 0) {
+          System.out.print(", ");
+        }
+        System.out.print(array[i]);
+      }
+      System.out.print("]");
+    }
+
+    public static void main(String[] args) {
+      m1();
+      m2();
+      m3();
+      m4();
+      m5();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayTest.java
index 180c412..4b6e64c 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayTest.java
@@ -41,11 +41,6 @@
   private static final String EXPECTED_OUTPUT =
       StringUtils.lines("[A, B, C, D, E]", "[E, D, C, B, A]");
 
-  public boolean canUseFilledNewArrayOfNonStringObjects(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
-  }
-
   private enum State {
     EXPECTING_CONSTCLASS,
     EXPECTING_APUTOBJECT
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithNonUniqueValuesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithNonUniqueValuesTest.java
index 213e3e4..3a364dd 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithNonUniqueValuesTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithNonUniqueValuesTest.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -47,15 +46,10 @@
 
   private static final String EXPECTED_OUTPUT = StringUtils.lines("100", "104");
 
-  public boolean canUseFilledNewArrayOfClass(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
-  }
-
   private void inspect(
       MethodSubject method, int constClasses, int puts, boolean insideCatchHandler) {
     boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfClass(parameters) && !insideCatchHandler;
+        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithUniqueValuesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithUniqueValuesTest.java
index d8227dc..c7f847b 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithUniqueValuesTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ConstClassArrayWithUniqueValuesTest.java
@@ -11,7 +11,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -48,11 +47,6 @@
   private static final String EXPECTED_OUTPUT =
       StringUtils.lines("[A00, A01, A02, A03, A04]", "[A00, A01, A02, A03, A04]", "100");
 
-  public boolean canUseFilledNewArrayOfClass(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
-  }
-
   private enum State {
     EXPECTING_CONSTCLASS,
     EXPECTING_APUTOBJECT
@@ -60,7 +54,7 @@
 
   private void inspect(MethodSubject method, int puts, boolean insideCatchHandler) {
     boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfClass(parameters) && !insideCatchHandler;
+        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/IntegerArrayTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/IntegerArrayTest.java
index 54abbcd..1c159da 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/IntegerArrayTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/IntegerArrayTest.java
@@ -41,10 +41,6 @@
       StringUtils.lines(
           "[-2147483648, -1, 0, 1, 2147483647]", "[-2147483647, -2, 0, 2, 2147483646]");
 
-  public boolean canUseFilledNewArrayOfInteger(TestParameters parameters) {
-    return parameters.isDexRuntime();
-  }
-
   private void inspect(MethodSubject main) {
     assertEquals(
         canUseFilledNewArrayOfInteger(parameters) ? 0 : 5,
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/SimplifyArrayConstructionTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/SimplifyArrayConstructionTest.java
index 3f75ac1..c80436c 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/SimplifyArrayConstructionTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/SimplifyArrayConstructionTest.java
@@ -212,14 +212,12 @@
       assertArrayTypes(reversedArray, DexFilledNewArray.class);
     }
 
-    // Cannot use filled-new-array of String before K.
-    if (parameters.getApiLevel().isLessThan(AndroidApiLevel.K)) {
+    if (!canUseFilledNewArrayOfStringObjects(parameters)) {
       assertArrayTypes(stringArrays, DexNewArray.class);
     } else {
       assertArrayTypes(stringArrays, DexFilledNewArray.class);
     }
-    // Cannot use filled-new-array of Object before L.
-    if (parameters.getApiLevel().isLessThan(AndroidApiLevel.N)) {
+    if (!canUseFilledNewArrayOfNonStringObjects(parameters)) {
       assertArrayTypes(referenceArraysNoCasts, DexNewArray.class);
       assertArrayTypes(referenceArraysWithSubclasses, DexNewArray.class);
       assertArrayTypes(referenceArraysWithInterfaceImplementations, DexNewArray.class);
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithNonUniqueValuesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithNonUniqueValuesTest.java
index 8623e55..be54d34 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithNonUniqueValuesTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithNonUniqueValuesTest.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -47,14 +46,9 @@
 
   private static final String EXPECTED_OUTPUT = StringUtils.lines("100", "50");
 
-  public boolean canUseFilledNewArrayOfObject(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
-  }
-
   private void inspect(MethodSubject method, int staticGets, int puts, boolean insideCatchHandler) {
     boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfObject(parameters) && !insideCatchHandler;
+        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -74,12 +68,14 @@
   private void inspectD8(CodeInspector inspector) {
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
-        canUseFilledNewArrayOfObject(parameters) ? 100 : 1,
+        canUseFilledNewArrayOfNonStringObjects(parameters) ? 100 : 1,
         100,
         false);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
-        canUseFilledNewArrayOfObject(parameters) ? 50 : (maxMaterializingConstants == 2 ? 42 : 10),
+        canUseFilledNewArrayOfNonStringObjects(parameters)
+            ? 50
+            : (maxMaterializingConstants == 2 ? 42 : 10),
         50,
         false);
   }
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithUniqueValuesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithUniqueValuesTest.java
index b5fe270..fce1e79 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithUniqueValuesTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/StaticGetArrayWithUniqueValuesTest.java
@@ -11,7 +11,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -48,11 +47,6 @@
   private static final String EXPECTED_OUTPUT =
       StringUtils.lines("[A00, A01, A02, A03, A04]", "[A00, A01, A02, A03, A04]", "100");
 
-  public boolean canUseFilledNewArrayOfObject(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
-  }
-
   private enum State {
     EXPECTING_GETSTATIC,
     EXPECTING_APUTOBJECT
@@ -60,7 +54,7 @@
 
   private void inspect(MethodSubject method, int puts, boolean insideCatchHandler) {
     boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfObject(parameters) && !insideCatchHandler;
+        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithNonUniqueValuesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithNonUniqueValuesTest.java
index 9100e39..c433e6d 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithNonUniqueValuesTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithNonUniqueValuesTest.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -47,15 +46,10 @@
 
   private static final String EXPECTED_OUTPUT = StringUtils.lines("100", "104");
 
-  public boolean canUseFilledNewArrayOfStrings(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
-  }
-
   private void inspect(
       MethodSubject method, int constStrings, int puts, boolean insideCatchHandler) {
     boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfStrings(parameters) && !insideCatchHandler;
+        canUseFilledNewArrayOfStringObjects(parameters) && !insideCatchHandler;
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithUniqueValuesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithUniqueValuesTest.java
index 2613ca5..837bea2 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithUniqueValuesTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/StringArrayWithUniqueValuesTest.java
@@ -11,7 +11,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -48,11 +47,6 @@
   private static final String EXPECTED_OUTPUT =
       StringUtils.lines("[A, B, C, D, E]", "[F, G, H, I, J]", "100");
 
-  public boolean canUseFilledNewArrayOfStrings(TestParameters parameters) {
-    return parameters.isDexRuntime()
-        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
-  }
-
   private enum State {
     EXPECTING_CONSTSTRING,
     EXPECTING_APUTOBJECT
@@ -60,7 +54,7 @@
 
   private void inspect(MethodSubject method, int puts, boolean insideCatchHandler) {
     boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfStrings(parameters) && !insideCatchHandler;
+        canUseFilledNewArrayOfStringObjects(parameters) && !insideCatchHandler;
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
diff --git a/tools/archive.py b/tools/archive.py
index a906a82..d9f8335 100755
--- a/tools/archive.py
+++ b/tools/archive.py
@@ -122,6 +122,20 @@
     print('INFO: Open files hard limit: %s' % hard)
 
 
+def RSyncDir(src_dir, version_or_path, dst_dir, is_main, options):
+    destination = GetUploadDestination(version_or_path, dst_dir, is_main)
+    print(f'RSyncing {src_dir} to {destination}')
+    if options.dry_run:
+        if options.dry_run_output:
+            dry_run_destination = os.path.join(options.dry_run_output, version_or_path, dst_dir)
+            print(f'Dry run, not actually syncing. Copying to {dry_run_destination}')
+            shutil.copytree(src_dir, dry_run_destination)
+        else:
+            print('Dry run, not actually uploading')
+    else:
+        utils.rsync_directory_to_cloud_storage(src_dir, destination)
+        print(f'Directory available at: {GetUrl(version_or_path, dst_dir, is_main)}')
+
 def UploadDir(src_dir, version_or_path, dst_dir, is_main, options):
     destination = GetUploadDestination(version_or_path, dst_dir, is_main)
     print(f'Uploading {src_dir} to {destination}')
@@ -250,7 +264,7 @@
         if is_main:
             version_or_path = 'docs'
             dst_dir = 'keepanno/javadoc'
-            UploadDir(utils.KEEPANNO_ANNOTATIONS_DOC, version_or_path, dst_dir, is_main, options)
+            RSyncDir(utils.KEEPANNO_ANNOTATIONS_DOC, version_or_path, dst_dir, is_main, options)
 
         # Upload directories.
         dirs_for_archiving = [
diff --git a/tools/utils.py b/tools/utils.py
index e859748..1df6d83 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -393,11 +393,36 @@
     PrintCmd(cmd)
     subprocess.check_call(cmd)
 
+def check_dir_args(source, destination):
+    # We require that the dirname of the paths coincide, e.g., src/dirname and dst/dirname
+    # The target is then stripped so the upload command will be: cp -R src/dirname dst/
+    (destination_parent, destination_file) = os.path.split(destination)
+    if os.path.basename(source) != destination_file:
+        raise Exception(
+            'Attempt to upload directory with non-matching directory name: ' +
+            f'{source} and {destination}')
+    if len(destination_parent.strip()) == 0:
+        raise Exception(
+            'Attempt to upload directory to empty destination directory: '
+            + destination)
+    return destination_parent
+
 def upload_directory_to_cloud_storage(source, destination, parallel=True):
+    destination_parent = check_dir_args(source, destination)
     cmd = [get_gsutil()]
     if parallel:
         cmd += ['-m']
     cmd += ['cp', '-R']
+    cmd += [source, destination_parent + '/']
+    PrintCmd(cmd)
+    subprocess.check_call(cmd)
+
+def rsync_directory_to_cloud_storage(source, destination, parallel=True):
+    check_dir_args(source, destination)
+    cmd = [get_gsutil()]
+    if parallel:
+        cmd += ['-m']
+    cmd += ['rsync', '-R']
     cmd += [source, destination]
     PrintCmd(cmd)
     subprocess.check_call(cmd)