diff --git a/doc/keepanno-guide.md b/doc/keepanno-guide.md
index c41aa8b..c924bdcf 100644
--- a/doc/keepanno-guide.md
+++ b/doc/keepanno-guide.md
@@ -23,6 +23,7 @@
 - [Annotating code using reflection](#using-reflection)
   - [Invoking methods](#using-reflection-methods)
   - [Accessing fields](#using-reflection-fields)
+  - [Accessing annotations](#using-reflection-annotations)
 - [Annotating code used by reflection (or via JNI)](#used-by-reflection)
 - [Annotating APIs](#apis)
 - [Migrating rules to annotations](#migrating-rules)
@@ -151,6 +152,79 @@
 ```
 
 
+### Accessing annotations<a name="using-reflection-annotations"></a>
+
+If your program is reflectively inspecting annotations on classes, methods or fields, you
+will need to declare additional "annotation constraints" about what assumptions are made
+about the annotations.
+
+In the following example, we have defined an annotation that will record the printing name we
+would like to use for fields instead of printing the concrete field name. That may be useful
+so that the field can be renamed to follow coding conventions for example.
+
+We are only interested in matching objects that contain fields annotated by `MyNameAnnotation`,
+that is specified using [@KeepTarget.fieldAnnotatedByClassConstant](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepTarget.html#fieldAnnotatedByClassConstant()).
+
+At runtime we need to be able to find the annotation too, so we add a constraint on the
+annotation using [@KeepTarget.constrainAnnotations](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepTarget.html#constrainAnnotations()).
+
+Finally, for the sake of example, we don't actually care about the name of the fields
+themselves, so we explicitly declare the smaller set of constraints to be
+[KeepConstraint.LOOKUP](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepConstraint.html#LOOKUP) since we must find the fields via `Class.getDeclaredFields` as well as
+[KeepConstraint.VISIBILITY_RELAX](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepConstraint.html#VISIBILITY_RELAX) and [KeepConstraint.FIELD_GET](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepConstraint.html#FIELD_GET) in order to be able to get
+the actual field value without accessibility errors.
+
+The effect is that the default constraint [KeepConstraint.NAME](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/KeepConstraint.html#NAME) is not specified which allows
+the shrinker to rename the fields at will.
+
+
+```
+public class MyAnnotationPrinter {
+
+  @Target(ElementType.FIELD)
+  @Retention(RetentionPolicy.RUNTIME)
+  public @interface MyNameAnnotation {
+    String value();
+  }
+
+  public static class MyClass {
+    @MyNameAnnotation("fieldOne")
+    public int mFieldOne = 1;
+
+    @MyNameAnnotation("fieldTwo")
+    public int mFieldTwo = 2;
+
+    public int mFieldThree = 3;
+  }
+
+  @UsesReflection(
+      @KeepTarget(
+          fieldAnnotatedByClassConstant = MyNameAnnotation.class,
+          constrainAnnotations = @AnnotationPattern(constant = MyNameAnnotation.class),
+          constraints = {
+            KeepConstraint.LOOKUP,
+            KeepConstraint.VISIBILITY_RELAX,
+            KeepConstraint.FIELD_GET
+          }))
+  public void printMyNameAnnotatedFields(Object obj) throws Exception {
+    for (Field field : obj.getClass().getDeclaredFields()) {
+      if (field.isAnnotationPresent(MyNameAnnotation.class)) {
+        System.out.println(
+            field.getAnnotation(MyNameAnnotation.class).value() + " = " + field.get(obj));
+      }
+    }
+  }
+}
+```
+
+
+If the annotations that need to be kept are not runtime
+visible annotations, then you must specify that by including the `RetentionPolicy.CLASS` value in the
+[@AnnotationPattern.retention](https://storage.googleapis.com/r8-releases/raw/main/docs/keepanno/javadoc/com/android/tools/r8/keepanno/annotations/AnnotationPattern.html#retention()) property.
+An annotation is runtime visible if its definition is explicitly annotated with
+`Retention(RetentionPolicy.RUNTIME)`.
+
+
 
 ## Annotating code used by reflection (or via JNI)<a name="used-by-reflection"></a>
 
diff --git a/doc/keepanno-guide.template.md b/doc/keepanno-guide.template.md
index 104bf02..54d910c 100644
--- a/doc/keepanno-guide.template.md
+++ b/doc/keepanno-guide.template.md
@@ -83,6 +83,19 @@
 
 [[[INCLUDE CODE:UsesReflectionFieldPrinter]]]
 
+### [Accessing annotations](using-reflection-annotations)
+
+[[[INCLUDE DOC:UsesReflectionOnAnnotations]]]
+
+[[[INCLUDE CODE:UsesReflectionOnAnnotations]]]
+
+If the annotations that need to be kept are not runtime
+visible annotations, then you must specify that by including the `RetentionPolicy.CLASS` value in the
+`@AnnotationPattern#retention` property.
+An annotation is runtime visible if its definition is explicitly annotated with
+`Retention(RetentionPolicy.RUNTIME)`.
+
+
 
 ## [Annotating code used by reflection (or via JNI)](used-by-reflection)
 
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/AnnotationPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/AnnotationPattern.java
new file mode 100644
index 0000000..cfd4302
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/AnnotationPattern.java
@@ -0,0 +1,82 @@
+// 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.
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+package com.android.tools.r8.keepanno.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A pattern structure for matching annotations.
+ *
+ * <p>If no properties are set, the default pattern matches any annotation with a runtime retention
+ * policy.
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface AnnotationPattern {
+
+  /**
+   * Define the annotation-name pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining annotation-name:
+   *
+   * <ul>
+   *   <li>constant
+   *   <li>namePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any annotation name.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String name() default "";
+
+  /**
+   * Define the annotation-name pattern by reference to a {@code Class} constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining annotation-name:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>namePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any annotation name.
+   *
+   * @return The Class constant that defines the annotation.
+   */
+  Class<?> constant() default Object.class;
+
+  /**
+   * Define the annotation-name pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining annotation-name:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>constant
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any annotation name.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern namePattern() default @ClassNamePattern(simpleName = "");
+
+  /**
+   * Specify which retention policies must be set for the annotations.
+   *
+   * <p>Matches annotations with matching retention policies
+   *
+   * @return Retention policies. By default {@code RetentionPolicy.RUNTIME}.
+   */
+  RetentionPolicy[] retention() default {RetentionPolicy.RUNTIME};
+}
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstraint.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstraint.java
index 8cfa99d..bd6f7c5 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstraint.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstraint.java
@@ -209,12 +209,4 @@
    * non-visible uses requires the same annotations to preserve as for reflective uses.
    */
   CLASS_OPEN_HIERARCHY,
-
-  /**
-   * Indicates that the annotations on the target item are being accessed reflectively.
-   *
-   * <p>If only a particular set of annotations is accessed, you should set the TBD property on the
-   * target item.
-   */
-  ANNOTATIONS,
 }
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 bf9251b..20e5492 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
@@ -110,6 +110,22 @@
   KeepConstraint[] constraintAdditions() default {};
 
   /**
+   * Patterns for annotations that must remain on the item.
+   *
+   * <p>The annotations matching any of the patterns must remain on the item if the annotation types
+   * remain in the program.
+   *
+   * <p>Note that if the annotation types themselves are unused/removed, then their references on
+   * the item will be removed too. If the annotation types themselves are used reflectively then
+   * they too need a keep annotation or rule to ensure they remain in the program.
+   *
+   * <p>By default no annotation patterns are defined and no annotations are required to remain.
+   *
+   * @return Annotation patterns
+   */
+  AnnotationPattern[] constrainAnnotations() default {};
+
+  /**
    * Define the class pattern by reference to a binding.
    *
    * <p>Mutually exclusive with the following other properties defining class:
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 6157cbd..076a93c 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
@@ -132,6 +132,22 @@
   KeepConstraint[] constraintAdditions() default {};
 
   /**
+   * Patterns for annotations that must remain on the item.
+   *
+   * <p>The annotations matching any of the patterns must remain on the item if the annotation types
+   * remain in the program.
+   *
+   * <p>Note that if the annotation types themselves are unused/removed, then their references on
+   * the item will be removed too. If the annotation types themselves are used reflectively then
+   * they too need a keep annotation or rule to ensure they remain in the program.
+   *
+   * <p>By default no annotation patterns are defined and no annotations are required to remain.
+   *
+   * @return Annotation patterns
+   */
+  AnnotationPattern[] constrainAnnotations() default {};
+
+  /**
    * Define the member-annotated-by pattern by fully qualified class name.
    *
    * <p>Mutually exclusive with the following other properties defining member-annotated-by:
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 17add2d..cf2225d 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
@@ -132,6 +132,22 @@
   KeepConstraint[] constraintAdditions() default {};
 
   /**
+   * Patterns for annotations that must remain on the item.
+   *
+   * <p>The annotations matching any of the patterns must remain on the item if the annotation types
+   * remain in the program.
+   *
+   * <p>Note that if the annotation types themselves are unused/removed, then their references on
+   * the item will be removed too. If the annotation types themselves are used reflectively then
+   * they too need a keep annotation or rule to ensure they remain in the program.
+   *
+   * <p>By default no annotation patterns are defined and no annotations are required to remain.
+   *
+   * @return Annotation patterns
+   */
+  AnnotationPattern[] constrainAnnotations() default {};
+
+  /**
    * Define the member-annotated-by pattern by fully qualified class name.
    *
    * <p>Mutually exclusive with the following other properties defining member-annotated-by:
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/AnnotationPatternParser.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/AnnotationPatternParser.java
new file mode 100644
index 0000000..f10f9cd
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/AnnotationPatternParser.java
@@ -0,0 +1,127 @@
+// 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.asm;
+
+import com.android.tools.r8.keepanno.asm.ClassNameParser.ClassNameProperty;
+import com.android.tools.r8.keepanno.ast.AnnotationConstants.AnnotationPattern;
+import com.android.tools.r8.keepanno.ast.KeepAnnotationPattern;
+import com.android.tools.r8.keepanno.ast.KeepQualifiedClassNamePattern;
+import com.android.tools.r8.keepanno.ast.ParsingContext;
+import com.android.tools.r8.keepanno.ast.ParsingContext.AnnotationParsingContext;
+import com.google.common.collect.ImmutableList;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+import java.util.function.Consumer;
+import org.objectweb.asm.AnnotationVisitor;
+
+public class AnnotationPatternParser
+    extends PropertyParserBase<KeepAnnotationPattern, AnnotationPatternParser.AnnotationProperty> {
+
+  public enum AnnotationProperty {
+    PATTERN
+  }
+
+  public AnnotationPatternParser(ParsingContext parsingContext) {
+    super(parsingContext);
+  }
+
+  @Override
+  AnnotationVisitor tryPropertyAnnotation(
+      AnnotationProperty property,
+      String name,
+      String descriptor,
+      Consumer<KeepAnnotationPattern> setValue) {
+    switch (property) {
+      case PATTERN:
+        AnnotationParsingContext parsingContext =
+            getParsingContext().property(name).annotation(descriptor);
+        AnnotationDeclarationParser parser = new AnnotationDeclarationParser(parsingContext);
+        return new ParserVisitor(
+            parsingContext,
+            parser,
+            () ->
+                setValue.accept(
+                    parser.isDeclared()
+                        ? parser.getValue()
+                        : KeepAnnotationPattern.anyWithRuntimeRetention()));
+      default:
+        return super.tryPropertyAnnotation(property, name, descriptor, setValue);
+    }
+  }
+
+  private enum RetentionProperty {
+    RETENTION
+  }
+
+  private static class RetentionParser
+      extends PropertyParserBase<RetentionPolicy, RetentionProperty> {
+
+    private static final String RETENTION_POLICY_DESC = "Ljava/lang/annotation/RetentionPolicy;";
+
+    public RetentionParser(ParsingContext parsingContext) {
+      super(parsingContext);
+    }
+
+    @Override
+    public boolean tryPropertyEnum(
+        RetentionProperty property,
+        String name,
+        String descriptor,
+        String value,
+        Consumer<RetentionPolicy> setValue) {
+      assert property == RetentionProperty.RETENTION;
+      if (RETENTION_POLICY_DESC.equals(descriptor)) {
+        setValue.accept(RetentionPolicy.valueOf(value));
+        return true;
+      }
+      return super.tryPropertyEnum(property, name, descriptor, value, setValue);
+    }
+  }
+
+  private static class AnnotationDeclarationParser
+      extends DeclarationParser<KeepAnnotationPattern> {
+
+    private final ClassNameParser nameParser;
+    private final ArrayPropertyParser<RetentionPolicy, RetentionProperty> retentionParser;
+    private final List<Parser<?>> parsers;
+
+    public AnnotationDeclarationParser(ParsingContext parsingContext) {
+      nameParser = new ClassNameParser(parsingContext);
+      nameParser.setProperty(AnnotationPattern.name, ClassNameProperty.NAME);
+      nameParser.setProperty(AnnotationPattern.constant, ClassNameProperty.CONSTANT);
+      nameParser.setProperty(AnnotationPattern.namePattern, ClassNameProperty.PATTERN);
+      retentionParser = new ArrayPropertyParser<>(parsingContext, RetentionParser::new);
+      retentionParser.setProperty(AnnotationPattern.retention, RetentionProperty.RETENTION);
+      retentionParser.setValueCheck(
+          (value, propertyContext) -> {
+            if (value.isEmpty()) {
+              throw propertyContext.error("Expected non-empty array of retention policies");
+            }
+          });
+      parsers = ImmutableList.of(nameParser, retentionParser);
+    }
+
+    @Override
+    List<Parser<?>> parsers() {
+      return parsers;
+    }
+
+    public KeepAnnotationPattern getValue() {
+      if (isDefault()) {
+        return null;
+      }
+      KeepAnnotationPattern.Builder builder = KeepAnnotationPattern.builder();
+      if (retentionParser.isDeclared()) {
+        List<RetentionPolicy> policies = retentionParser.getValue();
+        policies.forEach(builder::addRetentionPolicy);
+      } else {
+        builder.addRetentionPolicy(RetentionPolicy.RUNTIME);
+      }
+      return builder
+          .setNamePattern(nameParser.getValueOrDefault(KeepQualifiedClassNamePattern.any()))
+          .build();
+    }
+  }
+}
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ArrayPropertyParser.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ArrayPropertyParser.java
index 3c6cd08..3ae1bd2 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ArrayPropertyParser.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ArrayPropertyParser.java
@@ -26,6 +26,7 @@
   AnnotationVisitor tryPropertyArray(P property, String name, Consumer<List<T>> setValue) {
     // The property name and type is forwarded to the element parser.
     values = new ArrayList<>();
+    // The context is explicitly *not* extended with the property name here as it is forwarded.
     ParsingContext parsingContext = getParsingContext();
     return new AnnotationVisitorBase(parsingContext) {
 
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ClassNameParser.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ClassNameParser.java
index 9137b3e..6bc17aa 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ClassNameParser.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ClassNameParser.java
@@ -89,7 +89,6 @@
           nameParser.setProperty(ClassNamePattern.simpleName, ClassSimpleNameProperty.NAME);
           return new ParserVisitor(
               parsingContext,
-              descriptor,
               ImmutableList.of(packageParser, nameParser),
               () ->
                   setValue.accept(
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ConstraintsParser.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ConstraintPropertiesParser.java
similarity index 81%
rename from src/keepanno/java/com/android/tools/r8/keepanno/asm/ConstraintsParser.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/asm/ConstraintPropertiesParser.java
index e89279b..c652e91 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ConstraintsParser.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ConstraintPropertiesParser.java
@@ -4,21 +4,22 @@
 
 package com.android.tools.r8.keepanno.asm;
 
-import com.android.tools.r8.keepanno.asm.ConstraintsParser.ConstraintsProperty;
+import com.android.tools.r8.keepanno.asm.ConstraintPropertiesParser.ConstraintsProperty;
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.Target;
 import com.android.tools.r8.keepanno.ast.KeepConstraints;
 import com.android.tools.r8.keepanno.ast.ParsingContext;
 import java.util.function.Consumer;
 import org.objectweb.asm.AnnotationVisitor;
 
-public class ConstraintsParser extends PropertyParserBase<KeepConstraints, ConstraintsProperty> {
+public class ConstraintPropertiesParser
+    extends PropertyParserBase<KeepConstraints, ConstraintsProperty> {
 
   public enum ConstraintsProperty {
     CONSTRAINTS,
     ADDITIONS
   }
 
-  public ConstraintsParser(ParsingContext parsingContext) {
+  public ConstraintPropertiesParser(ParsingContext parsingContext) {
     super(parsingContext.group(Target.constraintsGroup));
   }
 
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepConstraintsVisitor.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepConstraintsVisitor.java
index b0b58f8..33bf5be 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepConstraintsVisitor.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepConstraintsVisitor.java
@@ -67,9 +67,6 @@
       case Constraints.CLASS_OPEN_HIERARCHY:
         builder.add(KeepConstraint.classOpenHierarchy());
         break;
-      case Constraints.ANNOTATIONS:
-        builder.add(KeepConstraint.annotationsAll());
-        break;
       default:
         super.visitEnum(ignore, descriptor, value);
     }
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 8c85b9a..1c6c71e 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
@@ -4,7 +4,7 @@
 package com.android.tools.r8.keepanno.asm;
 
 import com.android.tools.r8.keepanno.asm.ClassNameParser.ClassNameProperty;
-import com.android.tools.r8.keepanno.asm.ConstraintsParser.ConstraintsProperty;
+import com.android.tools.r8.keepanno.asm.ConstraintPropertiesParser.ConstraintsProperty;
 import com.android.tools.r8.keepanno.asm.InstanceOfParser.InstanceOfProperties;
 import com.android.tools.r8.keepanno.asm.StringPatternParser.StringProperty;
 import com.android.tools.r8.keepanno.asm.TypeParser.TypeProperty;
@@ -21,6 +21,7 @@
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.MethodAccess;
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.Target;
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.UsedByReflection;
+import com.android.tools.r8.keepanno.ast.KeepAnnotationPattern;
 import com.android.tools.r8.keepanno.ast.KeepBindingReference;
 import com.android.tools.r8.keepanno.ast.KeepBindings;
 import com.android.tools.r8.keepanno.ast.KeepBindings.KeepBindingSymbol;
@@ -30,6 +31,7 @@
 import com.android.tools.r8.keepanno.ast.KeepClassItemReference;
 import com.android.tools.r8.keepanno.ast.KeepCondition;
 import com.android.tools.r8.keepanno.ast.KeepConsequences;
+import com.android.tools.r8.keepanno.ast.KeepConstraint;
 import com.android.tools.r8.keepanno.ast.KeepConstraints;
 import com.android.tools.r8.keepanno.ast.KeepDeclaration;
 import com.android.tools.r8.keepanno.ast.KeepEdge;
@@ -61,6 +63,7 @@
 import com.android.tools.r8.keepanno.ast.ParsingContext.ClassParsingContext;
 import com.android.tools.r8.keepanno.ast.ParsingContext.FieldParsingContext;
 import com.android.tools.r8.keepanno.ast.ParsingContext.MethodParsingContext;
+import com.android.tools.r8.keepanno.ast.ParsingContext.PropertyParsingContext;
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -521,16 +524,17 @@
 
     @Override
     public AnnotationVisitor visitArray(String name) {
+      PropertyParsingContext propertyParsingContext = parsingContext.property(name);
       if (name.equals(Edge.bindings)) {
-        return new KeepBindingsVisitor(parsingContext, bindingsHelper);
+        return new KeepBindingsVisitor(propertyParsingContext, bindingsHelper);
       }
       if (name.equals(Edge.preconditions)) {
         return new KeepPreconditionsVisitor(
-            parsingContext, builder::setPreconditions, bindingsHelper);
+            propertyParsingContext, builder::setPreconditions, bindingsHelper);
       }
       if (name.equals(Edge.consequences)) {
         return new KeepConsequencesVisitor(
-            parsingContext, builder::setConsequences, bindingsHelper);
+            propertyParsingContext, builder::setConsequences, bindingsHelper);
       }
       return super.visitArray(name);
     }
@@ -593,7 +597,7 @@
     public AnnotationVisitor visitArray(String name) {
       if (name.equals(ForApi.additionalTargets)) {
         return new KeepConsequencesVisitor(
-            parsingContext,
+            parsingContext.property(name),
             additionalConsequences -> {
               additionalConsequences.forEachTarget(consequences::addTarget);
             },
@@ -695,7 +699,7 @@
     public AnnotationVisitor visitArray(String name) {
       if (name.equals(ForApi.additionalTargets)) {
         return new KeepConsequencesVisitor(
-            parsingContext,
+            parsingContext.property(name),
             additionalConsequences -> {
               additionalConsequences.forEachTarget(consequences::addTarget);
             },
@@ -715,6 +719,64 @@
     }
   }
 
+  public static class ConstraintDeclarationParser extends DeclarationParser<KeepConstraints> {
+    private final ConstraintPropertiesParser constraintsParser;
+    private final ArrayPropertyParser<
+            KeepAnnotationPattern, AnnotationPatternParser.AnnotationProperty>
+        annotationsParser;
+
+    public ConstraintDeclarationParser(ParsingContext parsingContext) {
+      constraintsParser = new ConstraintPropertiesParser(parsingContext);
+      constraintsParser.setProperty(Target.constraints, ConstraintsProperty.CONSTRAINTS);
+      constraintsParser.setProperty(Target.constraintAdditions, ConstraintsProperty.ADDITIONS);
+
+      annotationsParser = new ArrayPropertyParser<>(parsingContext, AnnotationPatternParser::new);
+      annotationsParser.setProperty(
+          Target.constrainAnnotations, AnnotationPatternParser.AnnotationProperty.PATTERN);
+      annotationsParser.setValueCheck(this::verifyAnnotationList);
+    }
+
+    private void verifyAnnotationList(
+        List<KeepAnnotationPattern> annotationList, ParsingContext parsingContext) {
+      if (annotationList.isEmpty()) {
+        throw parsingContext.error("Expected non-empty array of annotation patterns");
+      }
+    }
+
+    @Override
+    List<Parser<?>> parsers() {
+      return ImmutableList.of(constraintsParser, annotationsParser);
+    }
+
+    public KeepConstraints getValueOrDefault(KeepConstraints defaultValue) {
+      return isDeclared() ? getValue() : defaultValue;
+    }
+
+    public KeepConstraints getValue() {
+      if (isDefault()) {
+        return null;
+      }
+      // If only the constraints are set then those are the constraints as is.
+      if (annotationsParser.isDefault()) {
+        assert constraintsParser.isDeclared();
+        return constraintsParser.getValue();
+      }
+      KeepConstraints.Builder builder;
+      if (constraintsParser.isDeclared()) {
+        // If constraints are set use it as the initial set.
+        builder = KeepConstraints.builder().copyFrom(constraintsParser.getValue());
+        assert builder.verifyNoAnnotations();
+      } else {
+        // If only the annotations are set, add them as an extension of the defaults.
+        builder = KeepConstraints.builder().copyFrom(KeepConstraints.defaultConstraints());
+      }
+      annotationsParser
+          .getValue()
+          .forEach(pattern -> builder.add(KeepConstraint.annotation(pattern)));
+      return builder.build();
+    }
+  }
+
   /**
    * Parsing of @UsedByReflection or @UsedByNative on a class context.
    *
@@ -731,7 +793,7 @@
     private final KeepConsequences.Builder consequences = KeepConsequences.builder();
     private final KeepEdgeMetaInfo.Builder metaInfoBuilder = KeepEdgeMetaInfo.builder();
     private final UserBindingsHelper bindingsHelper = new UserBindingsHelper();
-    private final ConstraintsParser constraintsParser;
+    private final ConstraintDeclarationParser constraintsParser;
 
     UsedByReflectionClassVisitor(
         AnnotationParsingContext parsingContext,
@@ -743,11 +805,9 @@
       this.className = className;
       this.parent = parent;
       addContext.accept(metaInfoBuilder);
+      constraintsParser = new ConstraintDeclarationParser(parsingContext);
       // The class context/holder is the annotated class.
       visit(Item.className, className);
-      constraintsParser = new ConstraintsParser(parsingContext);
-      constraintsParser.setProperty(Target.constraints, ConstraintsProperty.CONSTRAINTS);
-      constraintsParser.setProperty(Target.constraintAdditions, ConstraintsProperty.ADDITIONS);
     }
 
     @Override
@@ -766,13 +826,14 @@
 
     @Override
     public AnnotationVisitor visitArray(String name) {
+      PropertyParsingContext propertyParsingContext = parsingContext.property(name);
       if (name.equals(Edge.preconditions)) {
         return new KeepPreconditionsVisitor(
-            parsingContext, builder::setPreconditions, bindingsHelper);
+            propertyParsingContext, builder::setPreconditions, bindingsHelper);
       }
       if (name.equals(UsedByReflection.additionalTargets)) {
         return new KeepConsequencesVisitor(
-            parsingContext,
+            propertyParsingContext,
             additionalConsequences -> {
               additionalConsequences.forEachTarget(consequences::addTarget);
             },
@@ -842,7 +903,7 @@
     private final UserBindingsHelper bindingsHelper = new UserBindingsHelper();
     private final KeepConsequences.Builder consequences = KeepConsequences.builder();
     private ItemKind kind = KeepEdgeReader.ItemKind.ONLY_MEMBERS;
-    private final ConstraintsParser constraintsParser;
+    private final ConstraintDeclarationParser constraintsParser;
 
     UsedByReflectionMemberVisitor(
         AnnotationParsingContext parsingContext,
@@ -854,9 +915,7 @@
       this.parent = parent;
       this.context = context;
       addContext.accept(metaInfoBuilder);
-      constraintsParser = new ConstraintsParser(parsingContext);
-      constraintsParser.setProperty(Target.constraints, ConstraintsProperty.CONSTRAINTS);
-      constraintsParser.setProperty(Target.constraintAdditions, ConstraintsProperty.ADDITIONS);
+      constraintsParser = new ConstraintDeclarationParser(parsingContext);
     }
 
     @Override
@@ -883,13 +942,14 @@
 
     @Override
     public AnnotationVisitor visitArray(String name) {
+      PropertyParsingContext propertyParsingContext = parsingContext.property(name);
       if (name.equals(Edge.preconditions)) {
         return new KeepPreconditionsVisitor(
-            parsingContext, builder::setPreconditions, bindingsHelper);
+            propertyParsingContext, builder::setPreconditions, bindingsHelper);
       }
       if (name.equals(UsedByReflection.additionalTargets)) {
         return new KeepConsequencesVisitor(
-            parsingContext,
+            propertyParsingContext,
             additionalConsequences -> {
               additionalConsequences.forEachTarget(consequences::addTarget);
             },
@@ -973,13 +1033,14 @@
 
     @Override
     public AnnotationVisitor visitArray(String name) {
+      PropertyParsingContext propertyParsingContext = parsingContext.property(name);
       if (name.equals(AnnotationConstants.UsesReflection.value)) {
         return new KeepConsequencesVisitor(
-            parsingContext, builder::setConsequences, bindingsHelper);
+            propertyParsingContext, builder::setConsequences, bindingsHelper);
       }
       if (name.equals(AnnotationConstants.UsesReflection.additionalPreconditions)) {
         return new KeepPreconditionsVisitor(
-            parsingContext,
+            propertyParsingContext,
             additionalPreconditions -> {
               additionalPreconditions.forEach(preconditions::addCondition);
             },
@@ -1003,7 +1064,7 @@
     private final ParsingContext parsingContext;
     private final UserBindingsHelper helper;
 
-    public KeepBindingsVisitor(ParsingContext parsingContext, UserBindingsHelper helper) {
+    public KeepBindingsVisitor(PropertyParsingContext parsingContext, UserBindingsHelper helper) {
       super(parsingContext);
       this.parsingContext = parsingContext;
       this.helper = helper;
@@ -1011,6 +1072,7 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+      assert name == null;
       if (descriptor.equals(AnnotationConstants.Binding.DESCRIPTOR)) {
         return new KeepBindingVisitor(parsingContext.annotation(descriptor), helper);
       }
@@ -1025,7 +1087,7 @@
     private final UserBindingsHelper bindingsHelper;
 
     public KeepPreconditionsVisitor(
-        ParsingContext parsingContext,
+        PropertyParsingContext parsingContext,
         Parent<KeepPreconditions> parent,
         UserBindingsHelper bindingsHelper) {
       super(parsingContext);
@@ -1036,6 +1098,7 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+      assert name == null;
       if (descriptor.equals(Condition.DESCRIPTOR)) {
         return new KeepConditionVisitor(
             parsingContext.annotation(descriptor), builder::addCondition, bindingsHelper);
@@ -1056,7 +1119,7 @@
     private final UserBindingsHelper bindingsHelper;
 
     public KeepConsequencesVisitor(
-        ParsingContext parsingContext,
+        PropertyParsingContext parsingContext,
         Parent<KeepConsequences> parent,
         UserBindingsHelper bindingsHelper) {
       super(parsingContext);
@@ -1067,6 +1130,7 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+      assert name == null;
       if (descriptor.equals(Target.DESCRIPTOR)) {
         return KeepTargetVisitor.create(
             parsingContext.annotation(descriptor), builder::addTarget, bindingsHelper);
@@ -1786,7 +1850,7 @@
 
     private final Parent<KeepTarget> parent;
     private final UserBindingsHelper bindingsHelper;
-    private final ConstraintsParser optionsParser;
+    private final ConstraintDeclarationParser constraintsParser;
     private final KeepTarget.Builder builder = KeepTarget.builder();
 
     static KeepTargetVisitor create(
@@ -1803,9 +1867,7 @@
       super(parsingContext);
       this.parent = parent;
       this.bindingsHelper = bindingsHelper;
-      optionsParser = new ConstraintsParser(parsingContext);
-      optionsParser.setProperty(Target.constraints, ConstraintsProperty.CONSTRAINTS);
-      optionsParser.setProperty(Target.constraintAdditions, ConstraintsProperty.ADDITIONS);
+      constraintsParser = new ConstraintDeclarationParser(parsingContext);
     }
 
     @Override
@@ -1815,7 +1877,7 @@
 
     @Override
     public AnnotationVisitor visitArray(String name) {
-      AnnotationVisitor visitor = optionsParser.tryParseArray(name, unused -> {});
+      AnnotationVisitor visitor = constraintsParser.tryParseArray(name, unused -> {});
       if (visitor != null) {
         return visitor;
       }
@@ -1825,7 +1887,8 @@
     @Override
     public void visitEnd() {
       super.visitEnd();
-      builder.setConstraints(optionsParser.getValueOrDefault(KeepConstraints.defaultConstraints()));
+      builder.setConstraints(
+          constraintsParser.getValueOrDefault(KeepConstraints.defaultConstraints()));
       for (KeepItemReference item : getItemsWithBinding()) {
         parent.accept(builder.setItemReference(item).build());
       }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ParserVisitor.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ParserVisitor.java
index 5f1f69b..5acb59f 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/ParserVisitor.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/ParserVisitor.java
@@ -12,33 +12,26 @@
 /** Convert parser(s) into an annotation visitor. */
 public class ParserVisitor extends AnnotationVisitorBase {
 
-  private final List<PropertyParser<?, ?>> parsers;
+  private final List<Parser<?>> parsers;
   private final Runnable onVisitEnd;
 
   public ParserVisitor(
-      AnnotationParsingContext parsingContext,
-      String annotationDescriptor,
-      List<PropertyParser<?, ?>> parsers,
-      Runnable onVisitEnd) {
+      AnnotationParsingContext parsingContext, List<Parser<?>> parsers, Runnable onVisitEnd) {
     super(parsingContext);
     this.parsers = parsers;
     this.onVisitEnd = onVisitEnd;
-    assert annotationDescriptor.equals(parsingContext.getAnnotationDescriptor());
   }
 
   public ParserVisitor(
-      AnnotationParsingContext parsingContext,
-      String annotationDescriptor,
-      PropertyParser<?, ?> declaration,
-      Runnable onVisitEnd) {
-    this(parsingContext, annotationDescriptor, Collections.singletonList(declaration), onVisitEnd);
+      AnnotationParsingContext parsingContext, Parser<?> parser, Runnable onVisitEnd) {
+    this(parsingContext, Collections.singletonList(parser), onVisitEnd);
   }
 
   private <T> void ignore(T unused) {}
 
   @Override
   public void visit(String name, Object value) {
-    for (PropertyParser<?, ?> parser : parsers) {
+    for (Parser<?> parser : parsers) {
       if (parser.tryParse(name, value, this::ignore)) {
         return;
       }
@@ -48,7 +41,7 @@
 
   @Override
   public AnnotationVisitor visitArray(String name) {
-    for (PropertyParser<?, ?> parser : parsers) {
+    for (Parser<?> parser : parsers) {
       AnnotationVisitor visitor = parser.tryParseArray(name, this::ignore);
       if (visitor != null) {
         return visitor;
@@ -59,7 +52,7 @@
 
   @Override
   public void visitEnum(String name, String descriptor, String value) {
-    for (PropertyParser<?, ?> parser : parsers) {
+    for (Parser<?> parser : parsers) {
       if (parser.tryParseEnum(name, descriptor, value, this::ignore)) {
         return;
       }
@@ -69,7 +62,7 @@
 
   @Override
   public AnnotationVisitor visitAnnotation(String name, String descriptor) {
-    for (PropertyParser<?, ?> parser : parsers) {
+    for (Parser<?> parser : parsers) {
       AnnotationVisitor visitor = parser.tryParseAnnotation(name, descriptor, this::ignore);
       if (visitor != null) {
         return visitor;
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/PropertyParserBase.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/PropertyParserBase.java
index 0213ef3..f5b40c3 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/PropertyParserBase.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/PropertyParserBase.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.keepanno.ast.ParsingContext;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import org.objectweb.asm.AnnotationVisitor;
 
@@ -18,6 +19,7 @@
   private final Map<String, P> mapping = new HashMap<>();
   private String resultPropertyName = null;
   private T resultValue = null;
+  private BiConsumer<T, ParsingContext> check = null;
 
   protected PropertyParserBase(ParsingContext parsingContext) {
     this.parsingContext = parsingContext;
@@ -52,6 +54,9 @@
   private Consumer<T> wrap(String propertyName, Consumer<T> setValue) {
     return value -> {
       assert value != null;
+      if (check != null) {
+        check.accept(value, parsingContext.property(propertyName));
+      }
       if (resultPropertyName != null) {
         assert resultValue != null;
         error(propertyName);
@@ -144,4 +149,8 @@
     }
     return null;
   }
+
+  public void setValueCheck(BiConsumer<T, ParsingContext> check) {
+    this.check = check;
+  }
 }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/StringPatternParser.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/StringPatternParser.java
index f866a90..2bb95df 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/StringPatternParser.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/StringPatternParser.java
@@ -57,7 +57,6 @@
           suffixParser.setProperty(StringPattern.endsWith, StringParser.Property.STRING);
           return new ParserVisitor(
               parsingContext,
-              descriptor,
               ImmutableList.of(exactParser, prefixParser, suffixParser),
               () -> {
                 if (exactParser.isDeclared()) {
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/TypeParser.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/TypeParser.java
index a40f450..a0c0afc 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/TypeParser.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/TypeParser.java
@@ -58,7 +58,6 @@
           typeParser.setProperty(TypePattern.classNamePattern, TypeProperty.CLASS_NAME_PATTERN);
           return new ParserVisitor(
               context,
-              descriptor,
               typeParser,
               () -> setValue.accept(typeParser.getValueOrDefault(KeepTypePattern.any())));
         }
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 9828d43..239dd0e 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
@@ -139,6 +139,7 @@
     public static final String constraintsGroup = "constraints";
     public static final String constraints = "constraints";
     public static final String constraintAdditions = "constraintAdditions";
+    public static final String constrainAnnotations = "constrainAnnotations";
   }
 
   public static final class Kind {
@@ -169,7 +170,6 @@
     public static final String FIELD_REPLACE = "FIELD_REPLACE";
     public static final String NEVER_INLINE = "NEVER_INLINE";
     public static final String CLASS_OPEN_HIERARCHY = "CLASS_OPEN_HIERARCHY";
-    public static final String ANNOTATIONS = "ANNOTATIONS";
   }
 
   public static final class Option {
@@ -236,4 +236,14 @@
     public static final String simpleName = "simpleName";
     public static final String packageName = "packageName";
   }
+
+  public static final class AnnotationPattern {
+    public static final String DESCRIPTOR =
+        "Lcom/android/tools/r8/keepanno/annotations/AnnotationPattern;";
+    public static final String annotationNameGroup = "annotation-name";
+    public static final String name = "name";
+    public static final String constant = "constant";
+    public static final String namePattern = "namePattern";
+    public static final String retention = "retention";
+  }
 }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepAnnotationPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepAnnotationPattern.java
new file mode 100644
index 0000000..5c7cf96
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepAnnotationPattern.java
@@ -0,0 +1,138 @@
+// 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.ast;
+
+import java.lang.annotation.RetentionPolicy;
+import java.util.Objects;
+
+public class KeepAnnotationPattern {
+
+  private static final int RUNTIME_RETENTION_MASK = 0x1;
+  private static final int CLASS_RETENTION_MASK = 0x2;
+  private static final int ANY_RETENTION_MASK = 0x3;
+
+  private static final KeepAnnotationPattern ANY_WITH_ANY_RETENTION =
+      new KeepAnnotationPattern(KeepQualifiedClassNamePattern.any(), ANY_RETENTION_MASK);
+
+  private static final KeepAnnotationPattern ANY_WITH_RUNTIME_RETENTION =
+      new KeepAnnotationPattern(KeepQualifiedClassNamePattern.any(), RUNTIME_RETENTION_MASK);
+
+  private static final KeepAnnotationPattern ANY_WITH_CLASS_RETENTION =
+      new KeepAnnotationPattern(KeepQualifiedClassNamePattern.any(), CLASS_RETENTION_MASK);
+
+  public static KeepAnnotationPattern any() {
+    return KeepAnnotationPattern.ANY_WITH_ANY_RETENTION;
+  }
+
+  public static KeepAnnotationPattern anyWithRuntimeRetention() {
+    return KeepAnnotationPattern.ANY_WITH_RUNTIME_RETENTION;
+  }
+
+  public static KeepAnnotationPattern anyWithClassRetention() {
+    return KeepAnnotationPattern.ANY_WITH_CLASS_RETENTION;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static class Builder {
+
+    private KeepQualifiedClassNamePattern namePattern = KeepQualifiedClassNamePattern.any();
+    private int retentionPolicies = 0x0;
+
+    private Builder() {}
+
+    public Builder setNamePattern(KeepQualifiedClassNamePattern namePattern) {
+      this.namePattern = namePattern;
+      return this;
+    }
+
+    public Builder addRetentionPolicy(RetentionPolicy policy) {
+      switch (policy) {
+        case RUNTIME:
+          retentionPolicies |= RUNTIME_RETENTION_MASK;
+          break;
+        case CLASS:
+          retentionPolicies |= CLASS_RETENTION_MASK;
+          break;
+        case SOURCE:
+          throw new KeepEdgeException("Retention policy SOURCE cannot be used in patterns");
+        default:
+          throw new KeepEdgeException("Invalid policy: " + policy);
+      }
+      return this;
+    }
+
+    public KeepAnnotationPattern build() {
+      if (retentionPolicies == 0x0) {
+        throw new KeepEdgeException("Invalid empty retention policy");
+      }
+      if (namePattern.isAny()) {
+        switch (retentionPolicies) {
+          case RUNTIME_RETENTION_MASK:
+            return ANY_WITH_RUNTIME_RETENTION;
+          case CLASS_RETENTION_MASK:
+            return ANY_WITH_CLASS_RETENTION;
+          case ANY_RETENTION_MASK:
+            return ANY_WITH_ANY_RETENTION;
+          default:
+            throw new KeepEdgeException("Invalid retention policy value: " + retentionPolicies);
+        }
+      }
+      return new KeepAnnotationPattern(namePattern, retentionPolicies);
+    }
+  }
+
+  private final KeepQualifiedClassNamePattern namePattern;
+  private final int retentionPolicies;
+
+  private KeepAnnotationPattern(KeepQualifiedClassNamePattern namePattern, int retentionPolicies) {
+    assert namePattern != null;
+    this.namePattern = namePattern;
+    this.retentionPolicies = retentionPolicies;
+  }
+
+  public boolean isAny() {
+    return this == ANY_WITH_ANY_RETENTION;
+  }
+
+  public boolean isAnyWithRuntimeRetention() {
+    return this == ANY_WITH_RUNTIME_RETENTION;
+  }
+
+  public boolean isAnyWithClassRetention() {
+    return this == ANY_WITH_CLASS_RETENTION;
+  }
+
+  public KeepQualifiedClassNamePattern getNamePattern() {
+    return namePattern;
+  }
+
+  public boolean includesRuntimeRetention() {
+    return (retentionPolicies & RUNTIME_RETENTION_MASK) > 0;
+  }
+
+  public boolean includesClassRetention() {
+    return (retentionPolicies & CLASS_RETENTION_MASK) > 0;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof KeepAnnotationPattern)) {
+      return false;
+    }
+    KeepAnnotationPattern that = (KeepAnnotationPattern) o;
+    return retentionPolicies == that.retentionPolicies && namePattern.equals(that.namePattern);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(namePattern, retentionPolicies);
+  }
+}
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraint.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraint.java
index 0f81deb..454f725 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraint.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraint.java
@@ -286,23 +286,42 @@
     return Annotation.ALL_INSTANCE;
   }
 
-  public static Annotation annotation(KeepQualifiedClassNamePattern pattern) {
+  public static Annotation annotationsAllWithRuntimeRetention() {
+    return Annotation.ALL_WITH_RUNTIME_RETENTION_INSTANCE;
+  }
+
+  public static Annotation annotationsAllWithClassRetention() {
+    return Annotation.ALL_WITH_CLASS_RETENTION_INSTANCE;
+  }
+
+  public static Annotation annotation(KeepAnnotationPattern pattern) {
     if (pattern.isAny()) {
       return annotationsAll();
     }
+    if (pattern.isAnyWithRuntimeRetention()) {
+      return annotationsAllWithRuntimeRetention();
+    }
+    if (pattern.isAnyWithClassRetention()) {
+      return annotationsAllWithClassRetention();
+    }
     return new Annotation(pattern);
   }
 
   public static final class Annotation extends KeepConstraint {
 
-    private static final Annotation ALL_INSTANCE =
-        new Annotation(KeepQualifiedClassNamePattern.any());
+    private static final Annotation ALL_INSTANCE = new Annotation(KeepAnnotationPattern.any());
 
-    private final KeepQualifiedClassNamePattern classNamePattern;
+    private static final Annotation ALL_WITH_RUNTIME_RETENTION_INSTANCE =
+        new Annotation(KeepAnnotationPattern.anyWithRuntimeRetention());
 
-    private Annotation(KeepQualifiedClassNamePattern classNamePattern) {
-      assert classNamePattern != null;
-      this.classNamePattern = classNamePattern;
+    private static final Annotation ALL_WITH_CLASS_RETENTION_INSTANCE =
+        new Annotation(KeepAnnotationPattern.anyWithClassRetention());
+
+    private final KeepAnnotationPattern annotationPattern;
+
+    private Annotation(KeepAnnotationPattern annotationPattern) {
+      assert annotationPattern != null;
+      this.annotationPattern = annotationPattern;
     }
 
     @Override
@@ -315,12 +334,16 @@
 
     @Override
     public void addRequiredKeepAttributes(Set<KeepAttribute> attributes) {
-      attributes.add(KeepAttribute.RUNTIME_VISIBLE_ANNOTATIONS);
-      attributes.add(KeepAttribute.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS);
-      attributes.add(KeepAttribute.RUNTIME_VISIBLE_TYPE_ANNOTATIONS);
-      attributes.add(KeepAttribute.RUNTIME_INVISIBLE_ANNOTATIONS);
-      attributes.add(KeepAttribute.RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS);
-      attributes.add(KeepAttribute.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS);
+      if (annotationPattern.includesRuntimeRetention()) {
+        attributes.add(KeepAttribute.RUNTIME_VISIBLE_ANNOTATIONS);
+        attributes.add(KeepAttribute.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS);
+        attributes.add(KeepAttribute.RUNTIME_VISIBLE_TYPE_ANNOTATIONS);
+      }
+      if (annotationPattern.includesClassRetention()) {
+        attributes.add(KeepAttribute.RUNTIME_INVISIBLE_ANNOTATIONS);
+        attributes.add(KeepAttribute.RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS);
+        attributes.add(KeepAttribute.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS);
+      }
     }
 
     @Override
@@ -332,12 +355,12 @@
         return false;
       }
       Annotation that = (Annotation) o;
-      return classNamePattern.equals(that.classNamePattern);
+      return annotationPattern.equals(that.annotationPattern);
     }
 
     @Override
     public int hashCode() {
-      return classNamePattern.hashCode();
+      return annotationPattern.hashCode();
     }
   }
 }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraints.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraints.java
index c319a3c..eb5cc2e 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraints.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConstraints.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.keepanno.ast;
 
+import com.android.tools.r8.keepanno.ast.KeepConstraint.Annotation;
 import com.android.tools.r8.keepanno.ast.KeepOptions.KeepOption;
 import com.google.common.collect.ImmutableSet;
 import java.util.Collections;
@@ -19,7 +20,12 @@
   }
 
   public static KeepConstraints defaultAdditions(KeepConstraints additionalConstraints) {
-    return new Additions(additionalConstraints);
+    if (additionalConstraints instanceof Constraints) {
+      return new Additions((Constraints) additionalConstraints);
+    }
+    // If no explicit constraints are set, this is just identity on the defaults/additions.
+    assert additionalConstraints instanceof Defaults || additionalConstraints instanceof Additions;
+    return additionalConstraints;
   }
 
   public static Builder builder() {
@@ -28,17 +34,39 @@
 
   public static class Builder {
 
+    private boolean defaultAdditions = false;
     private final Set<KeepConstraint> constraints = new HashSet<>();
 
     private Builder() {}
 
+    public Builder copyFrom(KeepConstraints fromConstraints) {
+      if (fromConstraints instanceof Defaults) {
+        // This builder is based on defaults so set the builder as an addition.
+        defaultAdditions = true;
+      } else if (fromConstraints instanceof Additions) {
+        // This builder is an addition, populate the additions into the constraint set.
+        defaultAdditions = true;
+        constraints.addAll(((Additions) fromConstraints).additions.constraints);
+      } else {
+        assert fromConstraints instanceof Constraints;
+        constraints.addAll(((Constraints) fromConstraints).constraints);
+      }
+      return this;
+    }
+
+    public boolean verifyNoAnnotations() {
+      assert constraints.stream().noneMatch(constraint -> constraint instanceof Annotation);
+      return true;
+    }
+
     public Builder add(KeepConstraint constraint) {
       constraints.add(constraint);
       return this;
     }
 
     public KeepConstraints build() {
-      return new Constraints(constraints);
+      Constraints constraintCollection = new Constraints(constraints);
+      return defaultAdditions ? new Additions(constraintCollection) : constraintCollection;
     }
   }
 
@@ -65,9 +93,9 @@
 
   private static class Additions extends KeepConstraints {
 
-    private final KeepConstraints additions;
+    private final Constraints additions;
 
-    public Additions(KeepConstraints additions) {
+    public Additions(Constraints additions) {
       this.additions = additions;
     }
 
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
index b894eae..05ee81c 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
@@ -122,6 +122,12 @@
  *
  *   MEMBER_ACCESS_FLAG
  *     ::= public | protected | package-private | private | static | final | synthetic
+ *
+ *   ANNOTATION_PATTERN
+ *     ::= @QUALIFIED_CLASS_NAME_PATTERN retention(RETENTION_POLICY+)
+ *
+ *   RETENTION_POLICY
+ *     ::= RUNTIME | CLASS
  * </pre>
  */
 public final class KeepEdge extends KeepDeclaration {
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java
index 0d83a25..5f6bb55 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java
@@ -55,6 +55,7 @@
   }
 
   public PropertyParsingContext property(String propertyName) {
+    assert propertyName != null;
     return new PropertyParsingContext(this, propertyName);
   }
 
@@ -273,5 +274,11 @@
     public String getContextFrameAsString() {
       return getPropertyName();
     }
+
+    @Override
+    public boolean isSynthetic() {
+      // The value property is the default and usually unnamed property, so we avoid printing it.
+      return "value".equals(propertyName);
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 33b687b..766371d 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -455,11 +455,11 @@
         reporter.error(
             "Option --main-dex-list-output requires --main-dex-rules and/or --main-dex-list");
       }
-      if (getMinApiLevel() >= AndroidApiLevel.L.getLevel()) {
+      if (getMinApiLevel() >= AndroidApiLevel.L_MR1.getLevel()) {
         if (getMainDexListConsumer() != null || getAppBuilder().hasMainDexList()) {
           reporter.error(
               "D8 does not support main-dex inputs and outputs when compiling to API level "
-                  + AndroidApiLevel.L.getLevel()
+                  + AndroidApiLevel.L_MR1.getLevel()
                   + " and above");
         }
       }
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 4507e1e..24f0c28 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -37,6 +37,7 @@
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.conversion.IRConverter;
+import com.android.tools.r8.ir.conversion.LirConverter;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions.MutableMethodConversionOptions;
 import com.android.tools.r8.ir.conversion.PrimaryR8IRConverter;
@@ -54,6 +55,7 @@
 import com.android.tools.r8.ir.optimize.SwitchMapCollector;
 import com.android.tools.r8.ir.optimize.enums.EnumUnboxingCfMethods;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
+import com.android.tools.r8.ir.optimize.info.OptimizationInfoRemover;
 import com.android.tools.r8.ir.optimize.templates.CfUtilityMethodsForCodeOptimizations;
 import com.android.tools.r8.jar.CfApplicationWriter;
 import com.android.tools.r8.keepanno.annotations.KeepForApi;
@@ -508,7 +510,7 @@
               initialRuntimeTypeCheckInfoBuilder.build(appView.graphLens()));
 
       // TODO(b/225838009): Horizontal merging currently assumes pre-phase CF conversion.
-      appView.testing().enterLirSupportedPhase(appView, executorService);
+      LirConverter.enterLirSupportedPhase(appView, executorService);
 
       new ProtoNormalizer(appViewWithLiveness).run(executorService, timing);
 
@@ -532,6 +534,7 @@
 
       new PrimaryR8IRConverter(appViewWithLiveness, timing)
           .optimize(appViewWithLiveness, executorService);
+      assert LirConverter.verifyLirOnly(appView);
 
       assert ArtProfileCompletenessChecker.verify(
           appView, ALLOW_MISSING_ENUM_UNBOXING_UTILITY_METHODS);
@@ -715,14 +718,16 @@
         SyntheticFinalization.finalizeWithClassHierarchy(appView, executorService, timing);
       }
 
-      // TODO(b/225838009): Move further down.
-      PrimaryR8IRConverter.finalizeLirToOutputFormat(appView, timing, executorService);
-
       // Read any -applymapping input to allow for repackaging to not relocate the classes.
       timing.begin("read -applymapping file");
       appView.loadApplyMappingSeedMapper();
       timing.end();
 
+      // Remove optimization info before remaining optimizations, since these optimization currently
+      // do not rewrite the optimization info, which is OK since the optimization info should
+      // already have been leveraged.
+      OptimizationInfoRemover.run(appView, executorService);
+
       // Perform repackaging.
       if (appView.hasLiveness()) {
         if (options.isRepackagingEnabled()) {
@@ -731,18 +736,21 @@
         assert Repackaging.verifyIdentityRepackaging(appView.withLiveness(), executorService);
       }
 
-      // Clear the reference type lattice element cache. This is required since class merging may
-      // need to build IR.
-      appView.dexItemFactory().clearTypeElementsCache();
-
-      GenericSignatureContextBuilder genericContextBuilderBeforeFinalMerging =
-          GenericSignatureContextBuilder.create(appView);
+      // Rewrite LIR with lens to allow building IR from LIR in class mergers.
+      LirConverter.rewriteLirWithLens(appView, timing, executorService);
 
       if (appView.hasLiveness()) {
         VerticalClassMerger.createForFinalClassMerging(appView.withLiveness())
             .runIfNecessary(executorService, timing);
       }
 
+      // TODO(b/225838009): Move further down.
+      LirConverter.finalizeLirToOutputFormat(appView, timing, executorService);
+      assert appView.dexItemFactory().verifyNoCachedTypeElements();
+
+      GenericSignatureContextBuilder genericContextBuilderBeforeFinalMerging =
+          GenericSignatureContextBuilder.create(appView);
+
       // Run horizontal class merging. This runs even if shrinking is disabled to ensure synthetics
       // are always merged.
       HorizontalClassMerger.createForFinalClassMerging(appView)
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index 47f7ed6..e3d2f78 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -229,7 +229,9 @@
     if (!options.isGeneratingDex()) {
       return true;
     }
-    AndroidApiLevel nativeMultiDex = AndroidApiLevel.L;
+    // Native multidex is supported from L, but the compiler supports compiling to L/21 using
+    // legacy multidex as there are some devices that have issues with it still.
+    AndroidApiLevel nativeMultiDex = AndroidApiLevel.L_MR1;
     if (options.getMinApiLevel().isLessThan(nativeMultiDex)) {
       return true;
     }
diff --git a/src/main/java/com/android/tools/r8/graph/AbstractAccessContexts.java b/src/main/java/com/android/tools/r8/graph/AbstractAccessContexts.java
index a30eb47..b8e779d 100644
--- a/src/main/java/com/android/tools/r8/graph/AbstractAccessContexts.java
+++ b/src/main/java/com/android/tools/r8/graph/AbstractAccessContexts.java
@@ -86,6 +86,8 @@
   abstract AbstractAccessContexts rewrittenWithLens(
       DexDefinitionSupplier definitions, GraphLens lens);
 
+  abstract AbstractAccessContexts withoutPrunedItems(PrunedItems prunedItems);
+
   public static EmptyAccessContexts empty() {
     return EmptyAccessContexts.getInstance();
   }
@@ -155,6 +157,11 @@
     public AbstractAccessContexts join(AbstractAccessContexts contexts) {
       return contexts;
     }
+
+    @Override
+    AbstractAccessContexts withoutPrunedItems(PrunedItems prunedItems) {
+      return this;
+    }
   }
 
   public static class ConcreteAccessContexts extends AbstractAccessContexts {
@@ -378,6 +385,14 @@
       contexts.asConcrete().accessesWithContexts.forEach(addAllMethods);
       return new ConcreteAccessContexts(newAccessesWithContexts);
     }
+
+    @Override
+    AbstractAccessContexts withoutPrunedItems(PrunedItems prunedItems) {
+      for (ProgramMethodSet methodSet : accessesWithContexts.values()) {
+        methodSet.removeIf(method -> prunedItems.isRemoved(method.getReference()));
+      }
+      return this;
+    }
   }
 
   public static class UnknownAccessContexts extends AbstractAccessContexts {
@@ -440,5 +455,10 @@
     public AbstractAccessContexts join(AbstractAccessContexts contexts) {
       return this;
     }
+
+    @Override
+    AbstractAccessContexts withoutPrunedItems(PrunedItems prunedItems) {
+      return this;
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index 691680c..c09b0fd 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -101,6 +101,7 @@
   private final WholeProgramOptimizations wholeProgramOptimizations;
   private GraphLens codeLens = GraphLens.getIdentityLens();
   private GraphLens graphLens = GraphLens.getIdentityLens();
+  private GraphLens genericSignaturesLens = GraphLens.getIdentityLens();
   private InitClassLens initClassLens;
   private GraphLens kotlinMetadataLens = GraphLens.getIdentityLens();
   private NamingLens namingLens = NamingLens.getIdentityLens();
@@ -678,6 +679,14 @@
     return false;
   }
 
+  public GraphLens getGenericSignaturesLens() {
+    return genericSignaturesLens;
+  }
+
+  public void setGenericSignaturesLens(GraphLens genericSignaturesLens) {
+    this.genericSignaturesLens = genericSignaturesLens;
+  }
+
   private boolean disallowFurtherInitClassUses = false;
 
   public void dissallowFurtherInitClassUses() {
@@ -871,7 +880,6 @@
       testing().verticallyMergedClassesConsumer.accept(dexItemFactory(), verticallyMergedClasses);
     } else {
       assert this.verticallyMergedClasses != null;
-      assert verticallyMergedClasses.isEmpty();
     }
   }
 
@@ -1088,7 +1096,10 @@
                 public void run(Timing timing) {
                   if (appView.hasLiveness()) {
                     result =
-                        appView.appInfoWithLiveness().rewrittenWithLens(application, lens, timing);
+                        appView
+                            .appInfoWithLiveness()
+                            .rewrittenWithLens(
+                                application, lens, appliedLensInModifiedLens, timing);
                   } else {
                     assert appView.hasClassHierarchy();
                     AppView<AppInfoWithClassHierarchy> appViewWithClassHierarchy =
@@ -1246,6 +1257,23 @@
                 public boolean shouldRun() {
                   return !appView.getStartupProfile().isEmpty();
                 }
+              },
+              new ThreadTask() {
+                @Override
+                public void run(Timing timing) {
+                  ImmutableSet.Builder<DexMethod> cfByteCodePassThroughBuilder =
+                      ImmutableSet.builder();
+                  for (DexMethod method : appView.cfByteCodePassThrough) {
+                    cfByteCodePassThroughBuilder.add(
+                        lens.getRenamedMethodSignature(method, appliedLensInModifiedLens));
+                  }
+                  appView.cfByteCodePassThrough = cfByteCodePassThroughBuilder.build();
+                }
+
+                @Override
+                public boolean shouldRun() {
+                  return !appView.cfByteCodePassThrough.isEmpty();
+                }
               });
         });
 
diff --git a/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java b/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java
index 665a472..f43f02e 100644
--- a/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java
+++ b/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java
@@ -19,17 +19,24 @@
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.graph.lens.MethodLookupResult;
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
+import com.android.tools.r8.ir.analysis.type.Nullability;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Position.SyntheticPosition;
+import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.conversion.IRBuilder;
 import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions.MutableMethodConversionOptions;
 import com.android.tools.r8.ir.conversion.SyntheticStraightLineSourceCode;
+import com.android.tools.r8.lightir.LirCode;
+import com.android.tools.r8.lightir.LirEncodingStrategy;
+import com.android.tools.r8.lightir.LirStrategy;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.IteratorUtils;
@@ -85,7 +92,12 @@
       AppView<?> appView, ProgramMethod method, DexType superType) {
     DexEncodedMethod definition = method.getDefinition();
     assert definition.getCode().isDefaultInstanceInitializerCode();
-    method.setCode(get().toCfCode(method, appView.dexItemFactory(), superType), appView);
+    if (appView.testing().isSupportedLirPhase()) {
+      method.setCode(get().toLirCode(appView, method), appView);
+    } else {
+      assert appView.testing().isPreLirPhase();
+      method.setCode(get().toCfCode(method, appView.dexItemFactory(), superType), appView);
+    }
   }
 
   @Override
@@ -370,6 +382,27 @@
     return new CfCode(method.getHolderType(), getMaxStack(), getMaxLocals(method), instructions);
   }
 
+  public LirCode<?> toLirCode(AppView<?> appView, ProgramMethod method) {
+    TypeElement receiverType =
+        method.getHolder().getType().toTypeElement(appView, Nullability.definitelyNotNull());
+    Value receiver = new Value(0, receiverType, null);
+    DexMethod invokedMethod =
+        appView.dexItemFactory().createInstanceInitializer(method.getHolder().getSuperType());
+    LirEncodingStrategy<Value, Integer> strategy =
+        LirStrategy.getDefaultStrategy().getEncodingStrategy();
+    strategy.defineValue(receiver, 0);
+    return LirCode.builder(
+            method.getReference(),
+            method.getDefinition().isD8R8Synthesized(),
+            strategy,
+            appView.options())
+        .setMetadata(IRMetadata.unknown())
+        .addArgument(0, false)
+        .addInvokeDirect(invokedMethod, ImmutableList.of(receiver), false)
+        .addReturnVoid()
+        .build();
+  }
+
   @Override
   public void writeCf(
       ProgramMethod method,
diff --git a/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java b/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
index 557bb44..af6a62f 100644
--- a/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
+++ b/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
@@ -48,6 +48,10 @@
   // Mapping from register to local for currently open/visible locals.
   private Int2ReferenceMap<DebugLocalInfo> pendingLocals = null;
 
+  // The method's preamble position. This is used in release mode to preserve the preamble position
+  // for methods without throwing instructions that have been moved (i.e., have a caller position).
+  private Position preamblePosition;
+
   // Conservative pending-state of locals to avoid some equality checks on locals.
   // pendingLocalChanges == true ==> localsEqual(emittedLocals, pendingLocals).
   private boolean pendingLocalChanges = false;
@@ -81,6 +85,9 @@
     // Initialize locals state on block entry.
     if (isBlockEntry) {
       updateBlockEntry(instruction);
+      if (preamblePosition == null) {
+        preamblePosition = instruction.getPosition();
+      }
     }
     assert pendingLocals != null;
 
@@ -116,8 +123,17 @@
   public DexDebugInfo build() {
     assert pendingLocals == null;
     assert !pendingLocalChanges;
+    assert preamblePosition != null;
     if (startLine == NO_LINE_INFO) {
-      return null;
+      if (!preamblePosition.hasCallerPosition()) {
+        return null;
+      }
+      return new EventBasedDebugInfo(
+          preamblePosition.getLine(),
+          new DexString[method.getReference().getArity()],
+          new DexDebugEvent[] {
+            factory.createPositionFrame(preamblePosition), factory.zeroChangeDefaultEvent
+          });
     }
     DexString[] params = new DexString[method.getReference().getArity()];
     if (arguments != null) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 7465b0a..3c3533a 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -10,6 +10,7 @@
 import static com.android.tools.r8.graph.DexEncodedMethod.CompilationState.PROCESSED_INLINING_CANDIDATE_SUBCLASS;
 import static com.android.tools.r8.graph.DexEncodedMethod.CompilationState.PROCESSED_NOT_INLINING_CANDIDATE;
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
 import static com.android.tools.r8.kotlin.KotlinMetadataUtils.getNoKotlinInfo;
 import static com.android.tools.r8.utils.ConsumerUtils.emptyConsumer;
 import static java.util.Objects.requireNonNull;
@@ -30,18 +31,15 @@
 import com.android.tools.r8.cf.code.CfStore;
 import com.android.tools.r8.cf.code.CfThrow;
 import com.android.tools.r8.dex.MixedSectionCollection;
-import com.android.tools.r8.dex.code.DexConstString;
-import com.android.tools.r8.dex.code.DexInstruction;
-import com.android.tools.r8.dex.code.DexInvokeDirect;
-import com.android.tools.r8.dex.code.DexInvokeStatic;
-import com.android.tools.r8.dex.code.DexNewInstance;
-import com.android.tools.r8.dex.code.DexThrow;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DexAnnotation.AnnotatedKind;
 import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.graph.proto.ArgumentInfoCollection;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.NumericType;
+import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.NestUtils;
@@ -52,6 +50,10 @@
 import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
 import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
 import com.android.tools.r8.kotlin.KotlinMethodLevelInfo;
+import com.android.tools.r8.lightir.LirBuilder;
+import com.android.tools.r8.lightir.LirCode;
+import com.android.tools.r8.lightir.LirEncodingStrategy;
+import com.android.tools.r8.lightir.LirStrategy;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.NamingLens;
@@ -911,28 +913,6 @@
     return getReference().toSourceString();
   }
 
-  /** Generates a {@link DexCode} object for the given instructions. */
-  private DexCode generateCodeFromTemplate(
-      int numberOfRegisters, int outRegisters, DexInstruction... instructions) {
-    int offset = 0;
-    for (DexInstruction instruction : instructions) {
-      instruction.setOffset(offset);
-      offset += instruction.getSize();
-    }
-    int requiredArgRegisters = accessFlags.isStatic() ? 0 : 1;
-    for (DexType type : getReference().proto.parameters.values) {
-      requiredArgRegisters += ValueType.fromDexType(type).requiredRegisters();
-    }
-    return new DexCode(
-        Math.max(numberOfRegisters, requiredArgRegisters),
-        requiredArgRegisters,
-        outRegisters,
-        instructions,
-        new DexCode.Try[0],
-        new DexCode.TryHandler[0],
-        null);
-  }
-
   public CfCode buildInstanceOfCfCode(DexType type, boolean negate) {
     CfInstruction[] instructions = new CfInstruction[3 + BooleanUtils.intValue(negate) * 2];
     int i = 0;
@@ -950,13 +930,15 @@
         Arrays.asList(instructions));
   }
 
-  public DexEncodedMethod toMethodThatLogsError(AppView<?> appView) {
+  public DexEncodedMethod toMethodThatLogsError(
+      AppView<? extends AppInfoWithClassHierarchy> appView) {
+    assert appView.testing().isPreLirPhase() || appView.testing().isSupportedLirPhase();
     Builder builder =
         builder(this)
             .setCode(
-                appView.options().isGeneratingClassFiles()
+                appView.testing().isPreLirPhase()
                     ? toCfCodeThatLogsError(appView.dexItemFactory())
-                    : toDexCodeThatLogsError(appView.dexItemFactory()))
+                    : toLirCodeThatLogsError(appView))
             .setIsLibraryMethodOverrideIf(
                 belongsToVirtualPool() && !isLibraryMethodOverride().isUnknown(),
                 isLibraryMethodOverride())
@@ -979,50 +961,86 @@
     }
   }
 
-  public static void setDebugInfoWithExtraParameters(
-      Code code, int arity, int extraParameters, AppView<?> appView) {
-    if (code.isDexCode()) {
-      DexCode dexCode = code.asDexCode();
-      DexDebugInfo newDebugInfo =
-          dexCode.debugInfoWithExtraParameters(appView.dexItemFactory(), extraParameters);
-      assert (newDebugInfo == null) || (arity == newDebugInfo.getParameterCount());
-      dexCode.setDebugInfo(newDebugInfo);
-    } else {
-      assert code.isCfCode();
-      // We don't have anything to do for Cf.
-    }
-  }
-
-  private DexCode toDexCodeThatLogsError(DexItemFactory itemFactory) {
+  private LirCode<?> toLirCodeThatLogsError(AppView<? extends AppInfoWithClassHierarchy> appView) {
     checkIfObsolete();
+    DexItemFactory factory = appView.dexItemFactory();
     Signature signature = MethodSignature.fromDexMethod(getReference());
     DexString message =
-        itemFactory.createString(
+        factory.createString(
             CONFIGURATION_DEBUGGING_PREFIX
                 + getReference().holder.toSourceString()
                 + ": "
                 + signature);
-    DexString tag = itemFactory.createString("[R8]");
-    DexType[] args = {itemFactory.stringType, itemFactory.stringType};
-    DexProto proto = itemFactory.createProto(itemFactory.intType, args);
-    DexMethod logMethod =
-        itemFactory.createMethod(
-            itemFactory.androidUtilLogType, proto, itemFactory.createString("e"));
-    DexType exceptionType = itemFactory.runtimeExceptionType;
+    DexString tag = factory.createString("[R8]");
+    DexType logger = factory.javaUtilLoggingLoggerType;
+    DexMethod getLogger =
+        factory.createMethod(
+            logger,
+            factory.createProto(logger, factory.stringType),
+            factory.createString("getLogger"));
+    DexMethod severe =
+        factory.createMethod(
+            logger,
+            factory.createProto(factory.voidType, factory.stringType),
+            factory.createString("severe"));
+    DexType exceptionType = factory.runtimeExceptionType;
     DexMethod exceptionInitMethod =
-        itemFactory.createMethod(
+        factory.createMethod(
             exceptionType,
-            itemFactory.createProto(itemFactory.voidType, itemFactory.stringType),
-            itemFactory.constructorMethodName);
-    return generateCodeFromTemplate(
-        2,
-        2,
-        new DexConstString(0, tag),
-        new DexConstString(1, message),
-        new DexInvokeStatic(2, logMethod, 0, 1, 0, 0, 0),
-        new DexNewInstance(0, exceptionType),
-        new DexInvokeDirect(2, exceptionInitMethod, 0, 1, 0, 0, 0),
-        new DexThrow(0));
+            factory.createProto(factory.voidType, factory.stringType),
+            factory.constructorMethodName);
+
+    TypeElement stringValueType = TypeElement.stringClassType(appView, definitelyNotNull());
+    TypeElement loggerValueType = logger.toTypeElement(appView);
+    TypeElement exceptionValueType = exceptionType.toTypeElement(appView, definitelyNotNull());
+
+    LirEncodingStrategy<Value, Integer> strategy =
+        LirStrategy.getDefaultStrategy().getEncodingStrategy();
+    LirBuilder<Value, Integer> lirBuilder =
+        LirCode.builder(getReference(), isD8R8Synthesized(), strategy, appView.options())
+            .setMetadata(IRMetadata.unknown());
+    int instructionIndex = 0;
+    for (; instructionIndex < getNumberOfArguments(); instructionIndex++) {
+      DexType argumentType = getArgumentType(instructionIndex);
+      lirBuilder.addArgument(instructionIndex, argumentType.isBooleanType());
+    }
+
+    // Load tag.
+    Value tagValue = new Value(instructionIndex, stringValueType, null);
+    strategy.defineValue(tagValue, tagValue.getNumber());
+    lirBuilder.addConstString(tag);
+    instructionIndex++;
+
+    // Get logger.
+    Value loggerValue = new Value(instructionIndex, loggerValueType, null);
+    strategy.defineValue(loggerValue, loggerValue.getNumber());
+    lirBuilder.addInvokeStatic(getLogger, ImmutableList.of(tagValue), false);
+    instructionIndex++;
+
+    // Load message.
+    Value messageValue = new Value(instructionIndex, stringValueType, null);
+    strategy.defineValue(messageValue, messageValue.getNumber());
+    lirBuilder.addConstString(message);
+    instructionIndex++;
+
+    // Call logger.
+    lirBuilder.addInvokeVirtual(severe, ImmutableList.of(loggerValue, messageValue));
+    instructionIndex++;
+
+    // Instantiate exception.
+    Value exceptionValue = new Value(instructionIndex, exceptionValueType, null);
+    strategy.defineValue(exceptionValue, exceptionValue.getNumber());
+    lirBuilder
+        .addNewInstance(exceptionType)
+        .addInvokeDirect(
+            exceptionInitMethod, ImmutableList.of(exceptionValue, messageValue), false);
+    instructionIndex += 2;
+
+    // Throw exception.
+    lirBuilder.addThrow(exceptionValue);
+    instructionIndex++;
+
+    return lirBuilder.build();
   }
 
   private CfCode toCfCodeThatLogsError(DexItemFactory itemFactory) {
@@ -1292,6 +1310,11 @@
     optimizationInfo = info;
   }
 
+  public void unsetOptimizationInfo() {
+    checkIfObsolete();
+    optimizationInfo = DefaultMethodOptimizationInfo.getInstance();
+  }
+
   public void copyMetadata(AppView<?> appView, DexEncodedMethod from) {
     checkIfObsolete();
     if (from.hasClassFileVersion()) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java b/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java
index ac780e9..3250adb 100644
--- a/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java
+++ b/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java
@@ -60,4 +60,31 @@
     // Always just return the object type since this is safe for all api versions.
     return factory.objectType;
   }
+
+  public static boolean isTypeAccessibleInMethodContext(
+      AppView<?> appView, DexType type, ProgramMethod context) {
+    if (type.isPrimitiveType()) {
+      return true;
+    }
+    if (type.isIdenticalTo(context.getHolderType())
+        || (context.getHolder().hasSuperType()
+            && type.isIdenticalTo(context.getHolder().getSuperType()))
+        || context.getHolder().getInterfaces().contains(type)) {
+      // In principle we don't know if the supertypes are guaranteed to be accessible in the current
+      // context. However, if they aren't, the current class will never be successfully loaded
+      // anyway.
+      return true;
+    }
+    DexClass clazz = appView.definitionFor(type, context);
+    if (clazz == null) {
+      return false;
+    }
+    if (clazz.isLibraryClass()) {
+      return AndroidApiLevelUtils.isApiSafeForReference(clazz.asLibraryClass(), appView);
+    }
+    if (appView.hasClassHierarchy()) {
+      return AccessControl.isClassAccessible(clazz, context, appView.withClassHierarchy()).isTrue();
+    }
+    return false;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
index 6b2bad4..29cd5a4 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
@@ -9,7 +9,9 @@
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.Timing;
 import java.util.IdentityHashMap;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.function.BiPredicate;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -102,4 +104,17 @@
     assert infos.values().size() == SetUtils.newIdentityHashSet(infos.values()).size();
     return true;
   }
+
+  public FieldAccessInfoCollectionImpl withoutPrunedItems(PrunedItems prunedItems) {
+    Iterator<Entry<DexField, FieldAccessInfoImpl>> iterator = infos.entrySet().iterator();
+    while (iterator.hasNext()) {
+      Entry<DexField, FieldAccessInfoImpl> entry = iterator.next();
+      if (prunedItems.isRemoved(entry.getKey())) {
+        iterator.remove();
+      } else {
+        entry.setValue(entry.getValue().withoutPrunedItems(prunedItems));
+      }
+    }
+    return this;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
index 0dae257..39aa866 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
@@ -406,4 +406,10 @@
     merged.writesWithContexts = writesWithContexts.join(impl.writesWithContexts);
     return merged;
   }
+
+  public FieldAccessInfoImpl withoutPrunedItems(PrunedItems prunedItems) {
+    readsWithContexts = readsWithContexts.withoutPrunedItems(prunedItems);
+    writesWithContexts = writesWithContexts.withoutPrunedItems(prunedItems);
+    return this;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/GenericSignatureTypeRewriter.java b/src/main/java/com/android/tools/r8/graph/GenericSignatureTypeRewriter.java
index d519324..916a8e2 100644
--- a/src/main/java/com/android/tools/r8/graph/GenericSignatureTypeRewriter.java
+++ b/src/main/java/com/android/tools/r8/graph/GenericSignatureTypeRewriter.java
@@ -38,7 +38,7 @@
         appView.appInfo().hasLiveness()
             ? appView.appInfo().withLiveness()::wasPruned
             : alwaysFalse(),
-        appView.graphLens()::lookupType,
+        type -> appView.graphLens().lookupType(type, appView.getGenericSignaturesLens()),
         context,
         hasGenericTypeVariables);
   }
diff --git a/src/main/java/com/android/tools/r8/graph/MethodAccessInfoCollection.java b/src/main/java/com/android/tools/r8/graph/MethodAccessInfoCollection.java
index 3b8681b..b541bfc 100644
--- a/src/main/java/com/android/tools/r8/graph/MethodAccessInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/MethodAccessInfoCollection.java
@@ -17,7 +17,9 @@
 import com.android.tools.r8.utils.collections.ThrowingMap;
 import com.google.common.collect.Sets;
 import java.util.IdentityHashMap;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiConsumer;
@@ -178,18 +180,18 @@
     }
   }
 
-  public MethodAccessInfoCollection withoutPrunedItems(PrunedItems prunedItems) {
+  public MethodAccessInfoCollection withoutPrunedContexts(PrunedItems prunedItems) {
     if (!fullyDestroyed) {
-      pruneItems(prunedItems, directInvokes);
-      pruneItems(prunedItems, interfaceInvokes);
-      pruneItems(prunedItems, staticInvokes);
-      pruneItems(prunedItems, superInvokes);
-      pruneItems(prunedItems, virtualInvokes);
+      pruneContexts(prunedItems, directInvokes);
+      pruneContexts(prunedItems, interfaceInvokes);
+      pruneContexts(prunedItems, staticInvokes);
+      pruneContexts(prunedItems, superInvokes);
+      pruneContexts(prunedItems, virtualInvokes);
     }
     return this;
   }
 
-  private static void pruneItems(
+  private static void pruneContexts(
       PrunedItems prunedItems, Map<DexMethod, ProgramMethodSet> invokes) {
     if (isThrowingMap(invokes)) {
       return;
@@ -212,6 +214,45 @@
             });
   }
 
+  public MethodAccessInfoCollection withoutPrunedItems(PrunedItems prunedItems) {
+    if (!fullyDestroyed) {
+      pruneItems(prunedItems, directInvokes);
+      pruneItems(prunedItems, interfaceInvokes);
+      pruneItems(prunedItems, staticInvokes);
+      pruneItems(prunedItems, superInvokes);
+      pruneItems(prunedItems, virtualInvokes);
+    }
+    return this;
+  }
+
+  private static void pruneItems(
+      PrunedItems prunedItems, Map<DexMethod, ProgramMethodSet> invokes) {
+    if (isThrowingMap(invokes)) {
+      return;
+    }
+    Iterator<Entry<DexMethod, ProgramMethodSet>> iterator = invokes.entrySet().iterator();
+    while (iterator.hasNext()) {
+      Entry<DexMethod, ProgramMethodSet> entry = iterator.next();
+      if (prunedItems.isRemoved(entry.getKey())) {
+        iterator.remove();
+      } else {
+        ProgramMethodSet contexts = entry.getValue();
+        contexts.removeIf(
+            context -> {
+              if (prunedItems.isRemoved(context.getReference())) {
+                return true;
+              }
+              assert prunedItems.getPrunedApp().definitionFor(context.getReference()) != null
+                  : "Expected method to be present: " + context.getReference().toSourceString();
+              return false;
+            });
+        if (contexts.isEmpty()) {
+          iterator.remove();
+        }
+      }
+    }
+  }
+
   public boolean verify(AppView<AppInfoWithLiveness> appView) {
     assert verifyNoNonResolving(appView);
     return true;
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollection.java b/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollection.java
index 70d1666..b55811b 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollection.java
@@ -43,5 +43,5 @@
       AppInfo appInfo);
 
   ObjectAllocationInfoCollection rewrittenWithLens(
-      DexDefinitionSupplier definitions, GraphLens lens, Timing timing);
+      DexDefinitionSupplier definitions, GraphLens lens, GraphLens appliedLens, Timing timing);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java b/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java
index 6050c9d..2ffe096 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java
@@ -8,6 +8,7 @@
 import static com.android.tools.r8.utils.MapUtils.ignoreKey;
 
 import com.android.tools.r8.graph.lens.GraphLens;
+import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
 import com.android.tools.r8.ir.desugar.LambdaDescriptor;
 import com.android.tools.r8.shaking.GraphReporter;
 import com.android.tools.r8.shaking.InstantiationReason;
@@ -144,14 +145,17 @@
 
   @Override
   public ObjectAllocationInfoCollectionImpl rewrittenWithLens(
-      DexDefinitionSupplier definitions, GraphLens lens, Timing timing) {
+      DexDefinitionSupplier definitions, GraphLens lens, GraphLens appliedLens, Timing timing) {
     return timing.time(
-        "Rewrite ObjectAllocationInfoCollectionImpl", () -> rewrittenWithLens(definitions, lens));
+        "Rewrite ObjectAllocationInfoCollectionImpl",
+        () -> rewrittenWithLens(definitions, lens, appliedLens));
   }
 
   private ObjectAllocationInfoCollectionImpl rewrittenWithLens(
-      DexDefinitionSupplier definitions, GraphLens lens) {
-    return builder(true, null).rewrittenWithLens(this, definitions, lens).build(definitions);
+      DexDefinitionSupplier definitions, GraphLens lens, GraphLens appliedLens) {
+    return builder(true, null)
+        .rewrittenWithLens(this, definitions, lens, appliedLens)
+        .build(definitions);
   }
 
   public ObjectAllocationInfoCollectionImpl withoutPrunedItems(PrunedItems prunedItems) {
@@ -474,11 +478,12 @@
     Builder rewrittenWithLens(
         ObjectAllocationInfoCollectionImpl objectAllocationInfos,
         DexDefinitionSupplier definitions,
-        GraphLens lens) {
+        GraphLens lens,
+        GraphLens appliedLens) {
       instantiatedHierarchy = null;
       objectAllocationInfos.classesWithoutAllocationSiteTracking.forEach(
           clazz -> {
-            DexType type = lens.lookupType(clazz.type);
+            DexType type = lens.lookupType(clazz.type, appliedLens);
             if (type.isPrimitiveType()) {
               return;
             }
@@ -488,7 +493,7 @@
           });
       objectAllocationInfos.classesWithAllocationSiteTracking.forEach(
           (clazz, allocationSitesForClass) -> {
-            DexType type = lens.lookupType(clazz.type);
+            DexType type = lens.lookupType(clazz.type, appliedLens);
             if (type.isPrimitiveType()) {
               return;
             }
@@ -507,7 +512,7 @@
           });
       for (DexProgramClass abstractType :
           objectAllocationInfos.interfacesWithUnknownSubtypeHierarchy) {
-        DexType type = lens.lookupType(abstractType.type);
+        DexType type = lens.lookupType(abstractType.type, appliedLens);
         if (type.isPrimitiveType()) {
           assert false;
           continue;
@@ -517,15 +522,19 @@
         assert !interfacesWithUnknownSubtypeHierarchy.contains(rewrittenClass);
         interfacesWithUnknownSubtypeHierarchy.add(rewrittenClass);
       }
+      LensCodeRewriterUtils rewriter = new LensCodeRewriterUtils(definitions, lens, appliedLens);
       objectAllocationInfos.instantiatedLambdas.forEach(
           (iface, lambdas) -> {
-            DexType type = lens.lookupType(iface);
+            DexType type = lens.lookupType(iface, appliedLens);
             if (type.isPrimitiveType()) {
               assert false;
               return;
             }
-            // TODO(b/150277553): Rewrite lambda descriptor.
-            instantiatedLambdas.computeIfAbsent(type, ignoreKey(ArrayList::new)).addAll(lambdas);
+            List<LambdaDescriptor> newLambdas =
+                instantiatedLambdas.computeIfAbsent(type, ignoreKey(ArrayList::new));
+            for (LambdaDescriptor lambda : lambdas) {
+              newLambdas.add(lambda.rewrittenWithLens(lens, appliedLens, rewriter));
+            }
           });
       return this;
     }
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramMethod.java b/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
index 9b4fa96..a86dbc8 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
@@ -204,18 +204,16 @@
     return appView.options().debug || getOrComputeReachabilitySensitive(appView);
   }
 
-  @SuppressWarnings("ReferenceEquality")
   public ProgramMethod rewrittenWithLens(
       GraphLens lens, GraphLens appliedLens, DexDefinitionSupplier definitions) {
     DexMethod newMethod = lens.getRenamedMethodSignature(getReference(), appliedLens);
-    if (newMethod == getReference() && !getDefinition().isObsolete()) {
+    if (newMethod.isIdenticalTo(getReference()) && !getDefinition().isObsolete()) {
       assert verifyIsConsistentWithLookup(definitions);
       return this;
     }
     return asProgramMethodOrNull(definitions.definitionFor(newMethod));
   }
 
-  @SuppressWarnings("ReferenceEquality")
   private boolean verifyIsConsistentWithLookup(DexDefinitionSupplier definitions) {
     DexClassAndMethod lookupMethod = definitions.definitionFor(getReference());
     assert getDefinition() == lookupMethod.getDefinition();
diff --git a/src/main/java/com/android/tools/r8/graph/lens/GraphLens.java b/src/main/java/com/android/tools/r8/graph/lens/GraphLens.java
index d0f23ae..96948b9 100644
--- a/src/main/java/com/android/tools/r8/graph/lens/GraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/lens/GraphLens.java
@@ -26,10 +26,7 @@
 import com.android.tools.r8.ir.optimize.enums.EnumUnboxingLens;
 import com.android.tools.r8.optimize.MemberRebindingIdentityLens;
 import com.android.tools.r8.optimize.MemberRebindingLens;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.utils.CollectionUtils;
-import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.Timing;
@@ -43,7 +40,6 @@
 import it.unimi.dsi.fastutil.objects.Object2BooleanArrayMap;
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
 import java.util.ArrayDeque;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Deque;
 import java.util.IdentityHashMap;
@@ -472,35 +468,6 @@
     return true;
   }
 
-  public <T extends DexReference> boolean assertPinnedNotModified(
-      AppView<AppInfoWithLiveness> appView) {
-    List<DexReference> pinnedItems = new ArrayList<>();
-    KeepInfoCollection keepInfo = appView.getKeepInfo();
-    InternalOptions options = appView.options();
-    keepInfo.forEachPinnedType(pinnedItems::add, options);
-    keepInfo.forEachPinnedMethod(pinnedItems::add, options);
-    keepInfo.forEachPinnedField(pinnedItems::add, options);
-    return assertReferencesNotModified(pinnedItems);
-  }
-
-  @SuppressWarnings("ReferenceEquality")
-  public <T extends DexReference> boolean assertReferencesNotModified(Iterable<T> references) {
-    for (DexReference reference : references) {
-      if (reference.isDexField()) {
-        DexField field = reference.asDexField();
-        assert getRenamedFieldSignature(field) == field;
-      } else if (reference.isDexMethod()) {
-        DexMethod method = reference.asDexMethod();
-        assert getRenamedMethodSignature(method) == method;
-      } else {
-        assert reference.isDexType();
-        DexType type = reference.asDexType();
-        assert lookupType(type) == type;
-      }
-    }
-    return true;
-  }
-
   public Map<DexCallSite, ProgramMethodSet> rewriteCallSites(
       Map<DexCallSite, ProgramMethodSet> callSites,
       DexDefinitionSupplier definitions,
diff --git a/src/main/java/com/android/tools/r8/graph/lens/NonIdentityGraphLens.java b/src/main/java/com/android/tools/r8/graph/lens/NonIdentityGraphLens.java
index 987bfe3..e657932 100644
--- a/src/main/java/com/android/tools/r8/graph/lens/NonIdentityGraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/lens/NonIdentityGraphLens.java
@@ -12,8 +12,6 @@
 import com.android.tools.r8.ir.code.InvokeType;
 import com.android.tools.r8.utils.ThrowingAction;
 import com.google.common.collect.Streams;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Predicate;
 
 public abstract class NonIdentityGraphLens extends GraphLens {
@@ -22,8 +20,6 @@
   private final DexItemFactory dexItemFactory;
   private GraphLens previousLens;
 
-  private final Map<DexType, DexType> arrayTypeCache = new ConcurrentHashMap<>();
-
   public NonIdentityGraphLens(AppView<?> appView) {
     this(appView, appView.graphLens());
   }
@@ -104,20 +100,14 @@
   }
 
   @Override
-  @SuppressWarnings("ReferenceEquality")
   public final DexType lookupType(DexType type, GraphLens appliedLens) {
     if (type.isClassType()) {
       return lookupClassType(type, appliedLens);
     }
     if (type.isArrayType()) {
-      DexType result = arrayTypeCache.get(type);
-      if (result == null) {
-        DexType baseType = type.toBaseType(dexItemFactory);
-        DexType newType = lookupType(baseType, appliedLens);
-        result = baseType == newType ? type : type.replaceBaseType(newType, dexItemFactory);
-        arrayTypeCache.put(type, result);
-      }
-      return result;
+      DexType baseType = type.toBaseType(dexItemFactory);
+      DexType newType = lookupType(baseType, appliedLens);
+      return baseType.isIdenticalTo(newType) ? type : type.replaceBaseType(newType, dexItemFactory);
     }
     assert type.isNullValueType() || type.isPrimitiveType() || type.isVoidType();
     return type;
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java b/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java
index 38b433a..85794e3 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.StringSwitch;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
@@ -53,7 +54,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return true;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
index 3570828..d784fa3 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
@@ -438,6 +438,17 @@
     }
   }
 
+  public void removeAllExceptionalSuccessors() {
+    assert hasCatchHandlers();
+    IntList successorsToRemove = new IntArrayList();
+    int numberOfExceptionalSuccessors = numberOfExceptionalSuccessors();
+    for (int i = 0; i < numberOfExceptionalSuccessors; i++) {
+      successorsToRemove.add(i);
+      successors.get(i).getMutablePredecessors().remove(this);
+    }
+    removeSuccessorsByIndex(successorsToRemove);
+  }
+
   public void swapSuccessors(BasicBlock a, BasicBlock b) {
     assert a != b;
     int aIndex = successors.indexOf(a);
@@ -1153,6 +1164,36 @@
     return true;
   }
 
+  private boolean isExceptionTrampoline() {
+    boolean ret = instructions.size() == 2 && entry().isMoveException() && exit().isGoto();
+    assert !ret || !hasCatchHandlers() : "Trampoline should not have catch handlers";
+    return ret;
+  }
+
+  /** Returns whether the given blocks are in the same try block. */
+  public boolean hasEquivalentCatchHandlers(BasicBlock other) {
+    if (this == other) {
+      return true;
+    }
+    List<Integer> targets1 = catchHandlers.getAllTargets();
+    List<Integer> targets2 = other.catchHandlers.getAllTargets();
+    int numHandlers = targets1.size();
+    if (numHandlers != targets2.size()) {
+      return false;
+    }
+    // If all catch handlers are trampolines to the same block, then they are from the same try.
+    for (int i = 0; i < numHandlers; ++i) {
+      BasicBlock catchBlock1 = successors.get(targets1.get(i));
+      BasicBlock catchBlock2 = other.successors.get(targets2.get(i));
+      if (!catchBlock1.isExceptionTrampoline()
+          || !catchBlock2.isExceptionTrampoline()
+          || catchBlock1.getUniqueSuccessor() != catchBlock2.getUniqueSuccessor()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   public void clearCurrentDefinitions() {
     currentDefinitions = null;
     for (Phi phi : getPhis()) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java b/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java
index 1717cb3..7da900e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java
+++ b/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java
@@ -5,7 +5,9 @@
 
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.ir.code.CatchHandlers.CatchHandler;
+import com.android.tools.r8.utils.ListUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.util.ArrayList;
@@ -110,6 +112,12 @@
     return new CatchHandlers<>(newGuards, newTargets);
   }
 
+  public CatchHandlers<T> rewriteWithLens(GraphLens graphLens, GraphLens codeLens) {
+    List<DexType> newGuards =
+        ListUtils.mapOrElse(guards, guard -> graphLens.lookupType(guard, codeLens), null);
+    return newGuards != null ? new CatchHandlers<>(newGuards, targets) : this;
+  }
+
   public void forEach(BiConsumer<DexType, T> consumer) {
     for (int i = 0; i < size(); ++i) {
       consumer.accept(guards.get(i), targets.get(i));
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java b/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java
index af8c834..1bd40d4 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeUtils;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.analysis.type.Nullability;
@@ -86,10 +87,17 @@
       ProgramMethod context,
       AbstractValueSupplier abstractValueSupplier,
       SideEffectAssumption assumption) {
-    return !(size().definition != null
-        && size().definition.isConstNumber()
-        && size().definition.asConstNumber().getRawValue() >= 0
-        && size().definition.asConstNumber().getRawValue() < Integer.MAX_VALUE);
+    assert type.isArrayType();
+    return isArrayTypeInaccessible(appView, context) || isArraySizeMaybeNegative();
+  }
+
+  private boolean isArrayTypeInaccessible(AppView<?> appView, ProgramMethod context) {
+    DexType baseType = type.toBaseType(appView.dexItemFactory());
+    return !DexTypeUtils.isTypeAccessibleInMethodContext(appView, baseType, context);
+  }
+
+  private boolean isArraySizeMaybeNegative() {
+    return sizeIfConst() < 0;
   }
 
   @Override
@@ -111,12 +119,7 @@
     if (instructionInstanceCanThrow(appView, code.context())) {
       return DeadInstructionResult.notDead();
     }
-    // This would belong better in instructionInstanceCanThrow, but that is not passed an appInfo.
-    DexType baseType = type.toBaseType(appView.dexItemFactory());
-    if (baseType.isPrimitiveType() || appView.definitionFor(baseType) != null) {
-      return DeadInstructionResult.deadIfOutValueIsDead();
-    }
-    return DeadInstructionResult.notDead();
+    return DeadInstructionResult.deadIfOutValueIsDead();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index ba73a12..365708f 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -406,6 +406,14 @@
     return uniquePhiUsers = ImmutableSet.copyOf(phiUsers);
   }
 
+  public Set<BasicBlock> uniquePhiUserBlocks() {
+    Set<BasicBlock> ret = Sets.newIdentityHashSet();
+    for (Phi phi : phiUsers) {
+      ret.add(phi.getBlock());
+    }
+    return ret;
+  }
+
   public Set<Instruction> debugUsers() {
     return debugData == null ? null : Collections.unmodifiableSet(debugData.users);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
index 9f48b43..c03f772 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
@@ -57,6 +57,7 @@
 import com.android.tools.r8.ir.optimize.PeepholeOptimizer;
 import com.android.tools.r8.ir.optimize.PhiOptimizations;
 import com.android.tools.r8.ir.optimize.peepholes.BasicBlockMuncher;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.Timing;
 import com.android.tools.r8.utils.WorkList;
 import com.google.common.collect.Sets;
@@ -90,6 +91,7 @@
   private CfRegisterAllocator registerAllocator;
 
   private Position currentPosition = Position.none();
+  private Position preamblePosition = null;
 
   private final Int2ReferenceMap<DebugLocalInfo> emittedLocals = new Int2ReferenceOpenHashMap<>();
   private Int2ReferenceMap<DebugLocalInfo> pendingLocals = null;
@@ -413,6 +415,7 @@
     if (method.getDefinition().getCode().isCfCode()) {
       diagnosticPosition = method.getDefinition().getCode().asCfCode().getDiagnosticPosition();
     }
+    materializePreamblePosition();
     return new CfCode(
         method.getHolderType(),
         stackHeightTracker.maxHeight,
@@ -424,6 +427,25 @@
         bytecodeMetadataBuilder.build());
   }
 
+  private void materializePreamblePosition() {
+    if (!currentPosition.isNone()
+        || preamblePosition == null
+        || !preamblePosition.hasCallerPosition()) {
+      return;
+    }
+    CfLabel existingLabel = ListUtils.first(instructions).asLabel();
+    int instructionIncrement = existingLabel != null ? 1 : 2;
+    List<CfInstruction> newInstructions =
+        new ArrayList<>(instructions.size() + instructionIncrement);
+    CfLabel label = existingLabel != null ? existingLabel : new CfLabel();
+    newInstructions.add(label);
+    newInstructions.add(new CfPosition(label, preamblePosition));
+    for (int i = existingLabel == null ? 0 : 1; i < instructions.size(); i++) {
+      newInstructions.add(instructions.get(i));
+    }
+    instructions = newInstructions;
+  }
+
   private static boolean isNopInstruction(Instruction instruction, BasicBlock nextBlock) {
     // From DexBuilder
     return instruction.isArgument()
@@ -559,6 +581,9 @@
   @SuppressWarnings("ReferenceEquality")
   private void updatePositionAndLocals(Instruction instruction) {
     Position position = instruction.getPosition();
+    if (preamblePosition == null) {
+      preamblePosition = position;
+    }
     boolean didLocalsChange = localsChanged();
     boolean didPositionChange =
         position.isSome()
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
index 6b13747..4fc003f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
@@ -67,6 +67,11 @@
   }
 
   @Override
+  public boolean isD8MethodProcessor() {
+    return true;
+  }
+
+  @Override
   public boolean isProcessedConcurrently(ProgramMethod method) {
     // In D8 all methods are considered independently compiled.
     return true;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 9a7b1e0..2dc1a3f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -85,7 +85,6 @@
 import com.android.tools.r8.shaking.KeepMethodInfo;
 import com.android.tools.r8.shaking.LibraryMethodOverrideAnalysis;
 import com.android.tools.r8.utils.Action;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions;
@@ -129,7 +128,6 @@
   protected ServiceLoaderRewriter serviceLoaderRewriter;
   protected final EnumUnboxer enumUnboxer;
   protected final NumberUnboxer numberUnboxer;
-  protected InstanceInitializerOutliner instanceInitializerOutliner;
   protected final RemoveVerificationErrorForUnknownReturnedValues
       removeVerificationErrorForUnknownReturnedValues;
 
@@ -218,7 +216,6 @@
       this.enumUnboxer = EnumUnboxer.empty();
       this.numberUnboxer = NumberUnboxer.empty();
       this.assumeInserter = null;
-      this.instanceInitializerOutliner = null;
       this.removeVerificationErrorForUnknownReturnedValues = null;
       return;
     }
@@ -230,13 +227,6 @@
         options.processCovariantReturnTypeAnnotations
             ? new CovariantReturnTypeAnnotationTransformer(appView, this)
             : null;
-    if (appView.options().desugarState.isOn()
-        && appView.options().apiModelingOptions().enableOutliningOfMethods
-        && appView.options().getMinApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L)) {
-      this.instanceInitializerOutliner = new InstanceInitializerOutliner(appView);
-    } else {
-      this.instanceInitializerOutliner = null;
-    }
     removeVerificationErrorForUnknownReturnedValues =
         (appView.options().apiModelingOptions().enableLibraryApiModeling
                 && appView.options().canHaveVerifyErrorForUnknownUnusedReturnValue())
@@ -652,12 +642,9 @@
     timing.end();
     previous = printMethod(code, "IR after enum-switch optimization (SSA)", previous);
 
-    if (instanceInitializerOutliner != null) {
-      instanceInitializerOutliner.rewriteInstanceInitializers(
-          code, context, methodProcessor, methodProcessingContext);
-      assert code.verifyTypes(appView);
-      previous = printMethod(code, "IR after instance initializer outlining (SSA)", previous);
-    }
+    new InstanceInitializerOutliner(appView)
+        .run(code, methodProcessor, methodProcessingContext, timing);
+    previous = printMethod(code, "IR after instance initializer outlining (SSA)", previous);
 
     // Update the IR code if collected call site optimization info has something useful.
     // While aggregation of parameter information at call sites would be more precise than static
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriterUtils.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriterUtils.java
index 013bfde..0e31e93 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriterUtils.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriterUtils.java
@@ -118,15 +118,19 @@
         .getName();
   }
 
-  @SuppressWarnings("ReferenceEquality")
   public DexMethodHandle rewriteDexMethodHandle(
       DexMethodHandle methodHandle, MethodHandleUse use, ProgramMethod context) {
+    return rewriteDexMethodHandle(methodHandle, use, context.getReference());
+  }
+
+  @SuppressWarnings("ReferenceEquality")
+  public DexMethodHandle rewriteDexMethodHandle(
+      DexMethodHandle methodHandle, MethodHandleUse use, DexMethod context) {
     if (methodHandle.isMethodHandle()) {
       DexMethod invokedMethod = methodHandle.asMethod();
       MethodHandleType oldType = methodHandle.type;
       MethodLookupResult lensLookup =
-          graphLens.lookupMethod(
-              invokedMethod, context.getReference(), oldType.toInvokeType(), codeLens);
+          graphLens.lookupMethod(invokedMethod, context, oldType.toInvokeType(), codeLens);
       DexMethod rewrittenTarget = lensLookup.getReference();
       DexMethod actualTarget;
       MethodHandleType newType;
@@ -161,7 +165,7 @@
         }
       }
       if (newType != oldType || actualTarget != invokedMethod || rewrittenTarget != actualTarget) {
-        DexClass holder = definitions.definitionFor(actualTarget.holder, context);
+        DexClass holder = definitions.definitionFor(actualTarget.holder);
         boolean isInterface = holder != null ? holder.isInterface() : methodHandle.isInterface;
         return definitions
             .dexItemFactory()
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java
new file mode 100644
index 0000000..19bb6dc
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java
@@ -0,0 +1,284 @@
+// 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.conversion;
+
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.Code;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
+import com.android.tools.r8.graph.lens.GraphLens;
+import com.android.tools.r8.graph.lens.NonIdentityGraphLens;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.conversion.passes.FilledNewArrayRewriter;
+import com.android.tools.r8.ir.optimize.ConstantCanonicalizer;
+import com.android.tools.r8.ir.optimize.DeadCodeRemover;
+import com.android.tools.r8.lightir.IR2LirConverter;
+import com.android.tools.r8.lightir.LirCode;
+import com.android.tools.r8.lightir.LirStrategy;
+import com.android.tools.r8.optimize.MemberRebindingIdentityLens;
+import com.android.tools.r8.utils.ObjectUtils;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+public class LirConverter {
+
+  public static void enterLirSupportedPhase(
+      AppView<AppInfoWithClassHierarchy> appView, ExecutorService executorService)
+      throws ExecutionException {
+    assert appView.testing().canUseLir(appView);
+    assert appView.testing().isPreLirPhase();
+    appView.testing().enterLirSupportedPhase();
+    // Convert code objects to LIR.
+    ThreadUtils.processItems(
+        appView.appInfo().classes(),
+        clazz -> {
+          // TODO(b/225838009): Also convert instance initializers to LIR, by adding support for
+          //  computing the inlining constraint for LIR and using that in the class mergers, and
+          //  class initializers, by updating the concatenation of clinits in horizontal class
+          //  merging.
+          clazz.forEachProgramMethodMatching(
+              method ->
+                  method.hasCode()
+                      && !method.isInitializer()
+                      && !appView.isCfByteCodePassThrough(method),
+              method -> {
+                IRCode code = method.buildIR(appView, MethodConversionOptions.forLirPhase(appView));
+                LirCode<Integer> lirCode =
+                    IR2LirConverter.translate(
+                        code,
+                        BytecodeMetadataProvider.empty(),
+                        LirStrategy.getDefaultStrategy().getEncodingStrategy(),
+                        appView.options());
+                // TODO(b/312890994): Setting a custom code lens is only needed until we convert
+                //  code objects to LIR before we create the first code object with a custom code
+                //  lens (horizontal class merging).
+                GraphLens codeLens = method.getDefinition().getCode().getCodeLens(appView);
+                if (codeLens != appView.codeLens()) {
+                  lirCode =
+                      new LirCode<>(lirCode) {
+                        @Override
+                        public GraphLens getCodeLens(AppView<?> appView) {
+                          return codeLens;
+                        }
+                      };
+                }
+                method.setCode(lirCode, appView);
+              });
+        },
+        appView.options().getThreadingModule(),
+        executorService);
+    // Conversion to LIR via IR will allocate type elements.
+    // They are not needed after construction so remove them again.
+    appView.dexItemFactory().clearTypeElementsCache();
+  }
+
+  public static void rewriteLirWithLens(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      Timing timing,
+      ExecutorService executorService)
+      throws ExecutionException {
+    assert appView.testing().canUseLir(appView);
+    assert appView.testing().isSupportedLirPhase();
+    assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
+    assert verifyLirOnly(appView);
+
+    GraphLens graphLens = appView.graphLens();
+    assert graphLens.isNonIdentityLens();
+    assert appView.codeLens().isAppliedLens();
+
+    MemberRebindingIdentityLens memberRebindingIdentityLens =
+        graphLens.asNonIdentityLens().find(GraphLens::isMemberRebindingIdentityLens);
+    assert memberRebindingIdentityLens != null;
+    if (graphLens == memberRebindingIdentityLens
+        && memberRebindingIdentityLens.getPrevious().isAppliedLens()) {
+      // Nothing to rewrite.
+      return;
+    }
+
+    timing.begin("LIR->LIR@" + graphLens.getClass().getTypeName());
+    rewriteLirWithUnappliedLens(appView, executorService);
+    timing.end();
+
+    // At this point all code has been mapped according to the graph lens.
+    updateCodeLens(appView);
+  }
+
+  private static void rewriteLirWithUnappliedLens(
+      AppView<? extends AppInfoWithClassHierarchy> appView, ExecutorService executorService)
+      throws ExecutionException {
+    LensCodeRewriterUtils rewriterUtils = new LensCodeRewriterUtils(appView, true);
+    ThreadUtils.processItems(
+        appView.appInfo().classes(),
+        clazz ->
+            clazz.forEachProgramMethodMatching(
+                m ->
+                    m.hasCode()
+                        && !m.getCode().isSharedCodeObject()
+                        && !appView.isCfByteCodePassThrough(m),
+                m -> rewriteLirMethodWithLens(m, appView, rewriterUtils)),
+        appView.options().getThreadingModule(),
+        executorService);
+
+    // Clear the reference type cache after conversion to reduce memory pressure.
+    appView.dexItemFactory().clearTypeElementsCache();
+  }
+
+  private static void rewriteLirMethodWithLens(
+      ProgramMethod method,
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      LensCodeRewriterUtils rewriterUtils) {
+    Code code = method.getDefinition().getCode();
+    if (!code.isLirCode()) {
+      assert false;
+      return;
+    }
+    LirCode<Integer> lirCode = code.asLirCode();
+    LirCode<Integer> rewrittenLirCode =
+        lirCode.rewriteWithSimpleLens(method, appView, rewriterUtils);
+    if (ObjectUtils.notIdentical(lirCode, rewrittenLirCode)) {
+      method.setCode(rewrittenLirCode, appView);
+    }
+  }
+
+  public static void finalizeLirToOutputFormat(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      Timing timing,
+      ExecutorService executorService)
+      throws ExecutionException {
+    assert appView.testing().canUseLir(appView);
+    assert appView.testing().isSupportedLirPhase();
+    assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
+    assert verifyLirOnly(appView);
+    appView.testing().exitLirSupportedPhase();
+    LensCodeRewriterUtils rewriterUtils = new LensCodeRewriterUtils(appView, true);
+    DeadCodeRemover deadCodeRemover = new DeadCodeRemover(appView);
+    String output = appView.options().isGeneratingClassFiles() ? "CF" : "DEX";
+    timing.begin("LIR->IR->" + output);
+    ThreadUtils.processItems(
+        appView.appInfo().classes(),
+        clazz ->
+            clazz.forEachProgramMethod(
+                m -> finalizeLirMethodToOutputFormat(m, deadCodeRemover, appView, rewriterUtils)),
+        appView.options().getThreadingModule(),
+        executorService);
+    timing.end();
+    // Clear the reference type cache after conversion to reduce memory pressure.
+    appView.dexItemFactory().clearTypeElementsCache();
+    // At this point all code has been mapped according to the graph lens.
+    updateCodeLens(appView);
+  }
+
+  private static void updateCodeLens(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    final NonIdentityGraphLens lens = appView.graphLens().asNonIdentityLens();
+    if (lens == null) {
+      assert false;
+      return;
+    }
+
+    // If the current graph lens is the member rebinding identity lens then code lens is simply
+    // the previous lens. This is the same structure as the more complicated case below but where
+    // there is no need to rewrite any previous pointers.
+    if (lens.isMemberRebindingIdentityLens()) {
+      appView.setCodeLens(lens.getPrevious());
+      return;
+    }
+
+    // Otherwise search out where the lens pointing to the member rebinding identity lens.
+    NonIdentityGraphLens lensAfterMemberRebindingIdentityLens =
+        lens.find(p -> p.getPrevious().isMemberRebindingIdentityLens());
+    if (lensAfterMemberRebindingIdentityLens == null) {
+      // With the current compiler structure we expect to always find the lens.
+      assert false;
+      appView.setCodeLens(lens);
+      return;
+    }
+
+    GraphLens codeLens = appView.codeLens();
+    MemberRebindingIdentityLens memberRebindingIdentityLens =
+        lensAfterMemberRebindingIdentityLens.getPrevious().asMemberRebindingIdentityLens();
+
+    // We are assuming that the member rebinding identity lens is always installed after the current
+    // applied lens/code lens and also that there should not be a rebinding lens from the compilers
+    // first phase (this subroutine is only used after IR conversion for now).
+    assert memberRebindingIdentityLens
+        == lens.findPrevious(
+            p -> p == memberRebindingIdentityLens || p == codeLens || p.isMemberRebindingLens());
+
+    // Rewrite the graph lens effects from 'lens' and up to the member rebinding identity lens.
+    MemberRebindingIdentityLens rewrittenMemberRebindingLens =
+        memberRebindingIdentityLens.toRewrittenMemberRebindingIdentityLens(
+            appView, lens, memberRebindingIdentityLens, lens);
+
+    // The current previous pointers for the graph lenses are:
+    //   lens -> ... -> lensAfterMemberRebindingIdentityLens -> memberRebindingIdentityLens -> g
+    // we rewrite them now to:
+    //   rewrittenMemberRebindingLens -> lens -> ... -> lensAfterMemberRebindingIdentityLens -> g
+
+    // The above will construct the new member rebinding lens such that it points to the new
+    // code-lens point already.
+    assert rewrittenMemberRebindingLens.getPrevious() == lens;
+
+    // Update the previous pointer on the new code lens to jump over the old member rebinding
+    // identity lens.
+    lensAfterMemberRebindingIdentityLens.setPrevious(memberRebindingIdentityLens.getPrevious());
+
+    // The applied lens can now be updated and the rewritten member rebinding lens installed as
+    // the current "unapplied lens".
+    appView.setCodeLens(lens);
+    appView.setGraphLens(rewrittenMemberRebindingLens);
+  }
+
+  private static void finalizeLirMethodToOutputFormat(
+      ProgramMethod method,
+      DeadCodeRemover deadCodeRemover,
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      LensCodeRewriterUtils rewriterUtils) {
+    Code code = method.getDefinition().getCode();
+    if (!(code instanceof LirCode)) {
+      return;
+    }
+    Timing onThreadTiming = Timing.empty();
+    LirCode<Integer> lirCode = code.asLirCode();
+    LirCode<Integer> rewrittenLirCode =
+        lirCode.rewriteWithSimpleLens(method, appView, rewriterUtils);
+    if (ObjectUtils.notIdentical(lirCode, rewrittenLirCode)) {
+      method.setCode(rewrittenLirCode, appView);
+    }
+    IRCode irCode = method.buildIR(appView, MethodConversionOptions.forPostLirPhase(appView));
+    FilledNewArrayRewriter filledNewArrayRewriter = new FilledNewArrayRewriter(appView);
+    boolean changed = filledNewArrayRewriter.run(irCode, onThreadTiming).hasChanged().toBoolean();
+    if (appView.options().isGeneratingDex() && changed) {
+      ConstantCanonicalizer constantCanonicalizer =
+          new ConstantCanonicalizer(appView, method, irCode);
+      constantCanonicalizer.canonicalize();
+    }
+    // Processing is done and no further uses of the meta-data should arise.
+    BytecodeMetadataProvider noMetadata = BytecodeMetadataProvider.empty();
+    // During processing optimization info may cause previously live code to become dead.
+    // E.g., we may now have knowledge that an invoke does not have side effects.
+    // Thus, we re-run the dead-code remover now as it is assumed complete by CF/DEX finalization.
+    deadCodeRemover.run(irCode, onThreadTiming);
+    MethodConversionOptions conversionOptions = irCode.getConversionOptions();
+    assert !conversionOptions.isGeneratingLir();
+    IRFinalizer<?> finalizer = conversionOptions.getFinalizer(deadCodeRemover, appView);
+    method.setCode(finalizer.finalizeCode(irCode, noMetadata, onThreadTiming), appView);
+  }
+
+  public static boolean verifyLirOnly(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      for (DexEncodedMethod method : clazz.methods(DexEncodedMethod::hasCode)) {
+        assert method.getCode().isLirCode()
+            || method.getCode().isSharedCodeObject()
+            || appView.isCfByteCodePassThrough(method)
+            || appView.options().skipIR;
+      }
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
index a80055a..829c985 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
@@ -17,6 +17,10 @@
     return null;
   }
 
+  public boolean isD8MethodProcessor() {
+    return false;
+  }
+
   public boolean isPrimaryMethodProcessor() {
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryD8L8IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryD8L8IRConverter.java
index e1a4c6f..625a337 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryD8L8IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryD8L8IRConverter.java
@@ -71,10 +71,6 @@
     reportNestDesugarDependencies();
     clearNestAttributes();
 
-    if (instanceInitializerOutliner != null) {
-      processSimpleSynthesizeMethods(
-          instanceInitializerOutliner.getSynthesizedMethods(), executorService);
-    }
     if (assertionErrorTwoArgsConstructorRewriter != null) {
       processSimpleSynthesizeMethods(
           assertionErrorTwoArgsConstructorRewriter.getSynthesizedMethods(), executorService);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java
index e87faba..3dd62c9 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java
@@ -6,28 +6,17 @@
 
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.PrunedItems;
-import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
 import com.android.tools.r8.graph.lens.GraphLens;
-import com.android.tools.r8.graph.lens.NonIdentityGraphLens;
 import com.android.tools.r8.ir.analysis.fieldaccess.TrivialFieldAccessReprocessor;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.conversion.passes.FilledNewArrayRewriter;
-import com.android.tools.r8.ir.optimize.ConstantCanonicalizer;
-import com.android.tools.r8.ir.optimize.DeadCodeRemover;
 import com.android.tools.r8.ir.optimize.info.MethodResolutionOptimizationInfoAnalysis;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
-import com.android.tools.r8.lightir.LirCode;
-import com.android.tools.r8.optimize.MemberRebindingIdentityLens;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagator;
 import com.android.tools.r8.optimize.compose.ComposableOptimizationPass;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
 import java.io.IOException;
@@ -239,139 +228,6 @@
     return appView.appInfo().app();
   }
 
-  public static void finalizeLirToOutputFormat(
-      AppView<? extends AppInfoWithClassHierarchy> appView,
-      Timing timing,
-      ExecutorService executorService)
-      throws ExecutionException {
-    appView.testing().exitLirSupportedPhase();
-    if (!appView.testing().canUseLir(appView)) {
-      return;
-    }
-    LensCodeRewriterUtils rewriterUtils = new LensCodeRewriterUtils(appView, true);
-    DeadCodeRemover deadCodeRemover = new DeadCodeRemover(appView);
-    String output = appView.options().isGeneratingClassFiles() ? "CF" : "DEX";
-    timing.begin("LIR->IR->" + output);
-    ThreadUtils.processItems(
-        appView.appInfo().classes(),
-        clazz ->
-            clazz.forEachProgramMethod(
-                m -> finalizeLirMethodToOutputFormat(m, deadCodeRemover, appView, rewriterUtils)),
-        appView.options().getThreadingModule(),
-        executorService);
-    appView
-        .getSyntheticItems()
-        .getPendingSyntheticClasses()
-        .forEach(
-            clazz ->
-                clazz.forEachProgramMethod(
-                    m ->
-                        finalizeLirMethodToOutputFormat(
-                            m, deadCodeRemover, appView, rewriterUtils)));
-    timing.end();
-    // Clear the reference type cache after conversion to reduce memory pressure.
-    appView.dexItemFactory().clearTypeElementsCache();
-    // At this point all code has been mapped according to the graph lens.
-    updateCodeLens(appView);
-  }
-
-  private static void updateCodeLens(AppView<? extends AppInfoWithClassHierarchy> appView) {
-    final NonIdentityGraphLens lens = appView.graphLens().asNonIdentityLens();
-    if (lens == null) {
-      assert false;
-      return;
-    }
-
-    // If the current graph lens is the member rebinding identity lens then code lens is simply
-    // the previous lens. This is the same structure as the more complicated case below but where
-    // there is no need to rewrite any previous pointers.
-    if (lens.isMemberRebindingIdentityLens()) {
-      appView.setCodeLens(lens.getPrevious());
-      return;
-    }
-
-    // Otherwise search out where the lens pointing to the member rebinding identity lens.
-    NonIdentityGraphLens lensAfterMemberRebindingIdentityLens =
-        lens.find(p -> p.getPrevious().isMemberRebindingIdentityLens());
-    if (lensAfterMemberRebindingIdentityLens == null) {
-      // With the current compiler structure we expect to always find the lens.
-      assert false;
-      appView.setCodeLens(lens);
-      return;
-    }
-
-    GraphLens codeLens = appView.codeLens();
-    MemberRebindingIdentityLens memberRebindingIdentityLens =
-        lensAfterMemberRebindingIdentityLens.getPrevious().asMemberRebindingIdentityLens();
-
-    // We are assuming that the member rebinding identity lens is always installed after the current
-    // applied lens/code lens and also that there should not be a rebinding lens from the compilers
-    // first phase (this subroutine is only used after IR conversion for now).
-    assert memberRebindingIdentityLens
-        == lens.findPrevious(
-            p -> p == memberRebindingIdentityLens || p == codeLens || p.isMemberRebindingLens());
-
-    // Rewrite the graph lens effects from 'lens' and up to the member rebinding identity lens.
-    MemberRebindingIdentityLens rewrittenMemberRebindingLens =
-        memberRebindingIdentityLens.toRewrittenMemberRebindingIdentityLens(
-            appView, lens, memberRebindingIdentityLens, lens);
-
-    // The current previous pointers for the graph lenses are:
-    //   lens -> ... -> lensAfterMemberRebindingIdentityLens -> memberRebindingIdentityLens -> g
-    // we rewrite them now to:
-    //   rewrittenMemberRebindingLens -> lens -> ... -> lensAfterMemberRebindingIdentityLens -> g
-
-    // The above will construct the new member rebinding lens such that it points to the new
-    // code-lens point already.
-    assert rewrittenMemberRebindingLens.getPrevious() == lens;
-
-    // Update the previous pointer on the new code lens to jump over the old member rebinding
-    // identity lens.
-    lensAfterMemberRebindingIdentityLens.setPrevious(memberRebindingIdentityLens.getPrevious());
-
-    // The applied lens can now be updated and the rewritten member rebinding lens installed as
-    // the current "unapplied lens".
-    appView.setCodeLens(lens);
-    appView.setGraphLens(rewrittenMemberRebindingLens);
-  }
-
-  @SuppressWarnings("ReferenceEquality")
-  private static void finalizeLirMethodToOutputFormat(
-      ProgramMethod method,
-      DeadCodeRemover deadCodeRemover,
-      AppView<?> appView,
-      LensCodeRewriterUtils rewriterUtils) {
-    Code code = method.getDefinition().getCode();
-    if (!(code instanceof LirCode)) {
-      return;
-    }
-    Timing onThreadTiming = Timing.empty();
-    LirCode<Integer> lirCode = code.asLirCode();
-    LirCode<Integer> rewrittenLirCode =
-        lirCode.rewriteWithSimpleLens(method, appView, rewriterUtils);
-    if (lirCode != rewrittenLirCode) {
-      method.setCode(rewrittenLirCode, appView);
-    }
-    IRCode irCode = method.buildIR(appView, MethodConversionOptions.forPostLirPhase(appView));
-    FilledNewArrayRewriter filledNewArrayRewriter = new FilledNewArrayRewriter(appView);
-    boolean changed = filledNewArrayRewriter.run(irCode, onThreadTiming).hasChanged().toBoolean();
-    if (appView.options().isGeneratingDex() && changed) {
-      ConstantCanonicalizer constantCanonicalizer =
-          new ConstantCanonicalizer(appView, method, irCode);
-      constantCanonicalizer.canonicalize();
-    }
-    // Processing is done and no further uses of the meta-data should arise.
-    BytecodeMetadataProvider noMetadata = BytecodeMetadataProvider.empty();
-    // During processing optimization info may cause previously live code to become dead.
-    // E.g., we may now have knowledge that an invoke does not have side effects.
-    // Thus, we re-run the dead-code remover now as it is assumed complete by CF/DEX finalization.
-    deadCodeRemover.run(irCode, onThreadTiming);
-    MethodConversionOptions conversionOptions = irCode.getConversionOptions();
-    assert !conversionOptions.isGeneratingLir();
-    IRFinalizer<?> finalizer = conversionOptions.getFinalizer(deadCodeRemover, appView);
-    method.setCode(finalizer.finalizeCode(irCode, noMetadata, onThreadTiming), appView);
-  }
-
   private void clearDexMethodCompilationState() {
     appView.appInfo().classes().forEach(this::clearDexMethodCompilationState);
   }
@@ -430,10 +286,6 @@
     if (inliner != null) {
       inliner.onLastWaveDone(postMethodProcessorBuilder, executorService, timing);
     }
-    if (instanceInitializerOutliner != null) {
-      instanceInitializerOutliner.onLastWaveDone(postMethodProcessorBuilder);
-      instanceInitializerOutliner = null;
-    }
     if (serviceLoaderRewriter != null) {
       serviceLoaderRewriter.onLastWaveDone(postMethodProcessorBuilder);
       serviceLoaderRewriter = null;
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 df8d38a..41379ad 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
@@ -7,24 +7,28 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeUtils;
 import com.android.tools.r8.ir.code.ArrayPut;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.LinearFlowInstructionListIterator;
 import com.android.tools.r8.ir.code.NewArrayEmpty;
 import com.android.tools.r8.ir.code.NewArrayFilled;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
-import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ArrayUtils;
+import com.android.tools.r8.utils.DominatorChecker;
 import com.android.tools.r8.utils.InternalOptions.RewriteArrayOptions;
-import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.ValueUtils;
+import com.android.tools.r8.utils.ValueUtils.ArrayValues;
 import com.android.tools.r8.utils.WorkList;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.IdentityHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -79,8 +83,11 @@
  */
 public class ArrayConstructionSimplifier extends CodeRewriterPass<AppInfo> {
 
+  private final RewriteArrayOptions rewriteArrayOptions;
+
   public ArrayConstructionSimplifier(AppView<?> appView) {
     super(appView);
+    rewriteArrayOptions = options.rewriteArrayOptions();
   }
 
   @Override
@@ -90,228 +97,271 @@
 
   @Override
   protected CodeRewriterResult rewriteCode(IRCode code) {
-    boolean hasChanged = false;
-    WorkList<BasicBlock> worklist = WorkList.newIdentityWorkList(code.blocks);
-    while (worklist.hasNext()) {
-      BasicBlock block = worklist.next();
-      hasChanged |= simplifyArrayConstructionBlock(block, worklist, code, appView.options());
+    ArrayList<ArrayValues> candidates = findOptimizableArrays(code);
+
+    if (candidates.isEmpty()) {
+      return CodeRewriterResult.NO_CHANGE;
     }
-    return CodeRewriterResult.hasChanged(hasChanged);
+    applyChanges(code, candidates);
+    return CodeRewriterResult.HAS_CHANGED;
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return code.metadata().mayHaveNewArrayEmpty();
   }
 
-  private boolean simplifyArrayConstructionBlock(
-      BasicBlock block, WorkList<BasicBlock> worklist, IRCode code, InternalOptions options) {
-    boolean hasChanged = false;
-    RewriteArrayOptions rewriteOptions = options.rewriteArrayOptions();
-    InstructionListIterator it = block.listIterator(code);
-    while (it.hasNext()) {
-      FilledArrayCandidate candidate = computeFilledArrayCandidate(it.next(), rewriteOptions);
-      if (candidate == null) {
-        continue;
-      }
-      FilledArrayConversionInfo info =
-          computeConversionInfo(
-              code, candidate, new LinearFlowInstructionListIterator(code, block, it.nextIndex()));
-      if (info == null) {
-        continue;
-      }
-
-      Instruction instructionAfterCandidate = it.peekNext();
-      NewArrayEmpty newArrayEmpty = candidate.newArrayEmpty;
-      DexType arrayType = newArrayEmpty.type;
-      int size = candidate.size;
-      Set<Instruction> instructionsToRemove = SetUtils.newIdentityHashSet(size + 1);
-      assert newArrayEmpty.getLocalInfo() == null;
-      Instruction lastArrayPut = info.lastArrayPutIterator.peekPrevious();
-      Value invokeValue = code.createValue(newArrayEmpty.getOutType(), null);
-      NewArrayFilled invoke =
-          new NewArrayFilled(arrayType, invokeValue, Arrays.asList(info.values));
-      invoke.setPosition(lastArrayPut.getPosition());
-      for (Value value : newArrayEmpty.inValues()) {
-        value.removeUser(newArrayEmpty);
-      }
-      newArrayEmpty.outValue().replaceUsers(invokeValue);
-      instructionsToRemove.add(newArrayEmpty);
-
-      boolean originalAllocationPointHasHandlers = block.hasCatchHandlers();
-      boolean insertionPointHasHandlers = lastArrayPut.getBlock().hasCatchHandlers();
-
-      if (!insertionPointHasHandlers && !originalAllocationPointHasHandlers) {
-        info.lastArrayPutIterator.add(invoke);
-      } else {
-        BasicBlock insertionBlock = info.lastArrayPutIterator.split(code);
-        if (originalAllocationPointHasHandlers) {
-          if (!insertionBlock.isTrivialGoto()) {
-            BasicBlock blockAfterInsertion = insertionBlock.listIterator(code).split(code);
-            assert insertionBlock.isTrivialGoto();
-            worklist.addIfNotSeen(blockAfterInsertion);
-          }
-          insertionBlock.moveCatchHandlers(block);
-        } else {
-          worklist.addIfNotSeen(insertionBlock);
-        }
-        insertionBlock.listIterator(code).add(invoke);
-      }
-
-      instructionsToRemove.addAll(info.arrayPutsToRemove);
-      Set<BasicBlock> visitedBlocks = Sets.newIdentityHashSet();
-      for (Instruction instruction : instructionsToRemove) {
-        BasicBlock ownerBlock = instruction.getBlock();
-        // If owner block is null, then the instruction has been removed already. We can't rely on
-        // just having the block pointer nulled, so the visited blocks guards reprocessing.
-        if (ownerBlock != null && visitedBlocks.add(ownerBlock)) {
-          InstructionListIterator removeIt = ownerBlock.listIterator(code);
-          while (removeIt.hasNext()) {
-            if (instructionsToRemove.contains(removeIt.next())) {
-              removeIt.removeOrReplaceByDebugLocalRead();
-            }
-          }
+  private ArrayList<ArrayValues> findOptimizableArrays(IRCode code) {
+    ArrayList<ArrayValues> candidates = new ArrayList<>();
+    for (Instruction instruction : code.instructions()) {
+      NewArrayEmpty newArrayEmpty = instruction.asNewArrayEmpty();
+      if (newArrayEmpty != null) {
+        ArrayValues arrayValues = analyzeCandidate(newArrayEmpty, code);
+        if (arrayValues != null) {
+          candidates.add(arrayValues);
         }
       }
-
-      // The above has invalidated the block iterator so reset it and continue.
-      it = block.listIterator(code, instructionAfterCandidate);
-      hasChanged = true;
     }
-    if (hasChanged) {
-      code.removeRedundantBlocks();
-    }
-
-    return hasChanged;
+    return candidates;
   }
 
-  private static class FilledArrayConversionInfo {
-
-    Value[] values;
-    List<ArrayPut> arrayPutsToRemove;
-    LinearFlowInstructionListIterator lastArrayPutIterator;
-
-    public FilledArrayConversionInfo(int size) {
-      values = new Value[size];
-      arrayPutsToRemove = new ArrayList<>(size);
+  private ArrayValues analyzeCandidate(NewArrayEmpty newArrayEmpty, IRCode code) {
+    if (newArrayEmpty.getLocalInfo() != null) {
+      return null;
     }
+    if (!rewriteArrayOptions.isPotentialSize(newArrayEmpty.sizeIfConst())) {
+      return null;
+    }
+
+    ArrayValues arrayValues = ValueUtils.computeInitialArrayValues(newArrayEmpty);
+    // Holes (default-initialized entries) could be supported, but they are rare and would
+    // complicate the logic.
+    if (arrayValues == null || arrayValues.containsHoles()) {
+      return null;
+    }
+
+    // See if all instructions are in the same try/catch.
+    ArrayPut lastArrayPut = ArrayUtils.last(arrayValues.getArrayPutsByIndex());
+    if (!newArrayEmpty.getBlock().hasEquivalentCatchHandlers(lastArrayPut.getBlock())) {
+      // Possible improvements:
+      // 1) Ignore catch handlers that do not catch OutOfMemoryError / NoClassDefFoundError.
+      // 2) Use the catch handlers from the new-array-empty if all exception blocks exit without
+      //    side effects (e.g. no method calls & no monitor instructions).
+      return null;
+    }
+
+    if (!checkTypesAreCompatible(arrayValues, code)) {
+      return null;
+    }
+    if (!checkDominance(arrayValues)) {
+      return null;
+    }
+    return arrayValues;
   }
 
-  @SuppressWarnings("ReferenceEquality")
-  private FilledArrayConversionInfo computeConversionInfo(
-      IRCode code, FilledArrayCandidate candidate, LinearFlowInstructionListIterator it) {
-    NewArrayEmpty newArrayEmpty = candidate.newArrayEmpty;
-    assert it.peekPrevious() == newArrayEmpty;
-    Value arrayValue = newArrayEmpty.outValue();
-    int size = candidate.size;
-
+  private boolean checkTypesAreCompatible(ArrayValues arrayValues, IRCode code) {
     // aput-object allows any object for arrays of interfaces, but new-filled-array fails to verify
     // if types require a cast.
     // TODO(b/246971330): Check if adding a checked-cast would have the same observable result. E.g.
     //   if aput-object throws a ClassCastException if given an object that does not implement the
     //   desired interface, then we could add check-cast instructions for arguments we're not sure
     //   about.
+    NewArrayEmpty newArrayEmpty = arrayValues.getDefinition().asNewArrayEmpty();
     DexType elementType = newArrayEmpty.type.toArrayElementType(dexItemFactory);
     boolean needsTypeCheck =
-        !elementType.isPrimitiveType() && elementType != dexItemFactory.objectType;
+        !elementType.isPrimitiveType() && elementType.isNotIdenticalTo(dexItemFactory.objectType);
+    if (!needsTypeCheck) {
+      return true;
+    }
 
-    FilledArrayConversionInfo info = new FilledArrayConversionInfo(size);
-    Value[] values = info.values;
-    int remaining = size;
-    Set<Instruction> users = newArrayEmpty.outValue().uniqueUsers();
-    while (it.hasNext()) {
-      Instruction instruction = it.next();
-      BasicBlock block = instruction.getBlock();
-      // If we encounter an instruction that can throw an exception we need to bail out of the
-      // optimization so that we do not transform half-initialized arrays into fully initialized
-      // arrays on exceptional edges. If the block has no handlers it is not observable so
-      // we perform the rewriting.
-      if (block.hasCatchHandlers()
-          && instruction.instructionInstanceCanThrow(appView, code.context())) {
-        return null;
-      }
-      if (!users.contains(instruction)) {
-        // If any instruction can transfer control between the new-array and the last array put
-        // then it is not safe to move the new array to the point of the last put.
-        if (block.hasCatchHandlers() && instruction.instructionTypeCanThrow()) {
-          return null;
-        }
+    // Not safe to move allocation if NoClassDefError is possible.
+    // TODO(b/246971330): Make this work for D8 where it ~always returns false by checking that
+    // all instructions between new-array-empty and the last array-put report
+    // !instruction.instructionMayHaveSideEffects(). Alternatively, we could replace the
+    // new-array-empty with a const-class instruction in this case.
+    if (!DexTypeUtils.isTypeAccessibleInMethodContext(
+        appView, elementType.toBaseType(dexItemFactory), code.context())) {
+      return false;
+    }
+
+    for (ArrayPut arrayPut : arrayValues.getArrayPutsByIndex()) {
+      Value value = arrayPut.value();
+      if (value.isAlwaysNull(appView)) {
         continue;
       }
-      ArrayPut arrayPut = instruction.asArrayPut();
-      // If the initialization sequence is broken by another use we cannot use a fill-array-data
-      // instruction.
+      DexType valueDexType = value.getType().asReferenceType().toDexType(dexItemFactory);
+      if (elementType.isArrayType()) {
+        if (elementType.isNotIdenticalTo(valueDexType)) {
+          return false;
+        }
+      } else if (valueDexType.isArrayType()) {
+        // isSubtype asserts for this case.
+        return false;
+      } else if (valueDexType.isNullValueType()) {
+        // Assume instructions can cause value.isAlwaysNull() == false while the DexType is
+        // null.
+        // TODO(b/246971330): Figure out how to write a test in SimplifyArrayConstructionTest
+        //   that hits this case.
+      } else {
+        // TODO(b/246971330): When in d8 mode, we might still be able to see if this is true for
+        //   library types (which this helper does not do).
+        if (appView.isSubtype(valueDexType, elementType).isPossiblyFalse()) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  private static boolean checkDominance(ArrayValues arrayValues) {
+    Value arrayValue = arrayValues.getArrayValue();
+
+    Set<BasicBlock> usageBlocks = Sets.newIdentityHashSet();
+    Set<Instruction> uniqueUsers = arrayValue.uniqueUsers();
+    for (Instruction user : uniqueUsers) {
+      ArrayPut arrayPut = user.asArrayPut();
       if (arrayPut == null || arrayPut.array() != arrayValue) {
-        return null;
+        usageBlocks.add(user.getBlock());
       }
-      int index = arrayPut.indexIfConstAndInBounds(values.length);
-      if (index < 0 || values[index] != null) {
-        return null;
+    }
+
+    // Ensure all blocks for users of the array are dominated by the last array-put's block.
+    ArrayPut lastArrayPut = ArrayUtils.last(arrayValues.getArrayPutsByIndex());
+    BasicBlock lastArrayPutBlock = lastArrayPut.getBlock();
+    BasicBlock subgraphEntryBlock = arrayValue.definition.getBlock();
+    for (BasicBlock usageBlock : usageBlocks) {
+      if (!DominatorChecker.check(subgraphEntryBlock, usageBlock, lastArrayPutBlock)) {
+        return false;
       }
-      if (arrayPut.instructionInstanceCanThrow(appView, code.context())) {
-        return null;
+    }
+
+    // Ensure all array users in the same block appear after the last array-put
+    for (Instruction inst : lastArrayPutBlock.getInstructions()) {
+      if (inst == lastArrayPut) {
+        break;
       }
-      Value value = arrayPut.value();
-      if (needsTypeCheck && !value.isAlwaysNull(appView)) {
-        DexType valueDexType = value.getType().asReferenceType().toDexType(dexItemFactory);
-        if (elementType.isArrayType()) {
-          if (elementType != valueDexType) {
-            return null;
-          }
-        } else if (valueDexType.isArrayType()) {
-          // isSubtype asserts for this case.
-          return null;
-        } else if (valueDexType.isNullValueType()) {
-          // Assume instructions can cause value.isAlwaysNull() == false while the DexType is null.
-          // TODO(b/246971330): Figure out how to write a test in SimplifyArrayConstructionTest
-          //   that hits this case.
-        } else {
-          // TODO(b/246971330): When in d8 mode, we might still be able to see if this is true for
-          //   library types (which this helper does not do).
-          if (appView.isSubtype(valueDexType, elementType).isPossiblyFalse()) {
-            return null;
+      if (uniqueUsers.contains(inst)) {
+        ArrayPut arrayPut = inst.asArrayPut();
+        if (arrayPut == null || arrayPut.array() != arrayValue) {
+          return false;
+        }
+      }
+    }
+
+    // It will not be the case that the newArrayEmpty dominates the phi user (or else it would
+    // just be a normal user). It is safe to optimize if all paths from the new-array-empty to the
+    // phi user include the last array-put (where the filled-new-array will end up).
+    if (anyPhiUsersReachableWhenOptimized(arrayValues)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Determines if there are any paths from the new-array-empty to any of its phi users that do not
+   * go through the last array-put, and that do not go through exceptional edges for new-array-empty
+   * / array-puts that will be removed.
+   */
+  private static boolean anyPhiUsersReachableWhenOptimized(ArrayValues arrayValues) {
+    Value arrayValue = arrayValues.getArrayValue();
+    if (!arrayValue.hasPhiUsers()) {
+      return false;
+    }
+    Set<BasicBlock> phiUserBlocks = arrayValue.uniquePhiUserBlocks();
+    WorkList<BasicBlock> workList = WorkList.newIdentityWorkList();
+    // Mark the last array-put as seen in order to find paths that do not contain it.
+    workList.markAsSeen(ArrayUtils.last(arrayValues.getArrayPutsByIndex()).getBlock());
+    // Start with normal successors since if optimized, the new-array-empty block will have no
+    // throwing instructions.
+    workList.addIfNotSeen(arrayValue.definition.getBlock().getNormalSuccessors());
+    while (workList.hasNext()) {
+      BasicBlock current = workList.removeLast();
+      if (phiUserBlocks.contains(current)) {
+        return true;
+      }
+      if (current.hasCatchHandlers()) {
+        Instruction throwingInstruction = current.exceptionalExit();
+        if (throwingInstruction != null) {
+          ArrayPut arrayPut = throwingInstruction.asArrayPut();
+          // Ignore exceptional edges that will be remove if optimized.
+          if (arrayPut != null && arrayPut.array() == arrayValue) {
+            workList.addIfNotSeen(current.getNormalSuccessors());
+            continue;
           }
         }
       }
-      info.arrayPutsToRemove.add(arrayPut);
-      values[index] = value;
-      --remaining;
-      if (remaining == 0) {
-        info.lastArrayPutIterator = it;
-        return info;
+      workList.addIfNotSeen(current.getSuccessors());
+    }
+    return false;
+  }
+
+  private void applyChanges(IRCode code, List<ArrayValues> candidates) {
+    Set<BasicBlock> relevantBlocks = Sets.newIdentityHashSet();
+    // All keys instructionsToChange are removed, and also maps lastArrayPut -> newArrayFilled.
+    Map<Instruction, Instruction> instructionsToChange = new IdentityHashMap<>();
+    boolean needToRemoveUnreachableBlocks = false;
+
+    for (ArrayValues arrayValues : candidates) {
+      NewArrayEmpty newArrayEmpty = arrayValues.getDefinition().asNewArrayEmpty();
+      instructionsToChange.put(newArrayEmpty, newArrayEmpty);
+      BasicBlock allocationBlock = newArrayEmpty.getBlock();
+      relevantBlocks.add(allocationBlock);
+
+      ArrayPut[] arrayPutsByIndex = arrayValues.getArrayPutsByIndex();
+      int lastArrayPutIndex = arrayPutsByIndex.length - 1;
+      for (int i = 0; i < lastArrayPutIndex; ++i) {
+        ArrayPut arrayPut = arrayPutsByIndex[i];
+        instructionsToChange.put(arrayPut, arrayPut);
+        relevantBlocks.add(arrayPut.getBlock());
+      }
+      ArrayPut lastArrayPut = arrayPutsByIndex[lastArrayPutIndex];
+      BasicBlock lastArrayPutBlock = lastArrayPut.getBlock();
+      relevantBlocks.add(lastArrayPutBlock);
+
+      // newArrayEmpty's outValue must be cleared before trying to remove newArrayEmpty. Rather than
+      // store the outValue for later, create and store newArrayFilled.
+      Value arrayValue = newArrayEmpty.clearOutValue();
+      NewArrayFilled newArrayFilled =
+          new NewArrayFilled(newArrayEmpty.type, arrayValue, arrayValues.getElementValues());
+      newArrayFilled.setPosition(lastArrayPut.getPosition());
+      instructionsToChange.put(lastArrayPut, newArrayFilled);
+
+      if (arrayValue.hasPhiUsers() && allocationBlock.hasCatchHandlers()) {
+        // When phi users exist, the phis belong to the exceptional successors of the allocation
+        // block. In order to preserve them, move them to the new allocation block.
+        // This is safe because we've already checked hasEquivalentCatchHandlers().
+        lastArrayPutBlock.removeAllExceptionalSuccessors();
+        lastArrayPutBlock.moveCatchHandlers(allocationBlock);
+        needToRemoveUnreachableBlocks = true;
       }
     }
-    return null;
-  }
 
-  private static class FilledArrayCandidate {
+    for (BasicBlock block : relevantBlocks) {
+      boolean hasCatchHandlers = block.hasCatchHandlers();
+      InstructionListIterator it = block.listIterator(code);
+      while (it.hasNext()) {
+        Instruction possiblyNewArray = instructionsToChange.get(it.next());
+        if (possiblyNewArray != null) {
+          if (possiblyNewArray.isNewArrayFilled()) {
+            // Change the last array-put to the new-array-filled.
+            it.replaceCurrentInstruction(possiblyNewArray);
+          } else {
+            it.removeOrReplaceByDebugLocalRead();
+            if (hasCatchHandlers) {
+              // Removing these catch handlers shrinks their ranges to be only that where the
+              // allocation occurs.
+              needToRemoveUnreachableBlocks = true;
+              assert !block.canThrow();
+              block.removeAllExceptionalSuccessors();
+            }
+          }
+        }
+      }
+    }
 
-    final NewArrayEmpty newArrayEmpty;
-    final int size;
-
-    public FilledArrayCandidate(NewArrayEmpty newArrayEmpty, int size) {
-      assert size > 0;
-      this.newArrayEmpty = newArrayEmpty;
-      this.size = size;
+    if (needToRemoveUnreachableBlocks) {
+      code.removeUnreachableBlocks();
     }
-  }
-
-  private FilledArrayCandidate computeFilledArrayCandidate(
-      Instruction instruction, RewriteArrayOptions options) {
-    NewArrayEmpty newArrayEmpty = instruction.asNewArrayEmpty();
-    if (newArrayEmpty == null) {
-      return null;
-    }
-    if (instruction.getLocalInfo() != null) {
-      return null;
-    }
-    if (!newArrayEmpty.size().isConstant()) {
-      return null;
-    }
-    int size = newArrayEmpty.size().getConstInstruction().asConstNumber().getIntValue();
-    if (!options.isPotentialSize(size)) {
-      return null;
-    }
-    return new FilledArrayCandidate(newArrayEmpty, size);
+    code.removeRedundantBlocks();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java
index e8672b3..160335c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java
@@ -29,6 +29,7 @@
 import com.android.tools.r8.ir.code.Ushr;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.Xor;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.utils.WorkList;
 import com.google.common.collect.ImmutableMap;
@@ -244,7 +245,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return options.testing.enableBinopOptimization
         && !isDebugMode(code.context())
         && code.metadata().mayHaveArithmeticOrLogicalBinop();
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/BranchSimplifier.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/BranchSimplifier.java
index c663705..978a99f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/BranchSimplifier.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/BranchSimplifier.java
@@ -78,7 +78,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return code.metadata().mayHaveIf() || code.metadata().mayHaveSwitch();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/CodeRewriterPass.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/CodeRewriterPass.java
index 73afe6a..98a92e8 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/CodeRewriterPass.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/CodeRewriterPass.java
@@ -50,7 +50,7 @@
       IRCode code,
       MethodProcessor methodProcessor,
       MethodProcessingContext methodProcessingContext) {
-    if (shouldRewriteCode(code)) {
+    if (shouldRewriteCode(code, methodProcessor)) {
       assert verifyConsistentCode(code, isAcceptingSSA(), "before");
       CodeRewriterResult result = rewriteCode(code, methodProcessor, methodProcessingContext);
       assert result.hasChanged().isFalse() || verifyConsistentCode(code, isProducingSSA(), "after");
@@ -100,5 +100,5 @@
     return rewriteCode(code);
   }
 
-  protected abstract boolean shouldRewriteCode(IRCode code);
+  protected abstract boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor);
 }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java
index 4089a9b..3e51706 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.utils.InternalOptions;
 import com.google.common.base.Equivalence;
@@ -35,7 +36,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return true;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/DexConstantOptimizer.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/DexConstantOptimizer.java
index 89b6f2d..9584e8a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/DexConstantOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/DexConstantOptimizer.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.ConstantCanonicalizer;
 import com.android.tools.r8.utils.LazyBox;
@@ -71,7 +72,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return true;
   }
 
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 28a40a5..7c476ff 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
@@ -30,6 +30,7 @@
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 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;
@@ -126,7 +127,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return code.metadata().mayHaveNewArrayFilled();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/KnownArrayLengthRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/KnownArrayLengthRewriter.java
index a9084b1..c8df326 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/KnownArrayLengthRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/KnownArrayLengthRewriter.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import java.util.Set;
 
@@ -28,7 +29,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return code.metadata().mayHaveArrayLength();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/MoveResultRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/MoveResultRewriter.java
index 42c9c91..a7277a8 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/MoveResultRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/MoveResultRewriter.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
 import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
@@ -37,7 +38,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return options.isGeneratingDex() && code.metadata().mayHaveInvokeMethod();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java
index eaa0edb..3096671 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Sub;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
 import com.android.tools.r8.utils.WorkList;
@@ -59,7 +60,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     // This is relevant only if a loop may be present, which implies at least 4 blocks.
     return appView.options().enableLoopUnrolling
         && code.metadata().mayHaveIf()
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/ParentConstructorHoistingCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/ParentConstructorHoistingCodeRewriter.java
index 28b76ae..43d249f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/ParentConstructorHoistingCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/ParentConstructorHoistingCodeRewriter.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.shaking.KeepMethodInfo;
 import com.android.tools.r8.utils.CollectionUtils;
@@ -139,7 +140,7 @@
 
   /** Only run this when the rewriting may actually enable more constructor inlining. */
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     if (!appView.hasClassHierarchy()) {
       return false;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java
index 298a742..f031b5c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ir.code.IfType;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.utils.LazyBox;
 import it.unimi.dsi.fastutil.longs.Long2ReferenceMap;
@@ -51,7 +52,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     if (appView.options().canHaveDalvikIntUsedAsNonIntPrimitiveTypeBug()
         && !appView.options().testing.forceRedundantConstNumberRemoval) {
       // See also b/124152497.
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java
index 7ebed43..c8455fc 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
 import com.android.tools.r8.utils.ListUtils;
@@ -38,7 +39,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     // This is relevant only if there is a diamond followed by an if which is a minimum of 6 blocks.
     return code.metadata().mayHaveIf() && code.getBlocks().size() >= 6;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java
index b9b34ad..3935555 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Throw;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
 import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
@@ -54,7 +55,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return true;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java
index 60ff58e..73fd010 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java
@@ -46,7 +46,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return appView.enableWholeProgramOptimizations()
         && appView.options().testing.enableCheckCastAndInstanceOfRemoval
         && (code.metadata().mayHaveCheckCast() || code.metadata().mayHaveInstanceOf());
@@ -231,7 +231,8 @@
     // type.
     if (castType.isClassType()
         && castType.isAlwaysNull(appViewWithLiveness)
-        && !outValue.hasDebugUsers()) {
+        && !outValue.hasDebugUsers()
+        && !appView.getSyntheticItems().isFinalized()) {
       // Replace all usages of the out-value by null.
       it.previous();
       Value nullValue = it.insertConstNullInstruction(code, options);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialGotosCollapser.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialGotosCollapser.java
index 3ecb8be..c0fb1af 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialGotosCollapser.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialGotosCollapser.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.Switch;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -87,7 +88,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return true;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index 46988a7..e204f8e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -178,9 +178,7 @@
   // Synthesize virtual methods.
   private void synthesizeVirtualMethods(
       SyntheticProgramClassBuilder builder, DesugarInvoke desugarInvoke) {
-    DexMethod mainMethod =
-        appView.dexItemFactory().createMethod(type, descriptor.erasedProto, descriptor.name);
-
+    DexMethod mainMethod = descriptor.getMainMethod().withHolder(type, appView.dexItemFactory());
     List<DexEncodedMethod> methods = new ArrayList<>(1 + descriptor.bridges.size());
 
     // Synthesize main method.
@@ -198,7 +196,7 @@
     // Synthesize bridge methods.
     for (DexProto bridgeProto : descriptor.bridges) {
       DexMethod bridgeMethod =
-          appView.dexItemFactory().createMethod(type, bridgeProto, descriptor.name);
+          appView.dexItemFactory().createMethod(type, bridgeProto, descriptor.getName());
       methods.add(
           DexEncodedMethod.syntheticBuilder()
               .setMethod(bridgeMethod)
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java
index 0c356a2..e3cbc07 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java
@@ -20,6 +20,10 @@
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.UseRegistry.MethodHandleUse;
+import com.android.tools.r8.graph.lens.GraphLens;
+import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
+import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.List;
@@ -39,13 +43,11 @@
 
   final String uniqueId;
   final DexMethod mainMethod;
-  public final DexString name;
-  final DexProto erasedProto;
   final DexProto enforcedProto;
   public final DexMethodHandle implHandle;
 
-  public final List<DexType> interfaces = new ArrayList<>();
-  public final Set<DexProto> bridges = Sets.newIdentityHashSet();
+  public final List<DexType> interfaces;
+  public final Set<DexProto> bridges;
   public final DexTypeList captures;
 
   // Used for accessibility analysis and few assertions only.
@@ -53,21 +55,21 @@
   private final DexType targetHolder;
 
   private LambdaDescriptor() {
-    uniqueId = null;
-    name = null;
-    erasedProto = null;
-    enforcedProto = null;
-    implHandle = null;
-    captures = null;
-    targetAccessFlags = null;
-    targetHolder = null;
-    mainMethod = null;
+    this(null, null, null, null, null, null, null, null, null);
+  }
+
+  public DexProto getErasedProto() {
+    return mainMethod.getProto();
   }
 
   public DexMethod getMainMethod() {
     return mainMethod;
   }
 
+  public DexString getName() {
+    return mainMethod.getName();
+  }
+
   private LambdaDescriptor(
       AppView<?> appView,
       AppInfoWithClassHierarchy appInfo,
@@ -89,12 +91,11 @@
     assert captures != null;
     this.mainMethod = appInfo.dexItemFactory().createMethod(mainInterface, erasedProto, name);
     this.uniqueId = callSite.getHash();
-    this.name = name;
-    this.erasedProto = erasedProto;
     this.enforcedProto = enforcedProto;
     this.implHandle = implHandle;
     this.captures = captures;
-
+    this.bridges = Sets.newIdentityHashSet();
+    this.interfaces = new ArrayList<>();
     this.interfaces.add(mainInterface);
     DexClassAndMethod targetMethod =
         context == null ? null : lookupTargetMethod(appView, appInfo, context);
@@ -107,6 +108,27 @@
     }
   }
 
+  private LambdaDescriptor(
+      String uniqueId,
+      DexMethod mainMethod,
+      DexProto enforcedProto,
+      DexMethodHandle implHandle,
+      List<DexType> interfaces,
+      Set<DexProto> bridges,
+      DexTypeList captures,
+      MethodAccessFlags targetAccessFlags,
+      DexType targetHolder) {
+    this.uniqueId = uniqueId;
+    this.mainMethod = mainMethod;
+    this.enforcedProto = enforcedProto;
+    this.implHandle = implHandle;
+    this.interfaces = interfaces;
+    this.bridges = bridges;
+    this.captures = captures;
+    this.targetAccessFlags = targetAccessFlags;
+    this.targetHolder = targetHolder;
+  }
+
   final DexType getImplReceiverType() {
     // The receiver of instance impl-method is captured as the first captured
     // value or should be the first argument of the enforced method signature.
@@ -179,7 +201,7 @@
     return method.getDefinition().isPublicized() && isInstanceMethod(method);
   }
 
-  public final boolean verifyTargetFoundInClass(DexType type) {
+  public boolean verifyTargetFoundInClass(DexType type) {
     return targetHolder.isIdenticalTo(type);
   }
 
@@ -189,14 +211,15 @@
   }
 
   public void forEachErasedAndEnforcedTypes(BiConsumer<DexType, DexType> consumer) {
-    consumer.accept(erasedProto.returnType, enforcedProto.returnType);
+    DexProto erasedProto = getErasedProto();
+    consumer.accept(erasedProto.getReturnType(), enforcedProto.getReturnType());
     for (int i = 0; i < enforcedProto.getArity(); i++) {
       consumer.accept(erasedProto.getParameter(i), enforcedProto.getParameter(i));
     }
   }
 
   /** Is a stateless lambda, i.e. lambda does not capture any values */
-  final boolean isStateless() {
+  boolean isStateless() {
     return captures.isEmpty();
   }
 
@@ -495,4 +518,32 @@
 
     return false;
   }
+
+  public LambdaDescriptor rewrittenWithLens(
+      GraphLens lens, GraphLens appliedLens, LensCodeRewriterUtils rewriter) {
+    String newUniqueId = uniqueId;
+    DexMethod newMainMethod = lens.getRenamedMethodSignature(mainMethod, appliedLens);
+    DexProto newEnforcedProto = rewriter.rewriteProto(enforcedProto);
+    DexMethodHandle newImplHandle =
+        rewriter.rewriteDexMethodHandle(
+            implHandle, MethodHandleUse.ARGUMENT_TO_LAMBDA_METAFACTORY, mainMethod);
+    List<DexType> newInterfaces =
+        new ArrayList<>(
+            SetUtils.mapLinkedHashSet(interfaces, itf -> lens.lookupType(itf, appliedLens)));
+    Set<DexProto> newBridges = SetUtils.mapIdentityHashSet(bridges, rewriter::rewriteProto);
+    DexTypeList newCaptures = captures.map(capture -> lens.lookupType(capture, appliedLens));
+    MethodAccessFlags newTargetAccessFlags = targetAccessFlags;
+    DexType newTargetHolder =
+        targetHolder != null ? lens.lookupType(targetHolder, appliedLens) : null;
+    return new LambdaDescriptor(
+        newUniqueId,
+        newMainMethod,
+        newEnforcedProto,
+        newImplHandle,
+        newInterfaces,
+        newBridges,
+        newCaptures,
+        newTargetAccessFlags,
+        newTargetHolder);
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
index df5b8b4..44f0307 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
@@ -24,6 +24,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.ir.code.InvokeType;
 import com.android.tools.r8.ir.code.NumericType;
 import com.android.tools.r8.ir.code.ValueType;
@@ -181,8 +182,8 @@
 
     DexMethod methodToCall = target.callTarget;
     DexType[] capturedTypes = lambda.descriptor.captures.values;
-    DexType[] erasedParams = lambda.descriptor.erasedProto.parameters.values;
-    DexType erasedReturnType = lambda.descriptor.erasedProto.returnType;
+    DexTypeList erasedParams = lambda.descriptor.getErasedProto().getParameters();
+    DexType erasedReturnType = lambda.descriptor.getErasedProto().getReturnType();
     DexType[] enforcedParams = lambda.descriptor.enforcedProto.parameters.values;
     DexType enforcedReturnType = lambda.descriptor.enforcedProto.returnType;
     if (enforcedReturnType.isPrimitiveType() && mainMethod.getReturnType().isReferenceType()) {
@@ -244,14 +245,14 @@
 
     // Prepare arguments.
     int maxLocals = 1; // Local 0 is the lambda/receiver.
-    for (int i = 0; i < erasedParams.length; i++) {
+    for (int i = 0; i < erasedParams.size(); i++) {
       ValueType valueType = ValueType.fromDexType(mainMethod.getParameters().values[i]);
       instructions.add(new CfLoad(valueType, maxLocals));
       maxLocals += valueType.requiredRegisters();
       DexType expectedParamType = implReceiverAndArgs.get(i + capturedValues);
       maxStack +=
           prepareParameterValue(
-              erasedParams[i], enforcedParams[i], expectedParamType, instructions, factory);
+              erasedParams.get(i), enforcedParams[i], expectedParamType, instructions, factory);
     }
 
     CfInvoke invoke =
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
index 064c4b2..1a6c122 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
@@ -40,6 +40,7 @@
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.StaticPut;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.RedundantFieldLoadAndStoreElimination.RedundantFieldLoadAndStoreEliminationOnCode.ExistingValue;
@@ -83,7 +84,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return appView.options().enableRedundantFieldLoadElimination
         && (code.metadata().mayHaveArrayGet()
             || code.metadata().mayHaveFieldInstruction()
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/api/InstanceInitializerOutliner.java b/src/main/java/com/android/tools/r8/ir/optimize/api/InstanceInitializerOutliner.java
index 2a90c2e..a9dfc03 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/api/InstanceInitializerOutliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/api/InstanceInitializerOutliner.java
@@ -8,6 +8,7 @@
 
 import com.android.tools.r8.androidapi.ComputedApiLevel;
 import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -16,7 +17,6 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
@@ -29,13 +29,14 @@
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.MethodProcessor;
-import com.android.tools.r8.ir.conversion.PostMethodProcessor;
-import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
+import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
+import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
+import com.android.tools.r8.ir.optimize.info.DefaultMethodOptimizationInfo;
 import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
 import com.android.tools.r8.ir.synthetic.NewInstanceSourceCode;
 import com.android.tools.r8.shaking.ComputeApiLevelUseRegistry;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.google.common.collect.Sets;
-import java.util.ArrayList;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -46,32 +47,21 @@
  * Unlike the ApiInvokeOutlinerDesugaring that works on CF, this works on IR to properly replace the
  * users of the NewInstance call.
  */
-public class InstanceInitializerOutliner {
+public class InstanceInitializerOutliner extends CodeRewriterPass<AppInfo> {
 
-  private final AppView<?> appView;
   private final DexItemFactory factory;
 
-  private final List<ProgramMethod> synthesizedMethods = new ArrayList<>();
-
   public InstanceInitializerOutliner(AppView<?> appView) {
-    this.appView = appView;
+    super(appView);
     this.factory = appView.dexItemFactory();
   }
 
-  public List<ProgramMethod> getSynthesizedMethods() {
-    return synthesizedMethods;
-  }
-
-  public void rewriteInstanceInitializers(
+  @Override
+  protected CodeRewriterResult rewriteCode(
       IRCode code,
-      ProgramMethod context,
       MethodProcessor methodProcessor,
       MethodProcessingContext methodProcessingContext) {
     assert !methodProcessor.isPostMethodProcessor();
-    // Do not outline from already synthesized methods.
-    if (context.getDefinition().isD8R8Synthesized()) {
-      return;
-    }
     Map<NewInstance, Value> rewrittenNewInstances = new IdentityHashMap<>();
     ComputedApiLevel minApiLevel = appView.computedMinApiLevel();
     InstructionListIterator iterator = code.instructionListIterator();
@@ -104,7 +94,7 @@
         continue;
       }
       // Check if this is already outlined.
-      if (isOutlinedAtSameOrLowerLevel(context.getHolder(), apiReferenceLevel)) {
+      if (isOutlinedAtSameOrLowerLevel(code.context().getHolder(), apiReferenceLevel)) {
         continue;
       }
       DexEncodedMethod synthesizedInstanceInitializer =
@@ -125,7 +115,7 @@
       rewrittenNewInstances.put(newInstance, outlinedMethodInvoke.outValue());
     }
     if (rewrittenNewInstances.isEmpty()) {
-      return;
+      return CodeRewriterResult.NO_CHANGE;
     }
     // Scan over NewInstance calls that needs to be outlined. We insert a call to a synthetic method
     // with a NewInstance to preserve class-init semantics.
@@ -173,14 +163,10 @@
     // the outline again in R8 - but allow inlining of other calls to min api level methods, we have
     // to recompute the api level.
     if (appView.enableWholeProgramOptimizations()) {
-      recomputeApiLevel(context, code);
+      recomputeApiLevel(code.context(), code);
     }
 
-    assert code.isConsistentSSA(appView);
-  }
-
-  public void onLastWaveDone(PostMethodProcessor.Builder postMethodProcessorBuilder) {
-    postMethodProcessorBuilder.addAll(synthesizedMethods, appView.graphLens());
+    return CodeRewriterResult.HAS_CHANGED;
   }
 
   private boolean canSkipClInit(
@@ -249,9 +235,7 @@
     methodProcessor
         .getEventConsumer()
         .acceptInstanceInitializerOutline(method, methodProcessingContext.getMethodContext());
-    synchronized (synthesizedMethods) {
-      synthesizedMethods.add(method);
-    }
+    methodProcessor.scheduleDesugaredMethodForProcessing(method);
     return method.getDefinition();
   }
 
@@ -271,31 +255,56 @@
                 kinds -> kinds.API_MODEL_OUTLINE,
                 methodProcessingContext.createUniqueContext(),
                 appView,
-                builder ->
-                    builder
-                        .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
-                        .setProto(proto)
-                        .setApiLevelForDefinition(appView.computedMinApiLevel())
-                        .setApiLevelForCode(computedApiLevel)
-                        .setCode(
-                            m ->
-                                ForwardMethodBuilder.builder(appView.dexItemFactory())
-                                    .setConstructorTargetWithNewInstance(targetMethod)
-                                    .setStaticSource(m)
-                                    .build()));
+                builder -> {
+                  DynamicType exactDynamicReturnType =
+                      DynamicType.createExact(
+                          targetMethod
+                              .getHolderType()
+                              .toTypeElement(appView, Nullability.definitelyNotNull())
+                              .asClassType());
+                  builder
+                      .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+                      .setProto(proto)
+                      .setApiLevelForDefinition(appView.computedMinApiLevel())
+                      .setApiLevelForCode(computedApiLevel)
+                      .setCode(
+                          m ->
+                              ForwardMethodBuilder.builder(appView.dexItemFactory())
+                                  .setConstructorTargetWithNewInstance(targetMethod)
+                                  .setStaticSource(m)
+                                  .build())
+                      .setOptimizationInfo(
+                          DefaultMethodOptimizationInfo.getInstance()
+                              .toMutableOptimizationInfo()
+                              .setDynamicType(exactDynamicReturnType));
+                });
     methodProcessor
         .getEventConsumer()
         .acceptInstanceInitializerOutline(method, methodProcessingContext.getMethodContext());
-    synchronized (synthesizedMethods) {
-      synthesizedMethods.add(method);
-      ClassTypeElement exactType =
-          targetMethod
-              .getHolderType()
-              .toTypeElement(appView, Nullability.definitelyNotNull())
-              .asClassType();
-      OptimizationFeedback.getSimpleFeedback()
-          .setDynamicReturnType(method, appView, DynamicType.createExact(exactType));
-    }
+    methodProcessor.scheduleDesugaredMethodForProcessing(method);
     return method.getDefinition();
   }
+
+  @Override
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
+    if (!appView.options().desugarState.isOn()
+        || !appView.options().apiModelingOptions().enableOutliningOfMethods
+        || !appView.options().getMinApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L)) {
+      return false;
+    }
+    // Only outline in primary optimization pass.
+    if (!methodProcessor.isD8MethodProcessor() && !methodProcessor.isPrimaryMethodProcessor()) {
+      return false;
+    }
+    // Do not outline from already synthesized methods.
+    if (code.context().getDefinition().isD8R8Synthesized()) {
+      return false;
+    }
+    return true;
+  }
+
+  @Override
+  protected String getRewriterId() {
+    return "InstanceInitializerOutliner";
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java
index 814bb26..9f3a782 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
@@ -186,7 +187,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     if (!options.enableEnumValueOptimization || !appView.hasLiveness()) {
       return false;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
index ea5f65d..36c1bce 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
@@ -122,7 +122,6 @@
 
   @Override
   public int getReturnedArgument() {
-    assert returnsArgument();
     return UNKNOWN_RETURNED_ARGUMENT;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index 47f2e03..9b9b529 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -919,6 +919,7 @@
         feedback.classInitializerMayBePostponed(method);
       } else {
         assert options.debug
+                || appView.getSyntheticItems().isFinalized()
                 || appView
                     .getSyntheticItems()
                     .verifySyntheticLambdaProperty(
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
index 9617c85..6c7a777 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
@@ -84,6 +84,10 @@
         abstractValue.rewrittenWithLens(appView, field.getType(), lens, codeLens), field);
   }
 
+  public void unsetAbstractValue() {
+    abstractValue = AbstractValue.unknown();
+  }
+
   @Override
   public int getReadBits() {
     return readBits;
@@ -111,6 +115,10 @@
     this.dynamicType = dynamicType;
   }
 
+  public void unsetDynamicType() {
+    setDynamicType(DynamicType.unknown());
+  }
+
   @Override
   public boolean isDead() {
     return (flags & FLAGS_IS_DEAD) != 0;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java
index 602b555..300c8c0 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java
@@ -33,7 +33,6 @@
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OptionalBool;
 import java.util.BitSet;
-import java.util.Collections;
 import java.util.Set;
 
 public class MutableMethodOptimizationInfo extends MethodOptimizationInfo
@@ -297,6 +296,10 @@
     return this;
   }
 
+  public void unsetArgumentInfos() {
+    argumentInfos = CallSiteOptimizationInfo.top();
+  }
+
   @Override
   public ClassInlinerMethodConstraint getClassInlinerMethodConstraint() {
     return classInlinerConstraint;
@@ -630,11 +633,16 @@
   }
 
   void markInitializesClassesOnNormalExit(Set<DexType> initializedClassesOnNormalExit) {
-    this.initializedClassesOnNormalExit = initializedClassesOnNormalExit;
+    if (initializedClassesOnNormalExit.isEmpty()) {
+      unsetInitializedClassesOnNormalExit();
+    } else {
+      this.initializedClassesOnNormalExit = initializedClassesOnNormalExit;
+    }
   }
 
   void unsetInitializedClassesOnNormalExit() {
-    initializedClassesOnNormalExit = Collections.emptySet();
+    initializedClassesOnNormalExit =
+        DefaultMethodOptimizationInfo.getInstance().getInitializedClassesOnNormalExit();
   }
 
   void markReturnsArgument(int returnedArgumentIndex) {
@@ -710,7 +718,7 @@
     setDynamicType(newDynamicType);
   }
 
-  private MutableMethodOptimizationInfo setDynamicType(DynamicType dynamicType) {
+  public MutableMethodOptimizationInfo setDynamicType(DynamicType dynamicType) {
     assert !dynamicType.hasDynamicUpperBoundType()
         || !dynamicType.asDynamicTypeWithUpperBound().getDynamicUpperBoundType().isPrimitiveType();
     this.dynamicType = dynamicType;
@@ -767,6 +775,30 @@
     return isFlagSet(RETURN_VALUE_HAS_BEEN_PROPAGATED_FLAG);
   }
 
+  @SuppressWarnings("ReferenceEquality")
+  public boolean isEffectivelyDefault() {
+    DefaultMethodOptimizationInfo top = DefaultMethodOptimizationInfo.getInstance();
+    return argumentInfos == top.getArgumentInfos()
+        && initializedClassesOnNormalExit == top.getInitializedClassesOnNormalExit()
+        && returnedArgument == top.getReturnedArgument()
+        && abstractReturnValue == top.getAbstractReturnValue()
+        && classInlinerConstraint == top.getClassInlinerMethodConstraint()
+        && convertCheckNotNull == top.isConvertCheckNotNull()
+        && enumUnboxerMethodClassification == top.getEnumUnboxerMethodClassification()
+        && dynamicType == top.getDynamicType()
+        && inlining == InlinePreference.Default
+        && isReturnValueUsed == top.isReturnValueUsed()
+        && bridgeInfo == top.getBridgeInfo()
+        && instanceInitializerInfoCollection.isEmpty()
+        && nonNullParamOrThrow == top.getNonNullParamOrThrow()
+        && nonNullParamOnNormalExits == top.getNonNullParamOnNormalExits()
+        && simpleInliningConstraint == top.getSimpleInliningConstraint()
+        && maxRemovedAndroidLogLevel == top.getMaxRemovedAndroidLogLevel()
+        && parametersWithBitwiseOperations == top.getParametersWithBitwiseOperations()
+        && unusedArguments == top.getUnusedArguments()
+        && flags == DEFAULT_FLAGS;
+  }
+
   @Override
   public boolean isMutableOptimizationInfo() {
     return true;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationInfoRemover.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationInfoRemover.java
new file mode 100644
index 0000000..a336a3d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationInfoRemover.java
@@ -0,0 +1,66 @@
+// 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.info;
+
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.utils.ThreadUtils;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * Clears any optimization info on fields and methods that need lens code rewriting. This avoids the
+ * need to lens code rewrite such optimization info in repackaging and other optimizations where the
+ * optimization info is mostly unused, since no more optimizations passes will be run.
+ */
+public class OptimizationInfoRemover {
+
+  public static void run(
+      AppView<? extends AppInfoWithClassHierarchy> appView, ExecutorService executorService)
+      throws ExecutionException {
+    ThreadUtils.processItems(
+        appView.appInfo().classes(),
+        OptimizationInfoRemover::processClass,
+        appView.options().getThreadingModule(),
+        executorService);
+  }
+
+  private static void processClass(DexProgramClass clazz) {
+    for (DexEncodedField field : clazz.fields()) {
+      processField(field);
+    }
+    for (DexEncodedMethod method : clazz.methods()) {
+      processMethod(method);
+    }
+  }
+
+  private static void processField(DexEncodedField field) {
+    MutableFieldOptimizationInfo optimizationInfo =
+        field.getOptimizationInfo().asMutableFieldOptimizationInfo();
+    if (optimizationInfo == null) {
+      return;
+    }
+    optimizationInfo.unsetAbstractValue();
+    optimizationInfo.unsetDynamicType();
+  }
+
+  private static void processMethod(DexEncodedMethod method) {
+    MutableMethodOptimizationInfo optimizationInfo =
+        method.getOptimizationInfo().asMutableMethodOptimizationInfo();
+    if (optimizationInfo == null) {
+      return;
+    }
+    optimizationInfo.unsetAbstractReturnValue();
+    optimizationInfo.unsetArgumentInfos();
+    optimizationInfo.unsetDynamicType();
+    optimizationInfo.unsetInitializedClassesOnNormalExit();
+    optimizationInfo.unsetInstanceInitializerInfoCollection();
+    if (optimizationInfo.isEffectivelyDefault()) {
+      method.unsetOptimizationInfo();
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java
index bc16337..eb0aa0d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
@@ -95,7 +96,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return options.enableStringConcatenationOptimization
         && !isDebugMode(code.context())
         && (code.metadata().mayHaveNewInstance()
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
index 3eeaae6..ad4c24f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.optimize.AffectedValues;
@@ -52,7 +53,7 @@
   }
 
   @Override
-  protected boolean shouldRewriteCode(IRCode code) {
+  protected boolean shouldRewriteCode(IRCode code, MethodProcessor methodProcessor) {
     return !isDebugMode(code.context());
   }
 
diff --git a/src/main/java/com/android/tools/r8/lightir/LirCode.java b/src/main/java/com/android/tools/r8/lightir/LirCode.java
index 056b7fa..29c7ca6 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirCode.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirCode.java
@@ -36,6 +36,7 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.ArrayUtils;
 import com.android.tools.r8.utils.ComparatorUtils;
+import com.android.tools.r8.utils.FastMapUtils;
 import com.android.tools.r8.utils.IntBox;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.RetracerForCodePrinting;
@@ -200,6 +201,15 @@
       return TryCatchTable::specify;
     }
 
+    public TryCatchTable rewriteWithLens(GraphLens graphLens, GraphLens codeLens) {
+      Int2ReferenceMap<CatchHandlers<Integer>> newTryCatchHandlers =
+          FastMapUtils.mapInt2ReferenceOpenHashMapOrElse(
+              tryCatchHandlers,
+              (block, blockHandlers) -> blockHandlers.rewriteWithLens(graphLens, codeLens),
+              null);
+      return newTryCatchHandlers != null ? new TryCatchTable(newTryCatchHandlers) : this;
+    }
+
     private static void specify(StructuralSpecification<TryCatchTable, ?> spec) {
       spec.withInt2CustomItemMap(
           s -> s.tryCatchHandlers,
@@ -774,6 +784,24 @@
         metadataMap);
   }
 
+  public LirCode<EV> newCodeWithRewrittenTryCatchTable(TryCatchTable rewrittenTryCatchTable) {
+    if (rewrittenTryCatchTable == tryCatchTable) {
+      return this;
+    }
+    return new LirCode<>(
+        irMetadata,
+        constants,
+        positionTable,
+        argumentCount,
+        instructions,
+        instructionCount,
+        rewrittenTryCatchTable,
+        debugLocalInfoTable,
+        strategyInfo,
+        useDexEstimationStrategy,
+        metadataMap);
+  }
+
   public LirCode<EV> rewriteWithSimpleLens(
       ProgramMethod context, AppView<?> appView, LensCodeRewriterUtils rewriterUtils) {
     GraphLens graphLens = appView.graphLens();
diff --git a/src/main/java/com/android/tools/r8/lightir/SimpleLensLirRewriter.java b/src/main/java/com/android/tools/r8/lightir/SimpleLensLirRewriter.java
index d093823..1a4d065 100644
--- a/src/main/java/com/android/tools/r8/lightir/SimpleLensLirRewriter.java
+++ b/src/main/java/com/android/tools/r8/lightir/SimpleLensLirRewriter.java
@@ -4,10 +4,13 @@
 
 package com.android.tools.r8.lightir;
 
+import static com.android.tools.r8.graph.UseRegistry.MethodHandleUse.NOT_ARGUMENT_TO_LAMBDA_METAFACTORY;
+
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexMethodHandle;
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
@@ -17,6 +20,8 @@
 import com.android.tools.r8.ir.code.InvokeType;
 import com.android.tools.r8.ir.code.Opcodes;
 import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
+import com.android.tools.r8.lightir.LirBuilder.RecordFieldValuesPayload;
+import com.android.tools.r8.lightir.LirCode.TryCatchTable;
 import com.android.tools.r8.utils.ArrayUtils;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
@@ -68,6 +73,12 @@
     addRewrittenMapping(callSite, helper.rewriteCallSite(callSite, context));
   }
 
+  public void onMethodHandleReference(DexMethodHandle methodHandle) {
+    addRewrittenMapping(
+        methodHandle,
+        helper.rewriteDexMethodHandle(methodHandle, NOT_ARGUMENT_TO_LAMBDA_METAFACTORY, context));
+  }
+
   public void onProtoReference(DexProto proto) {
     addRewrittenMapping(proto, helper.rewriteProto(proto));
   }
@@ -143,7 +154,8 @@
 
   public LirCode<EV> rewrite() {
     LirCode<EV> rewritten = rewriteConstantPoolAndScanForTypeChanges(getCode());
-    return rewriteInstructionsWithInvokeTypeChanges(rewritten);
+    rewritten = rewriteInstructionsWithInvokeTypeChanges(rewritten);
+    return rewriteTryCatchTable(rewritten);
   }
 
   private LirCode<EV> rewriteConstantPoolAndScanForTypeChanges(LirCode<EV> code) {
@@ -152,12 +164,16 @@
     // fields/methods that need to be examined.
     boolean hasPotentialRewrittenMethod = false;
     for (LirConstant constant : code.getConstantPool()) {
+      // RecordFieldValuesPayload is lowered to NewArrayEmpty before lens code rewriting any LIR.
+      assert !(constant instanceof RecordFieldValuesPayload);
       if (constant instanceof DexType) {
         onTypeReference((DexType) constant);
       } else if (constant instanceof DexField) {
         onFieldReference((DexField) constant);
       } else if (constant instanceof DexCallSite) {
         onCallSiteReference((DexCallSite) constant);
+      } else if (constant instanceof DexMethodHandle) {
+        onMethodHandleReference((DexMethodHandle) constant);
       } else if (constant instanceof DexProto) {
         onProtoReference((DexProto) constant);
       } else if (!hasPotentialRewrittenMethod && constant instanceof DexMethod) {
@@ -265,4 +281,13 @@
             byteWriter.toByteArray());
     return newCode;
   }
+
+  private LirCode<EV> rewriteTryCatchTable(LirCode<EV> code) {
+    TryCatchTable tryCatchTable = code.getTryCatchTable();
+    if (tryCatchTable == null) {
+      return code;
+    }
+    TryCatchTable newTryCatchTable = tryCatchTable.rewriteWithLens(graphLens, codeLens);
+    return code.newCodeWithRewrittenTryCatchTable(newTryCatchTable);
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java b/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java
index 7e91d18..9e966d0 100644
--- a/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java
+++ b/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java
@@ -116,5 +116,6 @@
         },
         appView.options().getThreadingModule(),
         executorService);
+    appView.setGenericSignaturesLens(appView.graphLens());
   }
 }
diff --git a/src/main/java/com/android/tools/r8/repackaging/Repackaging.java b/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
index 3d6fc32..5272500 100644
--- a/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
+++ b/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
@@ -24,6 +24,7 @@
 import com.android.tools.r8.graph.fixup.TreeFixerBase;
 import com.android.tools.r8.graph.lens.NestedGraphLens;
 import com.android.tools.r8.naming.Minifier.MinificationPackageNamingStrategy;
+import com.android.tools.r8.naming.signature.GenericSignatureRewriter;
 import com.android.tools.r8.repackaging.RepackagingLens.Builder;
 import com.android.tools.r8.shaking.AnnotationFixer;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -78,6 +79,7 @@
     if (lens != null) {
       appView.rewriteWithLensAndApplication(lens, appBuilder.build(), executorService, timing);
       appView.testing().repackagingLensConsumer.accept(appView.dexItemFactory(), lens);
+      new GenericSignatureRewriter(appView).run(appView.appInfo().classes(), executorService);
     }
     appView.notifyOptimizationFinishedForTesting();
     timing.end();
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index 93ac4f4..e634f97 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.Definition;
+import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndField;
@@ -316,8 +317,8 @@
         pruneMethods(previous.bootstrapMethods, prunedItems, tasks),
         pruneMethods(previous.virtualMethodsTargetedByInvokeDirect, prunedItems, tasks),
         pruneMethods(previous.liveMethods, prunedItems, tasks),
-        previous.fieldAccessInfoCollection,
-        previous.methodAccessInfoCollection.withoutPrunedItems(prunedItems),
+        previous.fieldAccessInfoCollection.withoutPrunedItems(prunedItems),
+        previous.methodAccessInfoCollection.withoutPrunedContexts(prunedItems),
         previous.objectAllocationInfoCollection.withoutPrunedItems(prunedItems),
         pruneCallSites(previous.callSites, prunedItems),
         extendPinnedItems(previous, prunedItems.getAdditionalPinnedItems()),
@@ -1090,12 +1091,19 @@
     return appInfoWithLiveness;
   }
 
+  public AppInfoWithLiveness rebuildWithLiveness(DexApplication application) {
+    return rebuildWithLiveness(getSyntheticItems().commit(application));
+  }
+
   public AppInfoWithLiveness rebuildWithLiveness(CommittedItems committedItems) {
     return new AppInfoWithLiveness(this, committedItems);
   }
 
   public AppInfoWithLiveness rewrittenWithLens(
-      DirectMappedDexApplication application, NonIdentityGraphLens lens, Timing timing) {
+      DirectMappedDexApplication application,
+      NonIdentityGraphLens lens,
+      GraphLens appliedLens,
+      Timing timing) {
     assert checkIfObsolete();
 
     // Switchmap classes should never be affected by renaming.
@@ -1126,7 +1134,8 @@
         lens.rewriteReferences(liveMethods),
         fieldAccessInfoCollection.rewrittenWithLens(definitionSupplier, lens, timing),
         methodAccessInfoCollection.rewrittenWithLens(definitionSupplier, lens, timing),
-        objectAllocationInfoCollection.rewrittenWithLens(definitionSupplier, lens, timing),
+        objectAllocationInfoCollection.rewrittenWithLens(
+            definitionSupplier, lens, appliedLens, timing),
         lens.rewriteCallSites(callSites, definitionSupplier, timing),
         keepInfo.rewrite(definitionSupplier, lens, application.options, timing),
         // Take any rule in case of collisions.
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
index f0080f3..dc0a4ac 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
@@ -84,9 +84,11 @@
       return hasher.hash();
     }
     if (intermediate) {
-      // If in intermediate mode, include the context type as sharing is restricted to within a
-      // single context.
-      getContext().getSynthesizingContextType().hashWithTypeEquivalence(hasher, map);
+      // If in intermediate mode, include the *input* context type to restrict sharing.
+      // This restricts sharing to only allow sharing the synthetics with the same *input* context.
+      // If the synthetic is itself an input from a previous compilation it is restricted to share
+      // within its own context only. The input context should not be mapped to an equivalence type.
+      getContext().getSynthesizingInputContext(intermediate).hash(hasher);
     }
     hasher.putInt(context.getFeatureSplit().hashCode());
     internalComputeHash(hasher, map);
@@ -103,7 +105,6 @@
     return compareTo(other, includeContext, graphLens, classToFeatureSplitMap) == 0;
   }
 
-  @SuppressWarnings("ReferenceEquality")
   int compareTo(
       D other,
       boolean includeContext,
@@ -138,10 +139,12 @@
     if (graphLens.isNonIdentityLens()) {
       DexType thisOrigType = graphLens.getOriginalType(thisType);
       DexType otherOrigType = graphLens.getOriginalType(otherType);
-      if (thisType != thisOrigType || otherType != otherOrigType) {
+      if (thisType.isNotIdenticalTo(thisOrigType) || otherType.isNotIdenticalTo(otherOrigType)) {
         map =
             t -> {
-              if (t == otherType || t == thisOrigType || t == otherOrigType) {
+              if (DexType.identical(t, otherType)
+                  || DexType.identical(t, thisOrigType)
+                  || DexType.identical(t, otherOrigType)) {
                 return thisType;
               }
               return t;
@@ -149,7 +152,7 @@
       }
     }
     if (map == null) {
-      map = t -> t == otherType ? thisType : t;
+      map = t -> otherType.isIdenticalTo(t) ? thisType : t;
     }
     return internalCompareTo(other, map);
   }
diff --git a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
index 8b3a049..1c83db6 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
@@ -512,7 +512,7 @@
                     }
                     for (DexProto bridgeProto : descriptor.bridges) {
                       DexEncodedMethod bridgeMethod =
-                          interfaceDefinition.lookupMethod(bridgeProto, descriptor.name);
+                          interfaceDefinition.lookupMethod(bridgeProto, descriptor.getName());
                       if (bridgeMethod != null) {
                         registerInvokeInterface(bridgeMethod.getReference());
                       }
diff --git a/src/main/java/com/android/tools/r8/utils/DominatorChecker.java b/src/main/java/com/android/tools/r8/utils/DominatorChecker.java
index c2fd047..d1dc853 100644
--- a/src/main/java/com/android/tools/r8/utils/DominatorChecker.java
+++ b/src/main/java/com/android/tools/r8/utils/DominatorChecker.java
@@ -5,7 +5,6 @@
 
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.google.common.collect.Sets;
-import java.util.ArrayDeque;
 import java.util.Collections;
 import java.util.Set;
 
@@ -32,20 +31,20 @@
   }
 
   class TraversingDominatorChecker implements DominatorChecker {
-    private final BasicBlock sourceBlock;
-    private final BasicBlock destBlock;
+    private final BasicBlock subgraphEntryBlock;
+    private final BasicBlock subgraphExitBlock;
     private final Set<BasicBlock> knownDominators;
-    private final ArrayDeque<BasicBlock> workQueue = new ArrayDeque<>();
-    private final Set<BasicBlock> visited;
+    private final WorkList<BasicBlock> workList = WorkList.newIdentityWorkList();
     private BasicBlock prevTargetBlock;
 
     private TraversingDominatorChecker(
-        BasicBlock sourceBlock, BasicBlock destBlock, Set<BasicBlock> knownDominators) {
-      this.sourceBlock = sourceBlock;
-      this.destBlock = destBlock;
+        BasicBlock subgraphEntryBlock,
+        BasicBlock subgraphExitBlock,
+        Set<BasicBlock> knownDominators) {
+      this.subgraphEntryBlock = subgraphEntryBlock;
+      this.subgraphExitBlock = subgraphExitBlock;
       this.knownDominators = knownDominators;
-      this.visited = Sets.newIdentityHashSet();
-      prevTargetBlock = destBlock;
+      prevTargetBlock = subgraphExitBlock;
     }
 
     @Override
@@ -60,7 +59,7 @@
       if (firstSplittingBlock.hasUniqueSuccessor()) {
         do {
           // knownDominators prevents firstSplittingBlock from being destBlock.
-          assert firstSplittingBlock != destBlock;
+          assert firstSplittingBlock != subgraphExitBlock;
           firstSplittingBlock = firstSplittingBlock.getUniqueSuccessor();
         } while (firstSplittingBlock.hasUniqueSuccessor());
 
@@ -73,13 +72,12 @@
       boolean ret;
       // Since we know the previously checked block is a dominator, narrow the check by using it for
       // either sourceBlock or destBlock.
-      if (visited.contains(targetBlock)) {
-        visited.clear();
-        ret =
-            checkWithTraversal(prevTargetBlock, destBlock, firstSplittingBlock, visited, workQueue);
+      if (workList.isSeen(targetBlock)) {
+        workList.clearSeen();
+        ret = checkWithTraversal(prevTargetBlock, subgraphExitBlock, firstSplittingBlock, workList);
         prevTargetBlock = firstSplittingBlock;
       } else {
-        ret = checkWithTraversal(sourceBlock, prevTargetBlock, targetBlock, visited, workQueue);
+        ret = checkWithTraversal(subgraphEntryBlock, prevTargetBlock, targetBlock, workList);
         prevTargetBlock = targetBlock;
       }
       if (ret) {
@@ -93,70 +91,71 @@
       return ret;
     }
 
+    /**
+     * Within the subgraph defined by the given entry/exit blocks, returns whether targetBlock
+     * dominates the exit block.
+     */
     private static boolean checkWithTraversal(
-        BasicBlock sourceBlock,
-        BasicBlock destBlock,
+        BasicBlock subgraphEntryBlock,
+        BasicBlock subgraphExitBlock,
         BasicBlock targetBlock,
-        Set<BasicBlock> visited,
-        ArrayDeque<BasicBlock> workQueue) {
-      assert workQueue.isEmpty();
+        WorkList<BasicBlock> workList) {
+      assert workList.isEmpty();
 
-      visited.add(targetBlock);
-
-      workQueue.addAll(destBlock.getPredecessors());
-      do {
-        BasicBlock curBlock = workQueue.removeLast();
-        if (!visited.add(curBlock)) {
-          continue;
-        }
-        if (curBlock == sourceBlock) {
-          // There is a path from sourceBlock -> destBlock that does not go through block.
+      workList.markAsSeen(targetBlock);
+      workList.addIfNotSeen(subgraphExitBlock.getPredecessors());
+      while (!workList.isEmpty()) {
+        BasicBlock curBlock = workList.removeLast();
+        if (curBlock == subgraphEntryBlock) {
+          // There is a path from subgraphExitBlock -> subgraphEntryBlock that does not go through
+          // targetBlock.
           return false;
         }
-        assert !curBlock.isEntry() : "sourceBlock did not dominate destBlock";
-        workQueue.addAll(curBlock.getPredecessors());
-      } while (!workQueue.isEmpty());
+        assert !curBlock.isEntry() : "subgraphEntryBlock did not dominate subgraphExitBlock";
+        workList.addIfNotSeen(curBlock.getPredecessors());
+      }
 
       return true;
     }
   }
 
-  static DominatorChecker create(BasicBlock sourceBlock, BasicBlock destBlock) {
+  static DominatorChecker create(BasicBlock subgraphEntryBlock, BasicBlock subgraphExitBlock) {
     // Fast-path: blocks are the same.
     // As of Nov 2023: in Chrome for String.format() optimization, this covers 77% of cases.
-    if (sourceBlock == destBlock) {
-      return new PrecomputedDominatorChecker(Collections.singleton(sourceBlock));
+    if (subgraphEntryBlock == subgraphExitBlock) {
+      return new PrecomputedDominatorChecker(Collections.singleton(subgraphEntryBlock));
     }
 
-    // Shrink the subgraph by moving sourceBlock forward to the first block with multiple
+    // Shrink the subgraph by moving subgraphEntryBlock forward to the first block with multiple
     // successors.
     Set<BasicBlock> headAndTailDominators = Sets.newIdentityHashSet();
-    headAndTailDominators.add(sourceBlock);
-    while (sourceBlock.hasUniqueSuccessor()) {
-      sourceBlock = sourceBlock.getUniqueSuccessor();
-      if (!headAndTailDominators.add(sourceBlock)) {
+    headAndTailDominators.add(subgraphEntryBlock);
+    while (subgraphEntryBlock.hasUniqueSuccessor()) {
+      subgraphEntryBlock = subgraphEntryBlock.getUniqueSuccessor();
+      if (!headAndTailDominators.add(subgraphEntryBlock)) {
         // Hit an infinite loop. Code would not verify in this case.
         assert false;
         return FALSE_CHECKER;
       }
-      if (sourceBlock == destBlock) {
+      if (subgraphEntryBlock == subgraphExitBlock) {
         // As of Nov 2023: in Chrome for String.format() optimization, a linear path from
         // source->dest was 14% of cases.
         return new PrecomputedDominatorChecker(headAndTailDominators);
       }
     }
-    if (sourceBlock.getSuccessors().isEmpty()) {
+    if (subgraphEntryBlock.getSuccessors().isEmpty()) {
       return FALSE_CHECKER;
     }
 
-    // Shrink the subgraph by moving destBlock back to the first block with multiple predecessors.
-    headAndTailDominators.add(destBlock);
-    while (destBlock.hasUniquePredecessor()) {
-      destBlock = destBlock.getUniquePredecessor();
-      if (!headAndTailDominators.add(destBlock)) {
-        if (sourceBlock == destBlock) {
-          // This normally happens when moving sourceBlock forwards, but when moving destBlock
-          // backwards when sourceBlock has multiple successors.
+    // Shrink the subgraph by moving subgraphExitBlock back to the first block with multiple
+    // predecessors.
+    headAndTailDominators.add(subgraphExitBlock);
+    while (subgraphExitBlock.hasUniquePredecessor()) {
+      subgraphExitBlock = subgraphExitBlock.getUniquePredecessor();
+      if (!headAndTailDominators.add(subgraphExitBlock)) {
+        if (subgraphEntryBlock == subgraphExitBlock) {
+          // This normally happens when moving subgraphEntryBlock forwards, but can also occur when
+          // moving subgraphExitBlock backwards when subgraphEntryBlock has multiple successors.
           return new PrecomputedDominatorChecker(headAndTailDominators);
         }
         // Hit an infinite loop. Code would not verify in this case.
@@ -165,10 +164,28 @@
       }
     }
 
-    if (destBlock.isEntry()) {
+    if (subgraphExitBlock.isEntry()) {
       return FALSE_CHECKER;
     }
 
-    return new TraversingDominatorChecker(sourceBlock, destBlock, headAndTailDominators);
+    return new TraversingDominatorChecker(
+        subgraphEntryBlock, subgraphExitBlock, headAndTailDominators);
+  }
+
+  /**
+   * Returns whether targetBlock dominates subgraphExitBlock by performing a depth-first traversal
+   * from subgraphExitBlock to subgraphEntryBlock with targetBlock removed from the graph.
+   */
+  @SuppressWarnings("InconsistentOverloads")
+  static boolean check(
+      BasicBlock subgraphEntryBlock, BasicBlock subgraphExitBlock, BasicBlock targetBlock) {
+    if (targetBlock == subgraphExitBlock) {
+      return true;
+    }
+    if (subgraphEntryBlock == subgraphExitBlock) {
+      return false;
+    }
+    return TraversingDominatorChecker.checkWithTraversal(
+        subgraphEntryBlock, subgraphExitBlock, targetBlock, WorkList.newIdentityWorkList());
   }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/FastMapUtils.java b/src/main/java/com/android/tools/r8/utils/FastMapUtils.java
new file mode 100644
index 0000000..e64f202
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/FastMapUtils.java
@@ -0,0 +1,60 @@
+// 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.utils;
+
+import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
+import java.util.Iterator;
+import java.util.function.Function;
+
+public class FastMapUtils {
+
+  public static <V> Int2ReferenceMap<V> destructiveMapValues(
+      Int2ReferenceMap<V> map, Function<V, V> valueMapper) {
+    Iterator<Int2ReferenceMap.Entry<V>> iterator = map.int2ReferenceEntrySet().iterator();
+    while (iterator.hasNext()) {
+      Int2ReferenceMap.Entry<V> entry = iterator.next();
+      V newValue = valueMapper.apply(entry.getValue());
+      if (newValue != null) {
+        entry.setValue(newValue);
+      } else {
+        iterator.remove();
+      }
+    }
+    return map;
+  }
+
+  public static <V> Int2ReferenceMap<V> mapInt2ReferenceOpenHashMapOrElse(
+      Int2ReferenceMap<V> map,
+      IntObjToObjFunction<V, V> valueMapper,
+      Int2ReferenceMap<V> defaultValue) {
+    Int2ReferenceMap<V> newMap = null;
+    Iterator<Int2ReferenceMap.Entry<V>> iterator = map.int2ReferenceEntrySet().iterator();
+    while (iterator.hasNext()) {
+      Int2ReferenceMap.Entry<V> entry = iterator.next();
+      int key = entry.getIntKey();
+      V value = entry.getValue();
+      V newValue = valueMapper.apply(key, value);
+      if (newMap == null) {
+        if (newValue == value) {
+          continue;
+        }
+        // This is the first entry where the value has been changed. Create the new map and copy
+        // over previous entries that did not change.
+        Int2ReferenceMap<V> newFinalMap = new Int2ReferenceOpenHashMap<>(map.size());
+        CollectionUtils.forEachUntilExclusive(
+            map.int2ReferenceEntrySet(),
+            previousEntry -> newFinalMap.put(previousEntry.getIntKey(), previousEntry.getValue()),
+            entry);
+        newMap = newFinalMap;
+      }
+      if (newValue != null) {
+        newMap.put(key, newValue);
+      } else {
+        iterator.remove();
+      }
+    }
+    return newMap != null ? newMap : defaultValue;
+  }
+}
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 011fbfb..0dc92d1 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -65,14 +65,11 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.analysis.ResourceAccessAnalysis;
-import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
-import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.analysis.proto.ProtoReferences;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.ir.desugar.TypeRewriter;
 import com.android.tools.r8.ir.desugar.TypeRewriter.MachineTypeRewriter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibrarySpecification;
@@ -80,9 +77,6 @@
 import com.android.tools.r8.ir.desugar.nest.Nest;
 import com.android.tools.r8.ir.optimize.Inliner;
 import com.android.tools.r8.ir.optimize.enums.EnumDataMap;
-import com.android.tools.r8.lightir.IR2LirConverter;
-import com.android.tools.r8.lightir.LirCode;
-import com.android.tools.r8.lightir.LirStrategy;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.MapConsumer;
 import com.android.tools.r8.naming.MapVersion;
@@ -133,8 +127,6 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
@@ -2200,56 +2192,9 @@
 
     private LirPhase currentPhase = LirPhase.PRE;
 
-    public void enterLirSupportedPhase(AppView<?> appView, ExecutorService executorService)
-        throws ExecutionException {
+    public void enterLirSupportedPhase() {
       assert isPreLirPhase();
       currentPhase = LirPhase.SUPPORTED;
-      if (!canUseLir(appView)) {
-        return;
-      }
-      // Convert code objects to LIR.
-      ThreadUtils.processItems(
-          appView.appInfo().classes(),
-          clazz -> {
-            // TODO(b/225838009): Also convert instance initializers to LIR, by adding support for
-            //  computing the inlining constraint for LIR and using that in the class mergers, and
-            //  class initializers, by updating the concatenation of clinits in horizontal class
-            //  merging.
-            clazz.forEachProgramMethodMatching(
-                method ->
-                    method.hasCode()
-                        && !method.isInitializer()
-                        && !appView.isCfByteCodePassThrough(method),
-                method -> {
-                  IRCode code =
-                      method.buildIR(appView, MethodConversionOptions.forLirPhase(appView));
-                  LirCode<Integer> lirCode =
-                      IR2LirConverter.translate(
-                          code,
-                          BytecodeMetadataProvider.empty(),
-                          LirStrategy.getDefaultStrategy().getEncodingStrategy(),
-                          appView.options());
-                  // TODO(b/312890994): Setting a custom code lens is only needed until we convert
-                  //  code objects to LIR before we create the first code object with a custom code
-                  //  lens (horizontal class merging).
-                  GraphLens codeLens = method.getDefinition().getCode().getCodeLens(appView);
-                  if (codeLens != appView.codeLens()) {
-                    lirCode =
-                        new LirCode<>(lirCode) {
-                          @Override
-                          public GraphLens getCodeLens(AppView<?> appView) {
-                            return codeLens;
-                          }
-                        };
-                  }
-                  method.setCode(lirCode, appView);
-                });
-          },
-          appView.options().getThreadingModule(),
-          executorService);
-      // Conversion to LIR via IR will allocate type elements.
-      // They are not needed after construction so remove them again.
-      appView.dexItemFactory().clearTypeElementsCache();
     }
 
     public void exitLirSupportedPhase() {
diff --git a/src/main/java/com/android/tools/r8/utils/SetUtils.java b/src/main/java/com/android/tools/r8/utils/SetUtils.java
index be05c5d..a7c3366 100644
--- a/src/main/java/com/android/tools/r8/utils/SetUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/SetUtils.java
@@ -6,9 +6,11 @@
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
+import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
@@ -115,7 +117,7 @@
     return builder.build();
   }
 
-  public static <T, S> Set<T> mapIdentityHashSet(Set<S> set, Function<S, T> fn) {
+  public static <T, S> Set<T> mapIdentityHashSet(Collection<S> set, Function<S, T> fn) {
     Set<T> out = newIdentityHashSet(set.size());
     for (S element : set) {
       out.add(fn.apply(element));
@@ -123,6 +125,14 @@
     return out;
   }
 
+  public static <T, S> Set<T> mapLinkedHashSet(Collection<S> set, Function<S, T> fn) {
+    Set<T> out = new LinkedHashSet<>(set.size());
+    for (S element : set) {
+      out.add(fn.apply(element));
+    }
+    return out;
+  }
+
   public static <T> T removeFirst(Set<T> set) {
     T element = set.iterator().next();
     set.remove(element);
diff --git a/src/main/java/com/android/tools/r8/utils/ValueUtils.java b/src/main/java/com/android/tools/r8/utils/ValueUtils.java
index 68d3364..9082be5 100644
--- a/src/main/java/com/android/tools/r8/utils/ValueUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ValueUtils.java
@@ -57,12 +57,15 @@
   public static final class ArrayValues {
     private List<Value> elementValues;
     private ArrayPut[] arrayPutsByIndex;
+    private final Value arrayValue;
 
-    private ArrayValues(List<Value> elementValues) {
+    private ArrayValues(Value arrayValue, List<Value> elementValues) {
+      this.arrayValue = arrayValue;
       this.elementValues = elementValues;
     }
 
-    private ArrayValues(ArrayPut[] arrayPutsByIndex) {
+    private ArrayValues(Value arrayValue, ArrayPut[] arrayPutsByIndex) {
+      this.arrayValue = arrayValue;
       this.arrayPutsByIndex = arrayPutsByIndex;
     }
 
@@ -83,6 +86,28 @@
     public int size() {
       return elementValues != null ? elementValues.size() : arrayPutsByIndex.length;
     }
+
+    public boolean containsHoles() {
+      for (ArrayPut arrayPut : arrayPutsByIndex) {
+        if (arrayPut == null) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public ArrayPut[] getArrayPutsByIndex() {
+      assert arrayPutsByIndex != null;
+      return arrayPutsByIndex;
+    }
+
+    public Value getArrayValue() {
+      return arrayValue;
+    }
+
+    public Instruction getDefinition() {
+      return arrayValue.definition;
+    }
   }
 
   /**
@@ -92,12 +117,8 @@
    * 1) The Array has a single users (other than array-puts)
    *   * This constraint is to ensure other users do not modify the array.
    *   * When users are in different blocks, their order is hard to know.
-   * 2) The array size is a constant.
+   * 2) The array size is a constant and non-negative.
    * 3) All array-put instructions have constant and unique indices.
-   *   * With the exception of array-puts that are in the same block as singleUser, in which case
-   *     non-unique puts are allowed.
-   *   * Indices must be unique in other blocks because order is hard to know when multiple blocks
-   *     are concerned (and reassignment is rare anyways).
    * 4) The array-put instructions are guaranteed to be executed before singleUser.
    * </pre>
    *
@@ -106,7 +127,6 @@
    * @return The computed array values, or null if they could not be determined.
    */
   public static ArrayValues computeSingleUseArrayValues(Value arrayValue, Instruction singleUser) {
-    assert singleUser == null || arrayValue.uniqueUsers().contains(singleUser);
     TypeElement arrayType = arrayValue.getType();
     if (!arrayType.isArrayType() || arrayValue.hasDebugUsers() || arrayValue.isPhi()) {
       return null;
@@ -121,7 +141,7 @@
       if (!arrayValue.hasSingleUniqueUser() || arrayValue.hasPhiUsers()) {
         return null;
       }
-      return new ArrayValues(newArrayFilled.inValues());
+      return new ArrayValues(arrayValue, newArrayFilled.inValues());
     } else if (newArrayEmpty == null) {
       return null;
     }
@@ -132,28 +152,83 @@
       return null;
     }
 
-    if (singleUser == null) {
-      for (Instruction user : arrayValue.uniqueUsers()) {
-        ArrayPut arrayPut = user.asArrayPut();
-        if (arrayPut == null || arrayPut.array() != arrayValue || arrayPut.value() == arrayValue) {
-          if (singleUser == null) {
-            singleUser = user;
-          } else {
-            return null;
-          }
+    return computeArrayValuesInternal(newArrayEmpty, arraySize, singleUser, false);
+  }
+
+  /**
+   * Determines the values for the given array at the point the last element is assigned.
+   *
+   * <pre>
+   * Returns null under the following conditions:
+   *  * The array has a non-const, negative, or abnormally large size.
+   *  * An array-put with non-constant index exists.
+   *  * An array-put with an out-of-bounds index exists.
+   *  * An array-put for the last index is not found.
+   *  * An array-put is found after the last-index array-put.
+   *  * An array-put is found where the array and value are the same: arr[index] = arr;
+   *  * There are multiple array-put instructions for the same index.
+   * </pre>
+   */
+  public static ArrayValues computeInitialArrayValues(NewArrayEmpty newArrayEmpty) {
+    int arraySize = newArrayEmpty.sizeIfConst();
+    if (arraySize < 0 || arraySize > MAX_ARRAY_SIZE) {
+      // Array is non-const size.
+      return null;
+    }
+
+    Value arrayValue = newArrayEmpty.outValue();
+    // Find array-put for the last element, as well as blocks for other array users.
+    ArrayPut lastArrayPut = null;
+    int lastIndex = arraySize - 1;
+    for (Instruction user : arrayValue.uniqueUsers()) {
+      ArrayPut arrayPut = user.asArrayPut();
+      if (arrayPut != null && arrayPut.array() == arrayValue) {
+        int index = arrayPut.indexOrDefault(-1);
+        if (index == lastIndex) {
+          lastArrayPut = arrayPut;
+          break;
         }
       }
     }
+    if (lastArrayPut == null) {
+      return null;
+    }
 
+    // Find all array-puts up until the last one.
+    // Also checks that no array-puts appear after the last one.
+    ArrayValues ret = computeArrayValuesInternal(newArrayEmpty, arraySize, lastArrayPut, true);
+    if (ret == null) {
+      return null;
+    }
+    // Since the last array-put is used as firstUser, it will not already be in arrayPutsByIndex.
+    if (ret.arrayPutsByIndex[lastIndex] != null) {
+      return null;
+    }
+    ret.arrayPutsByIndex[lastIndex] = lastArrayPut;
+    return ret;
+  }
+
+  private static ArrayValues computeArrayValuesInternal(
+      NewArrayEmpty newArrayEmpty, int arraySize, Instruction firstUser, boolean allowOtherUsers) {
     ArrayPut[] arrayPutsByIndex = new ArrayPut[arraySize];
-    BasicBlock usageBlock = singleUser.getBlock();
+    Value arrayValue = newArrayEmpty.outValue();
+    BasicBlock usageBlock = firstUser.getBlock();
+
+    // Collect array-puts from non-usage blocks, and (optionally) check for multiple users.
     for (Instruction user : arrayValue.uniqueUsers()) {
       ArrayPut arrayPut = user.asArrayPut();
-      if (arrayPut == null || arrayPut.array() != arrayValue || arrayPut.value() == arrayValue) {
-        if (user == singleUser) {
+      if (arrayPut == null || arrayPut.array() != arrayValue) {
+        if (user == firstUser) {
           continue;
         }
         // Found a second non-array-put user.
+        if (allowOtherUsers) {
+          continue;
+        }
+        return null;
+      } else if (arrayPut.value() == arrayValue) {
+        // An array that contains itself is uncommon and hard to reason about.
+        // e.g.: arr[0] = arr;
         return null;
       }
       // Process same-block instructions later.
@@ -168,8 +243,10 @@
       arrayPutsByIndex[index] = arrayPut;
     }
 
-    // Ensure that all paths from new-array-empty to |usage| contain all array-put instructions.
-    DominatorChecker dominatorChecker = DominatorChecker.create(definition.getBlock(), usageBlock);
+    // Ensure that all paths from new-array-empty's block to |usage|'s block contain all array-put
+    // instructions.
+    DominatorChecker dominatorChecker =
+        DominatorChecker.create(newArrayEmpty.getBlock(), usageBlock);
     // Visit in reverse order because array-puts generally appear in order, and DominatorChecker's
     // cache is more effective when visiting in reverse order.
     for (int i = arraySize - 1; i >= 0; --i) {
@@ -179,17 +256,18 @@
       }
     }
 
-    boolean seenSingleUser = false;
+    // Collect array-puts from the usage block, and ensure no array-puts come after the first user.
+    boolean seenFirstUser = false;
     for (Instruction inst : usageBlock.getInstructions()) {
-      if (inst == singleUser) {
-        seenSingleUser = true;
+      if (inst == firstUser) {
+        seenFirstUser = true;
         continue;
       }
       ArrayPut arrayPut = inst.asArrayPut();
       if (arrayPut == null || arrayPut.array() != arrayValue) {
         continue;
       }
-      if (seenSingleUser) {
+      if (seenFirstUser) {
         // Found an array-put after the array was used. This is too uncommon of a thing to support.
         return null;
       }
@@ -197,10 +275,14 @@
       if (index < 0) {
         return null;
       }
-      // We can allow reassignment at this point since we are visiting in order.
+      // Do not allow re-assignment so that we can use arrayPutsByIndex to find all array-put
+      // instructions.
+      if (arrayPutsByIndex[index] != null) {
+        return null;
+      }
       arrayPutsByIndex[index] = arrayPut;
     }
 
-    return new ArrayValues(arrayPutsByIndex);
+    return new ArrayValues(arrayValue, arrayPutsByIndex);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/WorkList.java b/src/main/java/com/android/tools/r8/utils/WorkList.java
index cdfb34c..ed63185 100644
--- a/src/main/java/com/android/tools/r8/utils/WorkList.java
+++ b/src/main/java/com/android/tools/r8/utils/WorkList.java
@@ -145,8 +145,8 @@
     return seen.contains(item);
   }
 
-  public void markAsSeen(T item) {
-    seen.add(item);
+  public boolean markAsSeen(T item) {
+    return seen.add(item);
   }
 
   public void markAsSeen(Iterable<T> items) {
@@ -154,16 +154,23 @@
   }
 
   public T next() {
-    assert hasNext();
     return workingList.removeFirst();
   }
 
+  public T removeLast() {
+    return workingList.removeLast();
+  }
+
   public T removeSeen() {
     T next = next();
     seen.remove(next);
     return next;
   }
 
+  public void clearSeen() {
+    seen.clear();
+  }
+
   public Set<T> getSeenSet() {
     return SetUtils.unmodifiableForTesting(seen);
   }
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/IllegalAccessDetector.java b/src/main/java/com/android/tools/r8/verticalclassmerging/IllegalAccessDetector.java
index cfbc759..5bb0780 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/IllegalAccessDetector.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/IllegalAccessDetector.java
@@ -81,7 +81,7 @@
     DexType baseType =
         rewrittenMethod.getHolderType().toBaseType(appViewWithClassHierarchy.dexItemFactory());
     if (baseType.isClassType() && baseType.isSamePackage(getContext().getHolderType())) {
-      if (checkTypeReference(rewrittenMethod.getHolderType())) {
+      if (checkRewrittenTypeReference(rewrittenMethod.getHolderType())) {
         return checkFoundPackagePrivateAccess();
       }
       MethodResolutionResult resolutionResult =
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
index 3987216..994795d 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
@@ -8,11 +8,13 @@
 
 import com.android.tools.r8.classmerging.ClassMergerGraphLens;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.lens.GraphLens;
@@ -22,6 +24,9 @@
 import com.android.tools.r8.ir.code.InvokeType;
 import com.android.tools.r8.ir.conversion.ExtraParameter;
 import com.android.tools.r8.ir.conversion.ExtraUnusedNullParameter;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepInfoCollection;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.IterableUtils;
 import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeHashMap;
 import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
@@ -283,7 +288,10 @@
     }
     if (type.isInterface()
         && mergedClasses.hasInterfaceBeenMergedIntoClass(previousMethod.getHolderType())) {
-      return InvokeType.VIRTUAL;
+      DexClass newMethodHolder = appView.definitionForHolder(newMethod);
+      if (newMethodHolder != null && !newMethodHolder.isInterface()) {
+        return InvokeType.VIRTUAL;
+      }
     }
     return type;
   }
@@ -309,6 +317,29 @@
     return true;
   }
 
+  public boolean assertPinnedNotModified(AppView<AppInfoWithLiveness> appView) {
+    KeepInfoCollection keepInfo = appView.getKeepInfo();
+    InternalOptions options = appView.options();
+    keepInfo.forEachPinnedType(this::assertReferenceNotModified, options);
+    keepInfo.forEachPinnedMethod(this::assertReferenceNotModified, options);
+    keepInfo.forEachPinnedField(this::assertReferenceNotModified, options);
+    return true;
+  }
+
+  private void assertReferenceNotModified(DexReference reference) {
+    if (reference.isDexField()) {
+      DexField field = reference.asDexField();
+      assert getNextFieldSignature(field).isIdenticalTo(field);
+    } else if (reference.isDexMethod()) {
+      DexMethod method = reference.asDexMethod();
+      assert getNextMethodSignature(method).isIdenticalTo(method);
+    } else {
+      assert reference.isDexType();
+      DexType type = reference.asDexType();
+      assert getNextClassType(type).isIdenticalTo(type);
+    }
+  }
+
   public static class Builder
       extends BuilderBase<VerticalClassMergerGraphLens, VerticallyMergedClasses> {
 
@@ -469,13 +500,6 @@
           staticizedMethods);
     }
 
-    // TODO: should be removed.
-    public boolean hasMappingForSignatureInContext(DexProgramClass context, DexMethod signature) {
-      return contextualSuperToImplementationInContexts
-          .getOrDefault(context.getType(), Collections.emptyMap())
-          .containsKey(signature);
-    }
-
     public void markMethodAsMerged(DexEncodedMethod method) {
       mergedMethods.add(method.getReference());
     }
diff --git a/src/test/java/com/android/tools/r8/D8CommandTest.java b/src/test/java/com/android/tools/r8/D8CommandTest.java
index 842b6a8..aaee1b0 100644
--- a/src/test/java/com/android/tools/r8/D8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/D8CommandTest.java
@@ -329,15 +329,25 @@
     assertTrue(ToolHelper.getApp(command).hasMainDexListResources());
   }
 
+  @Test
+  public void mainDexListNonLegacyMinApiL() throws Throwable {
+    Path mainDexList = temp.newFile("main-dex-list.txt").toPath();
+    D8Command command =
+        parse(
+            "--min-api", Integer.toString(AndroidApiLevel.L.getLevel()),
+            "--main-dex-list", mainDexList.toString());
+    assertTrue(ToolHelper.getApp(command).hasMainDexListResources());
+  }
+
   @Test(expected = CompilationFailedException.class)
-  public void mainDexListWithNonLegacyMinApi() throws Throwable {
+  public void mainDexListWithNonLegacyMinApiAboveL() throws Throwable {
     Path mainDexList = temp.newFile("main-dex-list.txt").toPath();
     DiagnosticsChecker.checkErrorsContains(
         "does not support main-dex",
         (handler) ->
             D8Command.builder(handler)
                 .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
-                .setMinApiLevel(AndroidApiLevel.L.getLevel())
+                .setMinApiLevel(AndroidApiLevel.L_MR1.getLevel())
                 .addMainDexListFiles(mainDexList)
                 .build());
   }
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerInvokeVirtualToInterfaceTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerInvokeVirtualToInterfaceTest.java
new file mode 100644
index 0000000..2a8fa07
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerInvokeVirtualToInterfaceTest.java
@@ -0,0 +1,94 @@
+// 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.classmerging.vertical;
+
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoParameterTypeStrengthening;
+import com.android.tools.r8.NoUnusedInterfaceRemoval;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+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 VerticalClassMergerInvokeVirtualToInterfaceTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addVerticallyMergedClassesInspector(
+            inspector -> inspector.assertMergedIntoSubtype(J.class).assertNoOtherClassesMerged())
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .enableNoParameterTypeStrengtheningAnnotations()
+        .enableNoUnusedInterfaceRemovalAnnotations()
+        .enableNoVerticalClassMergingAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello, world!", "Hello, world!");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      callOnI(new B());
+      callOnJ(new B());
+    }
+
+    @NeverInline
+    @NoParameterTypeStrengthening
+    static void callOnI(I i) {
+      i.m();
+    }
+
+    @NeverInline
+    @NoParameterTypeStrengthening
+    static void callOnJ(J j) {
+      j.m();
+    }
+  }
+
+  @NoUnusedInterfaceRemoval
+  @NoVerticalClassMerging
+  interface I {
+
+    void m();
+  }
+
+  @NoUnusedInterfaceRemoval
+  interface J {
+
+    void m();
+  }
+
+  @NoVerticalClassMerging
+  abstract static class A implements I, J {}
+
+  @NeverClassInline
+  static class B extends A {
+
+    @NeverInline
+    public void m() {
+      System.out.println("Hello, world!");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
index 128178a..ba3e8e6 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
@@ -16,6 +16,8 @@
 import com.android.tools.r8.DexFilePerClassFileConsumer;
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.SyntheticInfoConsumer;
+import com.android.tools.r8.SyntheticInfoConsumerData;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -23,7 +25,9 @@
 import com.android.tools.r8.ToolHelper.ArtCommandBuilder;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.desugar.backports.AbstractBackportTest.MiniAssert;
+import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -37,8 +41,10 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.Test;
@@ -342,6 +348,115 @@
     assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
   }
 
+  private static class ContextCollector implements SyntheticInfoConsumer {
+
+    Map<ClassReference, Set<ClassReference>> contextToSynthetics = new HashMap<>();
+
+    @Override
+    public synchronized void acceptSyntheticInfo(SyntheticInfoConsumerData data) {
+      contextToSynthetics
+          .computeIfAbsent(data.getSynthesizingContextClass(), k -> new HashSet<>())
+          .add(data.getSyntheticClass());
+    }
+
+    @Override
+    public void finished() {}
+  }
+
+  private static class PerFileCollector extends DexFilePerClassFileConsumer.ForwardingConsumer {
+
+    Map<ClassReference, byte[]> data = new HashMap<>();
+    ContextCollector contexts = new ContextCollector();
+
+    public PerFileCollector() {
+      super(null);
+    }
+
+    @Override
+    public boolean combineSyntheticClassesWithPrimaryClass() {
+      return false;
+    }
+
+    @Override
+    public synchronized void accept(
+        String primaryClassDescriptor,
+        ByteDataView data,
+        Set<String> descriptors,
+        DiagnosticsHandler handler) {
+      super.accept(primaryClassDescriptor, data, descriptors, handler);
+      this.data.put(Reference.classFromDescriptor(primaryClassDescriptor), data.copyByteData());
+    }
+  }
+
+  @Test
+  public void testDoubleCompileSyntheticInputsD8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    // This is a regression test for the pathological case of recompiling intermediates in
+    // intermediate mode, but where the second round of compilation can share more than what was
+    // originally shared. Such a case should never be hit by any reasonable compilation pipeline,
+    // but it could by chance happen if a bytecode transformation was between the two intermediate
+    // steps that ended up making two previously distinct synthetics equivalent. To simulate such
+    // a case the sharing of synthetics is internally disabled so that we know the second round
+    // would see equivalent synthetics.
+
+    // Compile part 1 of the input with sharing completely disabled.
+    PerFileCollector out1 = new PerFileCollector();
+    testForD8(parameters.getBackend())
+        .addOptionsModification(o -> o.testing.enableSyntheticSharing = false)
+        .addProgramClasses(User1.class)
+        .addClasspathClasses(CLASSES)
+        .setMinApi(parameters)
+        .setIntermediate(true)
+        .setProgramConsumer(out1)
+        .apply(b -> b.getBuilder().setSyntheticInfoConsumer(out1.contexts))
+        .compile();
+    // The total number of outputs is 8 of which 7 are synthetics in User1.
+    ClassReference user1 = Reference.classFromClass(User1.class);
+    assertEquals(8, out1.data.size());
+    assertEquals(1, out1.contexts.contextToSynthetics.size());
+    assertEquals(7, out1.contexts.contextToSynthetics.get(user1).size());
+
+    // Recompile a "shard" containing all the synthetics, but not the context.
+    PerFileCollector out2 = new PerFileCollector();
+    testForD8(parameters.getBackend())
+        .apply(
+            b ->
+                out1.contexts
+                    .contextToSynthetics
+                    .get(user1)
+                    .forEach(synthetic -> b.addProgramDexFileData(out1.data.get(synthetic))))
+        .addClasspathClasses(CLASSES)
+        .setMinApi(parameters)
+        .setIntermediate(true)
+        .setProgramConsumer(out2)
+        .apply(b -> b.getBuilder().setSyntheticInfoConsumer(out2.contexts))
+        .compile();
+    // Again the total number of synthetics should remain 7 with no sharing taking place.
+    assertEquals(7, out2.data.size());
+
+    // Compile the remaining program inputs not compiled in the above.
+    // Note: the order of final synthetics depends on compiling to intermediates before merge.
+    Path out3 =
+        testForD8(parameters.getBackend())
+            .addProgramClasses(MiniAssert.class, TestClass.class, User2.class)
+            .setMinApi(parameters)
+            .setIntermediate(true)
+            .compile()
+            .writeToZip();
+
+    // Merge all into a final build.
+    testForD8(parameters.getBackend())
+        .addProgramDexFileData(out1.data.get(user1))
+        .addProgramDexFileData(out2.data.values())
+        .addProgramFiles(out3)
+        .setMinApi(parameters)
+        .setIntermediate(false)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+        .inspect(this::checkExpectedSynthetics);
+  }
+
   static class User1 {
 
     private static void testBooleanCompare() {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMappingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMappingTest.java
index f7c850a..c23da1d 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMappingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMappingTest.java
@@ -18,22 +18,20 @@
 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 EnumUnboxingMappingTest extends EnumUnboxingTestBase {
 
-  private final TestParameters parameters;
+  @Parameter(0)
+  public TestParameters parameters;
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withDexRuntimes().withAllApiLevels().build();
   }
 
-  public EnumUnboxingMappingTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
   @Test
   public void testEnumUnboxing() throws Exception {
     testForR8(parameters.getBackend())
@@ -64,14 +62,14 @@
     assertEquals("int", debugInfoMethod.getFinalSignature().asMethodSignature().parameters[0]);
     assertEquals("int", noDebugInfoMethod.getFinalSignature().asMethodSignature().parameters[0]);
 
-    assertEquals(MyEnum.class.getName(), debugInfoMethod.getOriginalSignature().parameters[0]);
-    // TODO(b/314076309): The original parameter should be MyEnum.class but is int.
-    assertEquals("int", noDebugInfoMethod.getOriginalSignature().parameters[0]);
+    assertEquals(MyEnum.class.getTypeName(), debugInfoMethod.getOriginalSignature().parameters[0]);
+    assertEquals(
+        MyEnum.class.getTypeName(), noDebugInfoMethod.getOriginalSignature().parameters[0]);
 
     ClassSubject indirection = codeInspector.clazz(Indirection.class);
     MethodSubject abstractMethod = indirection.uniqueMethodWithOriginalName("intermediate");
     assertTrue(abstractMethod.isAbstract());
-    assertEquals(MyEnum.class.getName(), abstractMethod.getOriginalSignature().parameters[0]);
+    assertEquals(MyEnum.class.getTypeName(), abstractMethod.getOriginalSignature().parameters[0]);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/examples/filledarray/FilledArray.java b/src/test/java/com/android/tools/r8/examples/filledarray/FilledArray.java
index f25b76b..6551be6 100644
--- a/src/test/java/com/android/tools/r8/examples/filledarray/FilledArray.java
+++ b/src/test/java/com/android/tools/r8/examples/filledarray/FilledArray.java
@@ -115,8 +115,7 @@
     }
 
     try {
-      // Array creation that cannot be turned into fill-array-data because an exception would
-      // cause the initialization sequence to be interrupted.
+      // Exception does not prevent fill-array-data since only usage is within the try.
       int[] ints = new int[5];
       ints[0] = 0;
       ints[1] = 1;
diff --git a/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternAnyRetentionTest.java b/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternAnyRetentionTest.java
new file mode 100644
index 0000000..4b11ba6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternAnyRetentionTest.java
@@ -0,0 +1,127 @@
+// 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.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
+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.AnnotationPattern;
+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;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class AnnotationPatternAnyRetentionTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("C1: A1");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public AnnotationPatternAnyRetentionTest(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, Reflector.class, A1.class, A2.class, C1.class);
+  }
+
+  private void checkOutput(CodeInspector inspector) {
+    // The class retention annotation is used and kept. It can be renamed as nothing prohibits that.
+    assertThat(inspector.clazz(A1.class), isPresentAndRenamed());
+    assertThat(inspector.clazz(A2.class), isPresentAndRenamed());
+    // The class is retained by the keep-annotation.
+    ClassSubject clazz = inspector.clazz(C1.class);
+    assertThat(clazz, isPresentAndNotRenamed());
+    assertThat(clazz.annotation(A1.class), isPresent());
+    assertThat(clazz.annotation(A2.class), isPresent());
+  }
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface A1 {}
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.CLASS)
+  @interface A2 {}
+
+  static class Reflector {
+
+    @UsesReflection({
+      @KeepTarget(
+          classAnnotatedByClassConstant = A2.class,
+          constrainAnnotations =
+              @AnnotationPattern(retention = {RetentionPolicy.CLASS, RetentionPolicy.RUNTIME})),
+    })
+    public void foo(Class<?>... classes) throws Exception {
+      for (Class<?> clazz : classes) {
+        String typeName = clazz.getTypeName();
+        System.out.print(typeName.substring(typeName.lastIndexOf('$') + 1) + ":");
+        if (clazz.isAnnotationPresent(A1.class)) {
+          System.out.print(" A1");
+        }
+        // The below code will not trigger as A2 is not visible at runtime, but it will ensure the
+        // annotation is used.
+        if (clazz.isAnnotationPresent(A2.class)) {
+          System.out.print(" A2");
+        }
+        System.out.println();
+      }
+    }
+  }
+
+  @A1
+  @A2
+  static class C1 {}
+
+  static class TestClass {
+
+    @UsedByReflection(kind = KeepItemKind.CLASS_AND_METHODS)
+    public static void main(String[] args) throws Exception {
+      new Reflector().foo(C1.class);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternClassRetentionTest.java b/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternClassRetentionTest.java
new file mode 100644
index 0000000..efc77cf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternClassRetentionTest.java
@@ -0,0 +1,127 @@
+// 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.isPresentAndNotRenamed;
+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.AnnotationPattern;
+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;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class AnnotationPatternClassRetentionTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("C1:");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public AnnotationPatternClassRetentionTest(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, Reflector.class, A1.class, A2.class, C1.class);
+  }
+
+  private void checkOutput(CodeInspector inspector) {
+    // Nothing is keeping A1 and no references exist to it.
+    // Having the constraint on annotations with class retention should not prohibit removal.
+    assertThat(inspector.clazz(A1.class), isAbsent());
+    // The class retention annotation is used and kept. It can be renamed as nothing prohibits that.
+    assertThat(inspector.clazz(A2.class), isPresentAndRenamed());
+    // The class is retained by the keep-annotation.
+    ClassSubject clazz = inspector.clazz(C1.class);
+    assertThat(clazz, isPresentAndNotRenamed());
+    assertThat(clazz.annotation(A1.class), isAbsent());
+    assertThat(clazz.annotation(A2.class), isPresent());
+  }
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface A1 {}
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.CLASS)
+  @interface A2 {}
+
+  static class Reflector {
+
+    @UsesReflection({
+      @KeepTarget(
+          classAnnotatedByClassConstant = A2.class,
+          constrainAnnotations = @AnnotationPattern(retention = RetentionPolicy.CLASS)),
+    })
+    public void foo(Class<?>... classes) throws Exception {
+      for (Class<?> clazz : classes) {
+        String typeName = clazz.getTypeName();
+        System.out.print(typeName.substring(typeName.lastIndexOf('$') + 1) + ":");
+        // Ignoring A1 as we explicitly have no keep-annotation to preserve it.
+        // The below code will not trigger as A2 is not visible at runtime, but it will ensure the
+        // annotation is used.
+        if (clazz.isAnnotationPresent(A2.class)) {
+          System.out.print(" A2");
+        }
+        System.out.println();
+      }
+    }
+  }
+
+  @A1
+  @A2
+  static class C1 {}
+
+  static class TestClass {
+
+    @UsedByReflection(kind = KeepItemKind.CLASS_AND_METHODS)
+    public static void main(String[] args) throws Exception {
+      new Reflector().foo(C1.class);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternMultipleTest.java b/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternMultipleTest.java
new file mode 100644
index 0000000..33a4f6d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/AnnotationPatternMultipleTest.java
@@ -0,0 +1,146 @@
+// 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.isPresentAndNotRenamed;
+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.AnnotationPattern;
+import com.android.tools.r8.keepanno.annotations.ClassNamePattern;
+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;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class AnnotationPatternMultipleTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("C1: A1", "C2:");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public AnnotationPatternMultipleTest(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, Reflector.class, A1.class, A2.class, A3.class, C1.class, C2.class);
+  }
+
+  private void checkOutput(CodeInspector inspector) {
+    assertThat(inspector.clazz(A1.class), isPresentAndRenamed());
+    assertThat(inspector.clazz(A2.class), isPresentAndRenamed());
+    // No use of A3 so R8 will remove it.
+    assertThat(inspector.clazz(A3.class), isAbsent());
+    // The class is retained by the keep-annotation.
+    ClassSubject c1 = inspector.clazz(C1.class);
+    assertThat(c1, isPresentAndNotRenamed());
+    assertThat(c1.annotation(A1.class), isPresent());
+    assertThat(c1.annotation(A3.class), isAbsent());
+
+    ClassSubject c2 = inspector.clazz(C2.class);
+    assertThat(c2, isPresentAndNotRenamed());
+    assertThat(c2.annotation(A2.class), isPresent());
+    assertThat(c2.annotation(A3.class), isAbsent());
+  }
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface A1 {}
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.CLASS)
+  @interface A2 {}
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface A3 {}
+
+  static class Reflector {
+
+    @UsesReflection(
+        @KeepTarget(
+            classAnnotatedByClassNamePattern =
+                @ClassNamePattern(packageName = "com.android.tools.r8.keepanno"),
+            constrainAnnotations = {
+              @AnnotationPattern(constant = A1.class, retention = RetentionPolicy.RUNTIME),
+              @AnnotationPattern(constant = A2.class, retention = RetentionPolicy.CLASS)
+            }))
+    public void foo(Class<?>... classes) throws Exception {
+      for (Class<?> clazz : classes) {
+        String typeName = clazz.getTypeName();
+        System.out.print(typeName.substring(typeName.lastIndexOf('$') + 1) + ":");
+        if (clazz.isAnnotationPresent(A1.class)) {
+          System.out.print(" A1");
+        }
+        // The below code will not trigger as A2 is not visible at runtime, but it will ensure the
+        // annotation is used.
+        if (clazz.isAnnotationPresent(A2.class)) {
+          System.out.print(" A2");
+        }
+        System.out.println();
+      }
+    }
+  }
+
+  @A1
+  @A3
+  static class C1 {}
+
+  @A2
+  @A3
+  static class C2 {}
+
+  static class TestClass {
+
+    @UsedByReflection(kind = KeepItemKind.CLASS_AND_METHODS)
+    public static void main(String[] args) throws Exception {
+      new Reflector().foo(C1.class, C2.class);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoConstraintPatternTest.java b/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoConstraintPatternTest.java
new file mode 100644
index 0000000..0a33131
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoConstraintPatternTest.java
@@ -0,0 +1,153 @@
+// 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.isPresentAndNotRenamed;
+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.AnnotationPattern;
+import com.android.tools.r8.keepanno.annotations.ClassNamePattern;
+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;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassAnnotatedByAnyAnnoConstraintPatternTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("C1: A1", "C2: A2");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public ClassAnnotatedByAnyAnnoConstraintPatternTest(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,
+        Reflector.class,
+        A1.class,
+        A2.class,
+        A3.class,
+        C1.class,
+        C2.class,
+        C3.class);
+  }
+
+  private void checkOutput(CodeInspector inspector) {
+    // The class constant use will ensure the annotations remains.
+    // They are not renamed as the keep-annotation will match them (they are themselves annotated).
+    assertThat(inspector.clazz(A1.class), isPresentAndNotRenamed());
+    assertThat(inspector.clazz(A2.class), isPresentAndNotRenamed());
+    assertThat(inspector.clazz(A3.class), isPresentAndNotRenamed());
+    // The first two classes are annotated so the keep-annotation applies and retains their name.
+    assertThat(inspector.clazz(C1.class), isPresentAndNotRenamed());
+    assertThat(inspector.clazz(C2.class), isPresentAndNotRenamed());
+    // The last class will remain due to the class constant, but it is optimized/renamed.
+    assertThat(inspector.clazz(C3.class), isPresentAndRenamed());
+    // The class-retention annotation should not be present on the class as the pattern defaults
+    // to only match runtime retention classes.
+    assertThat(inspector.clazz(C2.class).annotation(A3.class), isAbsent());
+  }
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface A1 {}
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface A2 {}
+
+  @Target(ElementType.TYPE)
+  @Retention(RetentionPolicy.CLASS)
+  @interface A3 {}
+
+  static class Reflector {
+
+    @UsesReflection({
+      @KeepTarget(
+          classAnnotatedByClassNamePattern = @ClassNamePattern,
+          constraints = {KeepConstraint.NAME},
+          constrainAnnotations = @AnnotationPattern),
+    })
+    public void foo(Class<?>... classes) throws Exception {
+      for (Class<?> clazz : classes) {
+        if (clazz.getAnnotations().length > 0) {
+          String typeName = clazz.getTypeName();
+          System.out.print(typeName.substring(typeName.lastIndexOf('$') + 1) + ":");
+          if (clazz.isAnnotationPresent(A1.class)) {
+            System.out.print(" A1");
+          }
+          if (clazz.isAnnotationPresent(A2.class)) {
+            System.out.print(" A2");
+          }
+          if (clazz.isAnnotationPresent(A3.class)) {
+            System.out.print(" A3");
+          }
+          System.out.println();
+        }
+      }
+    }
+  }
+
+  @A1
+  static class C1 {}
+
+  @A2
+  @A3
+  static class C2 {}
+
+  static class C3 {}
+
+  static class TestClass {
+
+    @UsedByReflection(kind = KeepItemKind.CLASS_AND_METHODS)
+    public static void main(String[] args) throws Exception {
+      new Reflector().foo(C1.class, C2.class, C3.class);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoPatternTest.java b/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoPatternTest.java
index 684a4e2..6e8ea51 100644
--- a/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoPatternTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByAnyAnnoPatternTest.java
@@ -10,6 +10,7 @@
 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.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.ClassNamePattern;
 import com.android.tools.r8.keepanno.annotations.KeepConstraint;
 import com.android.tools.r8.keepanno.annotations.KeepItemKind;
@@ -91,11 +92,14 @@
 
   static class Reflector {
 
-    @UsesReflection({
-      @KeepTarget(
-          classAnnotatedByClassNamePattern = @ClassNamePattern,
-          constraints = {KeepConstraint.ANNOTATIONS, KeepConstraint.NAME}),
-    })
+    @UsesReflection(
+        @KeepTarget(
+            classAnnotatedByClassNamePattern = @ClassNamePattern,
+            constraints = KeepConstraint.NAME,
+            constrainAnnotations = {
+              @AnnotationPattern(constant = A1.class),
+              @AnnotationPattern(constant = A2.class)
+            }))
     public void foo(Class<?>... classes) throws Exception {
       for (Class<?> clazz : classes) {
         if (clazz.getAnnotations().length > 0) {
diff --git a/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByPatternsTest.java b/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByPatternsTest.java
index 6d7e6c8..d828d7f 100644
--- a/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByPatternsTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/ClassAnnotatedByPatternsTest.java
@@ -11,6 +11,7 @@
 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.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.KeepConstraint;
 import com.android.tools.r8.keepanno.annotations.KeepItemKind;
 import com.android.tools.r8.keepanno.annotations.KeepTarget;
@@ -95,7 +96,8 @@
     @UsesReflection(
         @KeepTarget(
             classAnnotatedByClassConstant = A1.class,
-            constraints = {KeepConstraint.ANNOTATIONS, KeepConstraint.NAME}))
+            constraints = KeepConstraint.NAME,
+            constrainAnnotations = @AnnotationPattern(constant = A1.class)))
     public void foo(Class<?>... classes) throws Exception {
       for (Class<?> clazz : classes) {
         if (clazz.isAnnotationPresent(A1.class)) {
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java
index dda99e1..6b4bfac 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java
@@ -10,7 +10,7 @@
 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.KeepConstraint;
+import com.android.tools.r8.keepanno.annotations.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.KeepTarget;
 import com.android.tools.r8.keepanno.annotations.UsesReflection;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -106,7 +106,8 @@
     @UsesReflection({
       @KeepTarget(
           instanceOfClassConstantExclusive = Base.class,
-          constraints = {KeepConstraint.ANNOTATIONS})
+          constraints = {},
+          constrainAnnotations = @AnnotationPattern(constant = Anno.class))
     })
     public Base() {
       Anno annotation = getClass().getAnnotation(Anno.class);
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepInvalidTargetTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepInvalidTargetTest.java
index 0eace48..d8d5941 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepInvalidTargetTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepInvalidTargetTest.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.keepanno.annotations.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.KeepConstraint;
 import com.android.tools.r8.keepanno.annotations.KeepTarget;
 import com.android.tools.r8.keepanno.annotations.StringPattern;
@@ -186,6 +187,48 @@
     }
   }
 
+  @Test
+  public void testEmptyAnnotationConstraints() {
+    assertThrowsWith(
+        () -> extractRuleForClass(EmptyAnnotationConstraints.class),
+        allOf(
+            containsString("Expected non-empty array"),
+            containsString("at property: constrainAnnotations")));
+  }
+
+  static class EmptyAnnotationConstraints {
+
+    @UsesReflection(
+        @KeepTarget(
+            classConstant = A.class,
+            constrainAnnotations = {}))
+    public static void main(String[] args) {
+      System.out.println("Hello, world");
+    }
+  }
+
+  @Test
+  public void testEmptyAnnotationPatternRetention() {
+    assertThrowsWith(
+        () -> extractRuleForClass(EmptyAnnotationPatternRetention.class),
+        allOf(
+            containsString("Expected non-empty array"),
+            containsString("at property: retention"),
+            containsString("at annotation: @AnnotationPattern"),
+            containsString("at property: constrainAnnotations")));
+  }
+
+  static class EmptyAnnotationPatternRetention {
+
+    @UsesReflection(
+        @KeepTarget(
+            classConstant = A.class,
+            constrainAnnotations = @AnnotationPattern(retention = {})))
+    public static void main(String[] args) {
+      System.out.println("Hello, world");
+    }
+  }
+
   static class A {
     // just a target.
   }
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java
index 19e2290..7c57ea6 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java
@@ -10,8 +10,8 @@
 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.AnnotationPattern;
 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.UsedByNative;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -108,7 +108,7 @@
         preconditions = {@KeepCondition(classConstant = A.class, methodName = "foo")},
         // Both the class and method are reflectively accessed.
         kind = KeepItemKind.CLASS_AND_MEMBERS,
-        constraintAdditions = {KeepConstraint.ANNOTATIONS})
+        constrainAnnotations = @AnnotationPattern(constant = Anno.class))
     @Anno("anno-on-bar")
     public static void bar() {
       System.out.println("Hello, world");
diff --git a/src/test/java/com/android/tools/r8/keepanno/MembersAnnotatedByPatternsTest.java b/src/test/java/com/android/tools/r8/keepanno/MembersAnnotatedByPatternsTest.java
index 642e269..0f2aadf 100644
--- a/src/test/java/com/android/tools/r8/keepanno/MembersAnnotatedByPatternsTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/MembersAnnotatedByPatternsTest.java
@@ -11,8 +11,8 @@
 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.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.ClassNamePattern;
-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;
@@ -29,6 +29,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.List;
+import org.checkerframework.checker.units.qual.A;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -122,19 +123,23 @@
           classConstant = OnMembers.class,
           kind = KeepItemKind.CLASS_AND_MEMBERS,
           memberAnnotatedByClassConstant = A.class,
-          constraintAdditions = {KeepConstraint.ANNOTATIONS}),
+          constrainAnnotations = @AnnotationPattern(constant = A.class)),
       @KeepTarget(
           classConstant = OnFields.class,
           kind = KeepItemKind.CLASS_AND_FIELDS,
           fieldAnnotatedByClassName =
               "com.android.tools.r8.keepanno.MembersAnnotatedByPatternsTest$B",
-          constraintAdditions = {KeepConstraint.ANNOTATIONS}),
+          constrainAnnotations =
+              @AnnotationPattern(
+                  name = "com.android.tools.r8.keepanno.MembersAnnotatedByPatternsTest$B")),
       @KeepTarget(
           classConstant = OnMethods.class,
           kind = KeepItemKind.CLASS_AND_METHODS,
           methodAnnotatedByClassNamePattern =
               @ClassNamePattern(simpleName = "MembersAnnotatedByPatternsTest$C"),
-          constraintAdditions = {KeepConstraint.ANNOTATIONS})
+          constrainAnnotations =
+              @AnnotationPattern(
+                  namePattern = @ClassNamePattern(simpleName = "MembersAnnotatedByPatternsTest$C")))
     })
     public void foo(Class<?> clazz) throws Exception {
       for (Field field : clazz.getDeclaredFields()) {
diff --git a/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionAnnotationsDocumentationTest.java b/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionAnnotationsDocumentationTest.java
new file mode 100644
index 0000000..a694a82
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/doctests/UsesReflectionAnnotationsDocumentationTest.java
@@ -0,0 +1,159 @@
+// 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;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+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.AnnotationPattern;
+import com.android.tools.r8.keepanno.annotations.KeepConstraint;
+import com.android.tools.r8.keepanno.annotations.KeepTarget;
+import com.android.tools.r8.keepanno.annotations.UsesReflection;
+import com.android.tools.r8.keepanno.doctests.UsesReflectionAnnotationsDocumentationTest.Example1.MyAnnotationPrinter.MyClass;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.google.common.collect.ImmutableList;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+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 UsesReflectionAnnotationsDocumentationTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("fieldOne = 1", "fieldTwo = 2");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public UsesReflectionAnnotationsDocumentationTest(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);
+  }
+
+  @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)
+        .inspect(
+            inspector -> {
+              ClassSubject clazz = inspector.clazz(MyClass.class);
+              assertThat(clazz.uniqueFieldWithOriginalName("mFieldOne"), isPresentAndRenamed());
+              assertThat(clazz.uniqueFieldWithOriginalName("mFieldTwo"), isPresentAndRenamed());
+              assertThat(clazz.uniqueFieldWithOriginalName("mFieldThree"), isAbsent());
+            });
+  }
+
+  public List<Class<?>> getExampleClasses() {
+    return ImmutableList.of(Example1.class);
+  }
+
+  static class Example1 {
+
+    /* INCLUDE DOC: UsesReflectionOnAnnotations
+    If your program is reflectively inspecting annotations on classes, methods or fields, you
+    will need to declare additional "annotation constraints" about what assumptions are made
+    about the annotations.
+
+    In the following example, we have defined an annotation that will record the printing name we
+    would like to use for fields instead of printing the concrete field name. That may be useful
+    so that the field can be renamed to follow coding conventions for example.
+
+    We are only interested in matching objects that contain fields annotated by `MyNameAnnotation`,
+    that is specified using `@KeepTarget#fieldAnnotatedByClassConstant`.
+
+    At runtime we need to be able to find the annotation too, so we add a constraint on the
+    annotation using `@KeepTarget#constrainAnnotations`.
+
+    Finally, for the sake of example, we don't actually care about the name of the fields
+    themselves, so we explicitly declare the smaller set of constraints to be
+    `@KeepConstraint#LOOKUP` since we must find the fields via `Class.getDeclaredFields` as well as
+    `@KeepConstraint#VISIBILITY_RELAX` and `@KeepConstraint#FIELD_GET` in order to be able to get
+    the actual field value without accessibility errors.
+
+    The effect is that the default constraint `@KeepConstraint#NAME` is not specified which allows
+    the shrinker to rename the fields at will.
+    INCLUDE END */
+
+    static
+    // INCLUDE CODE: UsesReflectionOnAnnotations
+    public class MyAnnotationPrinter {
+
+      @Target(ElementType.FIELD)
+      @Retention(RetentionPolicy.RUNTIME)
+      public @interface MyNameAnnotation {
+        String value();
+      }
+
+      public static class MyClass {
+        @MyNameAnnotation("fieldOne")
+        public int mFieldOne = 1;
+
+        @MyNameAnnotation("fieldTwo")
+        public int mFieldTwo = 2;
+
+        public int mFieldThree = 3;
+      }
+
+      @UsesReflection(
+          @KeepTarget(
+              fieldAnnotatedByClassConstant = MyNameAnnotation.class,
+              constrainAnnotations = @AnnotationPattern(constant = MyNameAnnotation.class),
+              constraints = {
+                KeepConstraint.LOOKUP,
+                KeepConstraint.VISIBILITY_RELAX,
+                KeepConstraint.FIELD_GET
+              }))
+      public void printMyNameAnnotatedFields(Object obj) throws Exception {
+        for (Field field : obj.getClass().getDeclaredFields()) {
+          if (field.isAnnotationPresent(MyNameAnnotation.class)) {
+            System.out.println(
+                field.getAnnotation(MyNameAnnotation.class).value() + " = " + field.get(obj));
+          }
+        }
+      }
+    }
+
+    // INCLUDE END
+
+    static void run() throws Exception {
+      new MyAnnotationPrinter().printMyNameAnnotatedFields(new MyAnnotationPrinter.MyClass());
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) throws Exception {
+      Example1.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 9376fa3..c2dec45 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
@@ -7,6 +7,7 @@
 import static com.android.tools.r8.keepanno.utils.KeepItemAnnotationGenerator.quote;
 
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.keepanno.annotations.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.FieldAccessFlags;
 import com.android.tools.r8.keepanno.annotations.KeepBinding;
 import com.android.tools.r8.keepanno.annotations.KeepCondition;
@@ -17,11 +18,14 @@
 import com.android.tools.r8.keepanno.annotations.KeepTarget;
 import com.android.tools.r8.keepanno.annotations.MemberAccessFlags;
 import com.android.tools.r8.keepanno.annotations.MethodAccessFlags;
+import com.android.tools.r8.keepanno.annotations.StringPattern;
+import com.android.tools.r8.keepanno.annotations.TypePattern;
 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.UsesReflectionAnnotationsDocumentationTest;
 import com.android.tools.r8.keepanno.doctests.UsesReflectionDocumentationTest;
 import com.android.tools.r8.keepanno.utils.KeepItemAnnotationGenerator.Generator;
 import com.android.tools.r8.utils.FileUtils;
@@ -86,6 +90,9 @@
             UsedByReflection.class,
             UsedByNative.class,
             KeepForApi.class,
+            StringPattern.class,
+            TypePattern.class,
+            AnnotationPattern.class,
             // Enums.
             KeepConstraint.class,
             KeepItemKind.class,
@@ -94,6 +101,7 @@
             FieldAccessFlags.class);
     populateCodeAndDocReplacements(
         UsesReflectionDocumentationTest.class,
+        UsesReflectionAnnotationsDocumentationTest.class,
         ForApiDocumentationTest.class,
         MainMethodsDocumentationTest.class);
   }
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 0852bde..475813b 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
@@ -7,6 +7,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.cfmethodgeneration.CodeGenerationBase;
+import com.android.tools.r8.keepanno.annotations.AnnotationPattern;
 import com.android.tools.r8.keepanno.annotations.CheckOptimizedOut;
 import com.android.tools.r8.keepanno.annotations.CheckRemoved;
 import com.android.tools.r8.keepanno.annotations.ClassNamePattern;
@@ -301,6 +302,7 @@
     private static String MEMBER_ANNOTATED_BY_GROUP = "member-annotated-by";
     private static String METHOD_ANNOTATED_BY_GROUP = "method-annotated-by";
     private static String FIELD_ANNOTATED_BY_GROUP = "field-annotated-by";
+    private static String ANNOTATION_NAME_GROUP = "annotation-name";
 
     private Group createDescriptionGroup() {
       return new Group("description")
@@ -487,12 +489,13 @@
               docLink(KeepItemKind.ONLY_MEMBERS) + " otherwise.");
     }
 
-    private Group getKeepConstraintsGroup() {
-      return new Group(CONSTRAINTS_GROUP).addMember(constraints()).addMember(constraintAdditions());
+    private void forEachKeepConstraintGroups(Consumer<Group> fn) {
+      fn.accept(getKeepConstraintsGroup());
+      fn.accept(new Group("constrain-annotations").addMember(constrainAnnotations()));
     }
 
-    private static String docLinkList(Enum<?>... values) {
-      return StringUtils.join(", ", values, v -> docLink(v), BraceType.TUBORG);
+    private Group getKeepConstraintsGroup() {
+      return new Group(CONSTRAINTS_GROUP).addMember(constraints()).addMember(constraintAdditions());
     }
 
     private static GroupMember constraints() {
@@ -527,6 +530,69 @@
           .defaultArrayEmpty(KeepConstraint.class);
     }
 
+    private static GroupMember constrainAnnotations() {
+      return new GroupMember("constrainAnnotations")
+          .setDocTitle("Patterns for annotations that must remain on the item.")
+          .addParagraph(
+              "The annotations matching any of the patterns must remain on the item",
+              "if the annotation types remain in the program.")
+          .addParagraph(
+              "Note that if the annotation types themselves are unused/removed,",
+              "then their references on the item will be removed too.",
+              "If the annotation types themselves are used reflectively then they too need a",
+              "keep annotation or rule to ensure they remain in the program.")
+          .addParagraph(
+              "By default no annotation patterns are defined and no annotations are required to",
+              "remain.")
+          .setDocReturn("Annotation patterns")
+          .defaultArrayEmpty(AnnotationPattern.class);
+    }
+
+    private Group annotationNameGroup() {
+      return new Group(ANNOTATION_NAME_GROUP)
+          .addMember(annotationName())
+          .addMember(annotationConstant())
+          .addMember(annotationNamePattern())
+          .addDocFooterParagraph(
+              "If none are specified the default is to match any annotation name.");
+    }
+
+    private GroupMember annotationName() {
+      return new GroupMember("name")
+          .setDocTitle(
+              "Define the " + ANNOTATION_NAME_GROUP + " pattern by fully qualified class name.")
+          .setDocReturn("The qualified class name that defines the annotation.")
+          .defaultEmptyString();
+    }
+
+    private GroupMember annotationConstant() {
+      return new GroupMember("constant")
+          .setDocTitle(
+              "Define the "
+                  + ANNOTATION_NAME_GROUP
+                  + " pattern by reference to a {@code Class} constant.")
+          .setDocReturn("The Class constant that defines the annotation.")
+          .defaultObjectClass();
+    }
+
+    private GroupMember annotationNamePattern() {
+      return new GroupMember("namePattern")
+          .setDocTitle(
+              "Define the "
+                  + ANNOTATION_NAME_GROUP
+                  + " pattern by reference to a class-name pattern.")
+          .setDocReturn("The class-name pattern that defines the annotation.")
+          .defaultValue(ClassNamePattern.class, DEFAULT_INVALID_CLASS_NAME_PATTERN);
+    }
+
+    private static GroupMember annotationRetention() {
+      return new GroupMember("retention")
+          .setDocTitle("Specify which retention policies must be set for the annotations.")
+          .addParagraph("Matches annotations with matching retention policies")
+          .setDocReturn("Retention policies. By default {@code RetentionPolicy.RUNTIME}.")
+          .defaultArrayValue(RetentionPolicy.class, "RetentionPolicy.RUNTIME");
+    }
+
     private GroupMember bindingName() {
       return new GroupMember("bindingName")
           .setDocTitle(
@@ -1024,6 +1090,30 @@
       println("}");
     }
 
+    private void generateAnnotationPattern() {
+      printCopyRight(2024);
+      printPackage("annotations");
+      printImports(ANNOTATION_IMPORTS);
+      DocPrinter.printer()
+          .setDocTitle("A pattern structure for matching annotations.")
+          .addParagraph(
+              "If no properties are set, the default pattern matches any annotation",
+              "with a runtime retention policy.")
+          .printDoc(this::println);
+      println("@Target(ElementType.ANNOTATION_TYPE)");
+      println("@Retention(RetentionPolicy.CLASS)");
+      println("public @interface " + simpleName(AnnotationPattern.class) + " {");
+      println();
+      withIndent(
+          () -> {
+            annotationNameGroup().generate(this);
+            println();
+            annotationRetention().generate(this);
+          });
+      println();
+      println("}");
+    }
+
     private void generateKeepBinding() {
       printCopyRight(2022);
       printPackage("annotations");
@@ -1073,8 +1163,11 @@
           () -> {
             getKindGroup().generate(this);
             println();
-            getKeepConstraintsGroup().generate(this);
-            println();
+            forEachKeepConstraintGroups(
+                g -> {
+                  g.generate(this);
+                  println();
+                });
             generateClassAndMemberPropertiesWithClassAndMemberBinding();
           });
       println();
@@ -1294,8 +1387,11 @@
                         + " if annotating a member.")
                 .generate(this);
             println();
-            getKeepConstraintsGroup().generate(this);
-            println();
+            forEachKeepConstraintGroups(
+                g -> {
+                  g.generate(this);
+                  println();
+                });
             generateMemberPropertiesNoBinding();
           });
       println();
@@ -1318,6 +1414,10 @@
       return "{@link " + simpleName(kind.getClass()) + "#" + kind.name() + "}";
     }
 
+    private static String docLinkList(Enum<?>... values) {
+      return StringUtils.join(", ", values, v -> docLink(v), BraceType.TUBORG);
+    }
+
     private void generateConstants() {
       printCopyRight(2023);
       printPackage("ast");
@@ -1356,6 +1456,7 @@
             generateStringPatternConstants();
             generateTypePatternConstants();
             generateClassNamePatternConstants();
+            generateAnnotationPatternConstants();
           });
       println("}");
     }
@@ -1509,7 +1610,7 @@
           () -> {
             generateAnnotationConstants(KeepTarget.class);
             getKindGroup().generateConstants(this);
-            getKeepConstraintsGroup().generateConstants(this);
+            forEachKeepConstraintGroups(g -> g.generateConstants(this));
           });
       println("}");
       println();
@@ -1663,6 +1764,18 @@
       println();
     }
 
+    private void generateAnnotationPatternConstants() {
+      println("public static final class AnnotationPattern {");
+      withIndent(
+          () -> {
+            generateAnnotationConstants(AnnotationPattern.class);
+            annotationNameGroup().generateConstants(this);
+            annotationRetention().generateConstants(this);
+          });
+      println("}");
+      println();
+    }
+
     private static void writeFile(Path file, Consumer<Generator> fn) throws IOException {
       ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
       PrintStream printStream = new PrintStream(byteStream);
@@ -1691,6 +1804,7 @@
       writeFile(source(annoPkg, StringPattern.class), Generator::generateStringPattern);
       writeFile(source(annoPkg, TypePattern.class), Generator::generateTypePattern);
       writeFile(source(annoPkg, ClassNamePattern.class), Generator::generateClassNamePattern);
+      writeFile(source(annoPkg, AnnotationPattern.class), Generator::generateAnnotationPattern);
       writeFile(source(annoPkg, KeepBinding.class), Generator::generateKeepBinding);
       writeFile(source(annoPkg, KeepTarget.class), Generator::generateKeepTarget);
       writeFile(source(annoPkg, KeepCondition.class), Generator::generateKeepCondition);
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexApi21Test.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexApi21Test.java
new file mode 100644
index 0000000..b9c3c87
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexApi21Test.java
@@ -0,0 +1,111 @@
+// 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.maindexlist;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+// Test for allowing main-dex support for API 21 / L (See b//320893283).
+@RunWith(Parameterized.class)
+public class MainDexApi21Test extends TestBase {
+
+  static class TestClassA {}
+
+  static class TestClassB {}
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public MainDexApi21Test(TestParameters parameters) {
+    parameters.assertNoneRuntime();
+  }
+
+  static class TestConsumer extends DexIndexedConsumer.ForwardingConsumer {
+
+    Map<Integer, byte[]> data = new HashMap<>();
+    Map<Integer, Set<String>> descriptors = new HashMap<>();
+
+    public TestConsumer() {
+      super(null);
+    }
+
+    @Override
+    public synchronized void accept(
+        int fileIndex, ByteDataView data, Set<String> descriptors, DiagnosticsHandler handler) {
+      assertNull(this.data.put(fileIndex, data.copyByteData()));
+      assertNull(this.descriptors.put(fileIndex, descriptors));
+    }
+  }
+
+  @Test
+  public void testWithoutMainDexInputs() throws Exception {
+    // Test to ensure that running at API 21 / L without any main-dex content works.
+    // Since L does support native multdex the compiler should not require any main-dex inputs.
+    TestConsumer programConsumer = new TestConsumer();
+    testForD8()
+        .setMinApi(AndroidApiLevel.L)
+        .addProgramClasses(ImmutableList.of(TestClassA.class, TestClassB.class))
+        .setProgramConsumer(programConsumer)
+        .compile();
+    assertEquals(1, programConsumer.data.size());
+    assertEquals(1, programConsumer.descriptors.size());
+    assertEquals(
+        ImmutableSet.of(descriptor(TestClassA.class), descriptor(TestClassB.class)),
+        programConsumer.descriptors.get(0));
+  }
+
+  @Test
+  public void testWithMainDexRules() throws Exception {
+    // Test to ensure that running at API 21 / L with main-dex rules will actually produce a
+    // main-dex file. Debug mode will compile to a minimal main-dex, so we will observe two files.
+    TestConsumer programConsumer = new TestConsumer();
+    testForD8()
+        .setMinApi(AndroidApiLevel.L)
+        .addProgramClasses(ImmutableList.of(TestClassA.class, TestClassB.class))
+        .addMainDexKeepClassAndMemberRules(TestClassB.class)
+        .setProgramConsumer(programConsumer)
+        .compile();
+    assertEquals(2, programConsumer.data.size());
+    assertEquals(2, programConsumer.descriptors.size());
+    assertEquals(ImmutableSet.of(descriptor(TestClassB.class)), programConsumer.descriptors.get(0));
+    assertEquals(ImmutableSet.of(descriptor(TestClassA.class)), programConsumer.descriptors.get(1));
+  }
+
+  @Test
+  public void testWithMainDexList() throws Exception {
+    // Test to ensure that running at API 21 / L with main-dex list will actually produce a
+    // main-dex file. Debug mode will compile to a minimal main-dex, so we will observe two files.
+    TestConsumer programConsumer = new TestConsumer();
+    testForD8()
+        .setMinApi(AndroidApiLevel.L)
+        .addProgramClasses(ImmutableList.of(TestClassA.class, TestClassB.class))
+        .addMainDexListClasses(TestClassB.class)
+        .setProgramConsumer(programConsumer)
+        .compile();
+    assertEquals(2, programConsumer.data.size());
+    assertEquals(2, programConsumer.descriptors.size());
+    assertEquals(ImmutableSet.of(descriptor(TestClassB.class)), programConsumer.descriptors.get(0));
+    assertEquals(ImmutableSet.of(descriptor(TestClassA.class)), programConsumer.descriptors.get(1));
+  }
+}
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
index 82ae38f..26a4674 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfArraysTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfArraysTest.java
@@ -63,13 +63,16 @@
   }
 
   private void inspect(CodeInspector inspector) {
+    int canUseStrings = canUseFilledNewArrayOfStringObjects(parameters) ? 1 : 0;
+    int canUseObjects = canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0;
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
-        2
-            + (canUseFilledNewArrayOfStringObjects(parameters) ? 2 : 0)
-            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 2 : 0),
+        2 + 2 * canUseStrings + 2 * canUseObjects,
         2);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 2, 2);
+    inspect(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
+        2 + 2 * canUseStrings + 1 * canUseObjects,
+        compilationMode.isDebug() ? 10 : 11);
   }
 
   @Test
@@ -129,32 +132,32 @@
 
     @NeverInline
     public static void m2() {
+      Object[] array = null;
       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();
+        array = new Object[9];
+        array[0] = new byte[] {(byte) 1};
+        array[1] = new short[] {(short) 1};
+        array[2] = new int[] {1};
+        array[3] = new long[] {1L};
+        array[4] = new char[] {(char) 1};
+        array[5] = new float[] {1.0f};
+        array[6] = new double[] {1.0d};
+        array[7] = new String[] {"one"};
+        array[8] =
+            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"},
+            };
       } catch (Exception e) {
-        throw new RuntimeException();
       }
+      printArray(array);
+      System.out.println();
     }
 
     @NeverInline
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
index 63fec32..b37c8a2 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfConstClassArraysTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfConstClassArraysTest.java
@@ -62,10 +62,7 @@
 
   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);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5, 4);
   }
 
   @Test
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
index edc54de..c429641 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfIntArraysTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfIntArraysTest.java
@@ -59,15 +59,15 @@
 
   private void inspect(CodeInspector inspector) {
     // This test use smaller int arrays, where filled-new-array is preferred over filled-array-data.
+    int canUseObjects = canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0;
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
-        4 + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0),
+        4 + 1 * canUseObjects,
         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);
+        4 + 1 * canUseObjects,
+        4);
   }
 
   @Test
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
index 1934f24..d238b1a 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfStringArraysTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayOfStringArraysTest.java
@@ -63,28 +63,27 @@
   }
 
   private void inspect(CodeInspector inspector) {
+    int canUseStrings = canUseFilledNewArrayOfStringObjects(parameters) ? 1 : 0;
+    int canUseObjects = canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0;
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
-        (canUseFilledNewArrayOfStringObjects(parameters) ? 4 : 0)
-            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0),
+        4 * canUseStrings + 1 * canUseObjects,
         1);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
-        0,
-        compilationMode.isDebug() ? 2 : 1);
+        4 * canUseStrings + 1 * canUseObjects,
+        4);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"),
-        (canUseFilledNewArrayOfStringObjects(parameters) ? 4 : 0)
-            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 5 : 0),
+        4 * canUseStrings + 5 * canUseObjects,
         5);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m4"),
-        0,
-        compilationMode.isDebug() ? 2 : 1);
+        4 * canUseStrings + 5 * canUseObjects,
+        5);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m5"),
-        (canUseFilledNewArrayOfStringObjects(parameters) ? 4 : 0)
-            + (canUseFilledNewArrayOfNonStringObjects(parameters) ? 1 : 0),
+        4 * canUseStrings + 1 * canUseObjects,
         compilationMode.isDebug() ? 6 : 4);
   }
 
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 4b6e64c..c27a171 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
@@ -10,7 +10,6 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-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;
@@ -46,9 +45,8 @@
     EXPECTING_APUTOBJECT
   }
 
-  private void inspect(MethodSubject method, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(MethodSubject method) {
+    boolean expectingFilledNewArray = canUseFilledNewArrayOfNonStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : 5,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -78,8 +76,8 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), false);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), true);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"));
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"));
   }
 
   @Test
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 3a364dd..7d8bba7 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
@@ -46,10 +46,8 @@
 
   private static final String EXPECTED_OUTPUT = StringUtils.lines("100", "104");
 
-  private void inspect(
-      MethodSubject method, int constClasses, int puts, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(MethodSubject method, int constClasses, int puts) {
+    boolean expectingFilledNewArray = canUseFilledNewArrayOfNonStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -68,12 +66,11 @@
   }
 
   private void inspectD8(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 1, 100, false);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 1, 100);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
         maxMaterializingConstants == 2 ? 98 : 26,
-        104,
-        false);
+        104);
   }
 
   @Test
@@ -89,12 +86,11 @@
   }
 
   private void inspectR8(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 1, 100, false);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 1, 100);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
         maxMaterializingConstants == 2 ? 32 : 26,
-        104,
-        false);
+        104);
   }
 
   @Test
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 c7f847b..3c7976f 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
@@ -52,9 +52,8 @@
     EXPECTING_APUTOBJECT
   }
 
-  private void inspect(MethodSubject method, int puts, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(MethodSubject method, int puts) {
+    boolean expectingFilledNewArray = canUseFilledNewArrayOfNonStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -86,9 +85,9 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5, false);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5, true);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"), 100, false);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"), 100);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/FilledArrayDataWithCatchHandlerTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/FilledArrayDataWithCatchHandlerTest.java
deleted file mode 100644
index e28a4fc..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/FilledArrayDataWithCatchHandlerTest.java
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (c) 2022, 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 com.android.tools.r8.cf.methodhandles.fields.ClassFieldMethodHandleTest.Main.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.dex.code.DexFillArrayData;
-import com.android.tools.r8.dex.code.DexNewArray;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.InstructionOffsetSubject;
-import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class FilledArrayDataWithCatchHandlerTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("1");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
-  }
-
-  public FilledArrayDataWithCatchHandlerTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void test() throws Exception {
-    testForRuntime(parameters)
-        .addInnerClasses(FilledArrayDataWithCatchHandlerTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testReleaseD8() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    testForD8(parameters.getBackend())
-        .release()
-        .setMinApi(parameters)
-        .addInnerClasses(FilledArrayDataWithCatchHandlerTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkInstructions);
-  }
-
-  private void checkInstructions(CodeInspector inspector) {
-    MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithFinalName("foo");
-    List<InstructionSubject> newArrays =
-        foo.streamInstructions()
-            .filter(i -> i.asDexInstruction().getInstruction() instanceof DexNewArray)
-            .collect(Collectors.toList());
-    assertEquals(1, newArrays.size());
-
-    List<InstructionSubject> fillArrays =
-        foo.streamInstructions()
-            .filter(i -> i.asDexInstruction().getInstruction() instanceof DexFillArrayData)
-            .collect(Collectors.toList());
-    assertEquals(1, fillArrays.size());
-
-    InstructionOffsetSubject offsetNew = newArrays.get(0).getOffset(foo);
-    InstructionOffsetSubject offsetFill = newArrays.get(0).getOffset(foo);
-    assertTrue(
-        foo.streamTryCatches()
-            .allMatch(r -> r.getRange().includes(offsetNew) && r.getRange().includes(offsetFill)));
-  }
-
-  static class TestClass {
-
-    public static int foo() {
-      int value = 1;
-      int[] array = null;
-      try {
-        array = new int[6];
-      } catch (RuntimeException e) {
-        return array[0];
-      }
-      array[0] = value;
-      array[1] = value;
-      array[2] = value;
-      array[3] = value;
-      array[4] = value;
-      array[5] = value;
-      return array[5];
-    }
-
-    public static void main(String[] args) {
-      System.out.println(foo());
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayInCatchRangeTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayInCatchRangeTest.java
deleted file mode 100644
index f9e3ffe..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayInCatchRangeTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (c) 2022, 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 static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.dex.code.DexFilledNewArray;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.InstructionOffsetSubject;
-import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class NewArrayInCatchRangeTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("1");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
-  }
-
-  public NewArrayInCatchRangeTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void test() throws Exception {
-    testForRuntime(parameters)
-        .addInnerClasses(NewArrayInCatchRangeTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testReleaseD8() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    testForD8(parameters.getBackend())
-        .release()
-        .setMinApi(parameters)
-        .addInnerClasses(NewArrayInCatchRangeTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkInstructions);
-  }
-
-  private void checkInstructions(CodeInspector inspector) {
-    MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithFinalName("foo");
-    List<InstructionSubject> filledArrayInstructions =
-        foo.streamInstructions()
-            .filter(i -> i.asDexInstruction().getInstruction() instanceof DexFilledNewArray)
-            .collect(Collectors.toList());
-    assertEquals(1, filledArrayInstructions.size());
-    InstructionOffsetSubject offset = filledArrayInstructions.get(0).getOffset(foo);
-    assertTrue(foo.streamTryCatches().allMatch(r -> r.getRange().includes(offset)));
-  }
-
-  static class TestClass {
-
-    public static int foo() {
-      int value = 1;
-      int[] array = null;
-      try {
-        array = new int[1];
-      } catch (Exception e) {
-        return array == null ? -1 : array.length;
-      }
-      array[0] = value;
-      return array[0];
-    }
-
-    public static void main(String[] args) {
-      System.out.println(foo());
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayInTwoCatchRangesTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayInTwoCatchRangesTest.java
deleted file mode 100644
index 3ecd9de..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayInTwoCatchRangesTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) 2022, 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.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.dex.code.DexFilledNewArray;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class NewArrayInTwoCatchRangesTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("1");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
-  }
-
-  public NewArrayInTwoCatchRangesTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void test() throws Exception {
-    testForRuntime(parameters)
-        .addInnerClasses(NewArrayInTwoCatchRangesTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testReleaseD8() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    testForD8(parameters.getBackend())
-        .release()
-        .setMinApi(parameters)
-        .addInnerClasses(NewArrayInTwoCatchRangesTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkHasFilledNewArray);
-  }
-
-  private void checkHasFilledNewArray(CodeInspector inspector) {
-    MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithFinalName("foo");
-    assertTrue(
-        foo.streamInstructions()
-            .anyMatch(i -> i.asDexInstruction().getInstruction() instanceof DexFilledNewArray));
-  }
-
-  static class TestClass {
-
-    public static int foo() {
-      int value = 1;
-      try {
-        int[] array = new int[2];
-        try {
-          array[0] = value;
-          try {
-            array[1] = value;
-          } catch (RuntimeException e) {
-            return array[1];
-          }
-        } catch (RuntimeException e) {
-          return array[0];
-        }
-        return array[0];
-      } catch (RuntimeException e) {
-        return 42;
-      }
-    }
-
-    public static void main(String[] args) {
-      System.out.println(foo());
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayMonitorTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayMonitorTest.java
deleted file mode 100644
index c7e3b2a..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayMonitorTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) 2022, 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 static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.dex.code.DexFilledNewArray;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.InstructionOffsetSubject;
-import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class NewArrayMonitorTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("1");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
-  }
-
-  public NewArrayMonitorTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void test() throws Exception {
-    testForRuntime(parameters)
-        .addInnerClasses(NewArrayMonitorTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testReleaseD8() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    testForD8(parameters.getBackend())
-        .release()
-        .setMinApi(parameters)
-        .addInnerClasses(NewArrayMonitorTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkInstructions);
-  }
-
-  private void checkInstructions(CodeInspector inspector) {
-    MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithFinalName("foo");
-    List<InstructionSubject> filledArrayInstructions =
-        foo.streamInstructions()
-            .filter(i -> i.asDexInstruction().getInstruction() instanceof DexFilledNewArray)
-            .collect(Collectors.toList());
-    assertEquals(1, filledArrayInstructions.size());
-    InstructionOffsetSubject offset = filledArrayInstructions.get(0).getOffset(foo);
-    assertTrue(foo.streamTryCatches().allMatch(r -> r.getRange().includes(offset)));
-  }
-
-  static class TestClass {
-
-    public static synchronized int foo() {
-      int value = 1;
-      int[] array = new int[1];
-      try {
-        array[0] = value;
-      } catch (RuntimeException e) {
-        return array[0];
-      }
-      return array[0];
-    }
-
-    public static void main(String[] args) {
-      System.out.println(foo());
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayOfInaccessibleTypeTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayOfInaccessibleTypeTest.java
new file mode 100644
index 0000000..2282a4a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayOfInaccessibleTypeTest.java
@@ -0,0 +1,99 @@
+// 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 com.android.tools.r8.NoAccessModification;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.List;
+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;
+import org.objectweb.asm.MethodVisitor;
+
+@RunWith(Parameterized.class)
+public class NewArrayOfInaccessibleTypeTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    parameters.assumeCfRuntime();
+    testForJvm(parameters)
+        .addProgramClassFileData(getProgramClassFileData())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(IllegalAccessError.class);
+  }
+
+  @Test
+  public void testD8Release() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8()
+        .addProgramClassFileData(getProgramClassFileData())
+        .release()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(IllegalAccessError.class);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(getProgramClassFileData())
+        .addKeepMainRule(Main.class)
+        .enableNoAccessModificationAnnotationsForClasses()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(IllegalAccessError.class);
+  }
+
+  private static List<byte[]> getProgramClassFileData() throws Exception {
+    return ImmutableList.of(
+        transformer(Main.class)
+            .transformTypeInsnInMethod(
+                "main",
+                (int opcode, String type, MethodVisitor visitor) ->
+                    visitor.visitTypeInsn(
+                        opcode,
+                        type.equals(binaryName(Inaccessible.class)) ? "pkg/Inaccessible" : type))
+            .replaceClassDescriptorInMethodInstructions(
+                descriptor(Inaccessible.class), "Lpkg/Inaccessible;")
+            .transform(),
+        transformer(Inaccessible.class).setClassDescriptor("Lpkg/Inaccessible;").transform());
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      // Moving the array creation into the else branch would change semantics as the code then no
+      // longer throws IllegalAccessError.
+      Inaccessible[] array = new Inaccessible[3];
+      array[0] = null;
+      array[1] = null;
+      if (System.currentTimeMillis() > 0) {
+        throw new RuntimeException("Unexpected");
+      } else {
+        array[2] = null;
+        System.out.println(Arrays.toString(array));
+      }
+    }
+  }
+
+  // TODO(b/320445632): Access modifier should not publicize items with illegal accesses.
+  @NoAccessModification
+  static class /*pkg.*/ Inaccessible {}
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayPutInCatchRangeTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayPutInCatchRangeTest.java
deleted file mode 100644
index a3fd2da..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArrayPutInCatchRangeTest.java
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2022, 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 static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.dex.code.DexFilledNewArray;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.Collections;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-// Regression test for issue found in b/259986613
-@RunWith(Parameterized.class)
-public class NewArrayPutInCatchRangeTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("1");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
-  }
-
-  public NewArrayPutInCatchRangeTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void test() throws Exception {
-    testForRuntime(parameters)
-        .addInnerClasses(NewArrayPutInCatchRangeTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testReleaseD8() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    testForD8(parameters.getBackend())
-        .release()
-        .setMinApi(parameters)
-        .addInnerClasses(NewArrayPutInCatchRangeTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkHasFilledNewArray);
-  }
-
-  private void checkHasFilledNewArray(CodeInspector inspector) {
-    MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithFinalName("foo");
-    assertTrue(
-        foo.streamInstructions()
-            .anyMatch(i -> i.asDexInstruction().getInstruction() instanceof DexFilledNewArray));
-    assertEquals(Collections.emptyList(), foo.streamTryCatches().collect(Collectors.toList()));
-  }
-
-  static class TestClass {
-
-    public static int foo() {
-      int value = 1;
-      int[] array = new int[1];
-      try {
-        array[0] = value;
-      } catch (RuntimeException e) {
-        return array[0];
-      }
-      return array[0];
-    }
-
-    public static void main(String[] args) {
-      System.out.println(foo());
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArraySynchronizedBlockTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArraySynchronizedBlockTest.java
index c552566..5ed624e 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/NewArraySynchronizedBlockTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/NewArraySynchronizedBlockTest.java
@@ -72,7 +72,7 @@
       int[] array;
       synchronized (TestClass.class) {
         array = new int[1];
-      } // monitor exit here prohibits optimization as its failure could observe the lack of init.
+      }
       array[0] = value;
       return array[0];
     }
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 c80436c..7011411 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
@@ -63,7 +63,18 @@
     "[1, null, 2]",
     "[1, null, 2]",
     "[1]",
-    "[1, 2]",
+    "[1, 2, 3]",
+    "[2, 2, 2]",
+    "[6, 7]",
+    "[7]",
+    "[3, 4]",
+    "[99]",
+    "[0, 1]",
+    "[0, 1]",
+    "[0, 1]",
+    "[0, 1]",
+    "[0, 1]",
+    "[0, 1]",
     "[1, 2, 3, 4, 5]",
     "[1]",
     "[a, 1, null, d, e, f]",
@@ -91,12 +102,16 @@
     "[0, 1, 2, 3, 4]",
     "[4, 0, 0, 0, 0]",
     "[4, 1, 2, 3, 4]",
+    "[9]",
+    "[*]",
+    "[*]",
+    "finally: [1, 2]",
+    "[1, 2]",
+    "[1, 2]",
+    "[1, 2]",
+    "[1, 2]",
     "[0, 1, 2]",
     "[0]",
-    "[0, 1, 2]",
-    "[1, 2, 3]",
-    "[1, 2, 3, 4, 5, 6]",
-    "[0]",
     "[null, null]",
   };
 
@@ -176,6 +191,20 @@
         mainClass.uniqueMethodWithOriginalName("interfaceArrayWithRawObject");
 
     MethodSubject phiFilledNewArray = mainClass.uniqueMethodWithOriginalName("phiFilledNewArray");
+    MethodSubject phiFilledNewArrayBlocks =
+        mainClass.uniqueMethodWithOriginalName("phiFilledNewArrayBlocks");
+    MethodSubject arrayWithDominatingPhiUsers =
+        mainClass.uniqueMethodWithOriginalName("arrayWithDominatingPhiUsers");
+    MethodSubject arrayWithNonDominatingPhiUsers =
+        mainClass.uniqueMethodWithOriginalName("arrayWithNonDominatingPhiUsers");
+    MethodSubject phiWithExceptionalPhiUser =
+        mainClass.uniqueMethodWithOriginalName("phiWithExceptionalPhiUser");
+    MethodSubject phiWithNestedCatchHandler =
+        mainClass.uniqueMethodWithOriginalName("phiWithNestedCatchHandler");
+    MethodSubject multiUseArray = mainClass.uniqueMethodWithOriginalName("multiUseArray");
+    MethodSubject arrayWithHole = mainClass.uniqueMethodWithOriginalName("arrayWithHole");
+    MethodSubject reassignmentDoesNotOptimize =
+        mainClass.uniqueMethodWithOriginalName("reassignmentDoesNotOptimize");
     MethodSubject intsThatUseFilledNewArray =
         mainClass.uniqueMethodWithOriginalName("intsThatUseFilledNewArray");
     MethodSubject twoDimensionalArrays =
@@ -191,26 +220,60 @@
         mainClass.uniqueMethodWithOriginalName("arrayWithCorrectCountButIncompleteCoverage");
     MethodSubject arrayWithExtraInitialPuts =
         mainClass.uniqueMethodWithOriginalName("arrayWithExtraInitialPuts");
-    MethodSubject catchHandlerThrowing =
-        mainClass.uniqueMethodWithOriginalName("catchHandlerThrowing");
-    MethodSubject catchHandlerNonThrowingFilledNewArray =
-        mainClass.uniqueMethodWithOriginalName("catchHandlerNonThrowingFilledNewArray");
-    MethodSubject catchHandlerNonThrowingFillArrayData =
-        mainClass.uniqueMethodWithOriginalName("catchHandlerNonThrowingFillArrayData");
+    MethodSubject catchHandlerWithoutSideeffects =
+        mainClass.uniqueMethodWithOriginalName("catchHandlerWithoutSideeffects");
+    MethodSubject allocationWithCatchHandler =
+        mainClass.uniqueMethodWithOriginalName("allocationWithCatchHandler");
+    MethodSubject allocationWithoutCatchHandler =
+        mainClass.uniqueMethodWithOriginalName("allocationWithoutCatchHandler");
+    MethodSubject catchHandlerWithFinally =
+        mainClass.uniqueMethodWithOriginalName("catchHandlerWithFinally");
+    MethodSubject simpleSynchronized1 =
+        mainClass.uniqueMethodWithOriginalName("simpleSynchronized1");
+    MethodSubject simpleSynchronized2 =
+        mainClass.uniqueMethodWithOriginalName("simpleSynchronized2");
+    MethodSubject simpleSynchronized3 =
+        mainClass.uniqueMethodWithOriginalName("simpleSynchronized3");
+    MethodSubject simpleSynchronized4 =
+        mainClass.uniqueMethodWithOriginalName("simpleSynchronized4");
+    MethodSubject arrayInsideCatchHandler =
+        mainClass.uniqueMethodWithOriginalName("arrayInsideCatchHandler");
     MethodSubject assumedValues = mainClass.uniqueMethodWithOriginalName("assumedValues");
 
+    // The explicit assignments can't be collapsed without breaking the debugger's ability to
+    // visit each line.
+    Class<?> filledNewArrayInRelease =
+        compilationMode == CompilationMode.DEBUG ? DexNewArray.class : DexFilledNewArray.class;
+
     assertArrayTypes(arraysThatUseNewArrayEmpty, DexNewArray.class);
     assertArrayTypes(intsThatUseFilledNewArray, DexFilledNewArray.class);
     assertFilledArrayData(arraysThatUseFilledData);
-    assertFilledArrayData(catchHandlerNonThrowingFillArrayData);
 
-    if (compilationMode == CompilationMode.DEBUG) {
-      // The explicit assignments can't be collapsed without breaking the debugger's ability to
-      // visit each line.
-      assertArrayTypes(reversedArray, DexNewArray.class);
-    } else {
-      assertArrayTypes(reversedArray, DexFilledNewArray.class);
-    }
+    // Algorithm does not support out-of-order assignment.
+    assertArrayTypes(reversedArray, DexNewArray.class);
+    // Algorithm does not support assigning to array elements multiple times.
+    assertArrayTypes(reassignmentDoesNotOptimize, DexNewArray.class);
+    // Algorithm does not support default-initialized array elements.
+    assertArrayTypes(arrayWithHole, DexNewArray.class);
+    // ArrayPuts not dominated by return statement.
+    assertArrayTypes(phiFilledNewArrayBlocks, DexNewArray.class);
+    assertArrayTypes(arrayWithDominatingPhiUsers, filledNewArrayInRelease);
+    assertArrayTypes(arrayWithNonDominatingPhiUsers, DexNewArray.class);
+    assertArrayTypes(phiWithNestedCatchHandler, DexNewArray.class);
+    assertArrayTypes(phiWithExceptionalPhiUser, DexFilledNewArray.class, filledNewArrayInRelease);
+    // Not safe to change catch handlers.
+    assertArrayTypes(allocationWithoutCatchHandler, DexNewArray.class);
+    // Not safe to change catch handlers.
+    assertArrayTypes(allocationWithCatchHandler, DexNewArray.class);
+    assertArrayTypes(catchHandlerWithFinally, DexNewArray.class);
+    assertArrayTypes(simpleSynchronized1, DexFilledNewArray.class);
+    assertArrayTypes(simpleSynchronized2, DexFilledNewArray.class);
+    assertArrayTypes(simpleSynchronized3, DexNewArray.class);
+    assertArrayTypes(simpleSynchronized4, DexNewArray.class);
+    // Could be optimized if we had side-effect analysis of exceptional blocks.
+    assertArrayTypes(catchHandlerWithoutSideeffects, DexNewArray.class);
+    assertArrayTypes(arrayInsideCatchHandler, filledNewArrayInRelease);
+    assertArrayTypes(multiUseArray, filledNewArrayInRelease);
 
     if (!canUseFilledNewArrayOfStringObjects(parameters)) {
       assertArrayTypes(stringArrays, DexNewArray.class);
@@ -239,9 +302,7 @@
         assertArrayTypes(referenceArraysWithInterfaceImplementations, DexNewArray.class);
       }
 
-      // TODO(b/246971330): Add support for arrays whose values have conditionals.
-      // assertArrayTypes(phiFilledNewArray, DexFilledNewArray.class);
-
+      assertArrayTypes(phiFilledNewArray, DexFilledNewArray.class);
       assertArrayTypes(
           objectArraysFilledNewArrayRange, DexFilledNewArrayRange.class, DexNewArray.class);
 
@@ -261,9 +322,6 @@
     // haven't bothered.
     assertArrayTypes(arrayWithExtraInitialPuts, DexNewArray.class);
     assertArrayTypes(arrayWithCorrectCountButIncompleteCoverage, DexNewArray.class);
-
-    assertArrayTypes(catchHandlerThrowing, DexNewArray.class);
-    assertArrayTypes(catchHandlerNonThrowingFilledNewArray, DexFilledNewArray.class);
   }
 
   private static Predicate<InstructionSubject> isInstruction(List<Class<?>> allowlist) {
@@ -310,6 +368,14 @@
       referenceArraysWithInterfaceImplementations();
       interfaceArrayWithRawObject();
       phiFilledNewArray();
+      phiFilledNewArrayBlocks();
+      arrayWithDominatingPhiUsers();
+      arrayWithNonDominatingPhiUsers();
+      phiWithNestedCatchHandler();
+      phiWithExceptionalPhiUser();
+      multiUseArray();
+      arrayWithHole();
+      reassignmentDoesNotOptimize();
       intsThatUseFilledNewArray();
       twoDimensionalArrays();
       objectArraysFilledNewArrayRange();
@@ -318,9 +384,15 @@
       reversedArray();
       arrayWithCorrectCountButIncompleteCoverage();
       arrayWithExtraInitialPuts();
-      catchHandlerThrowing();
-      catchHandlerNonThrowingFilledNewArray();
-      catchHandlerNonThrowingFillArrayData();
+      arrayInsideCatchHandler();
+      allocationWithCatchHandler();
+      allocationWithoutCatchHandler();
+      catchHandlerWithFinally();
+      simpleSynchronized1();
+      simpleSynchronized2();
+      simpleSynchronized3();
+      simpleSynchronized4();
+      catchHandlerWithoutSideeffects();
       arrayIntoAnotherArray();
       assumedValues();
     }
@@ -411,21 +483,12 @@
     }
 
     @NeverInline
-    private static void catchHandlerNonThrowingFilledNewArray() {
+    private static void arrayInsideCatchHandler() {
       try {
-        int[] arr1 = {1, 2, 3};
+        // Test filled-new-array with a throwing instruction before the last array-put.
+        int[] arr = new int[1];
         System.currentTimeMillis();
-        System.out.println(Arrays.toString(arr1));
-      } catch (Throwable t) {
-        throw new RuntimeException(t);
-      }
-    }
-
-    @NeverInline
-    private static void catchHandlerNonThrowingFillArrayData() {
-      try {
-        int[] arr = {1, 2, 3, 4, 5, 6};
-        System.currentTimeMillis();
+        arr[0] = 9;
         System.out.println(Arrays.toString(arr));
       } catch (Throwable t) {
         throw new RuntimeException(t);
@@ -433,37 +496,115 @@
     }
 
     @NeverInline
-    private static void catchHandlerThrowing() {
-      int[] arr1 = new int[3];
-      arr1[0] = 0;
-      arr1[1] = 1;
-      // Since the array is used in only one spot, and that spot is not within the try/catch, it
-      // should be safe to use filled-new-array, but we don't.
+    private static void allocationWithCatchHandler() {
+      Object[] arr;
       try {
-        System.currentTimeMillis();
+        arr = new Object[1];
+      } catch (NoClassDefFoundError | OutOfMemoryError t) {
+        throw new RuntimeException(t);
+      }
+
+      // new-array-empty dominates this, but catch handlers are relevant
+      arr[0] = "*";
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void allocationWithoutCatchHandler() {
+      Object[] arr = new Object[1];
+      try {
+        // new-array-empty dominates this, but catch handlers are relevant.
+        arr[0] = "*";
+      } catch (NoClassDefFoundError | OutOfMemoryError t) {
+        throw new RuntimeException(t);
+      }
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void catchHandlerWithFinally() {
+      Object[] arr = new Object[2];
+      try {
+        System.out.print("finally: ");
+      } finally {
+        // This will be duplicated into the throwing and non-throwing blocks.
+        arr[0] = "1";
+      }
+      arr[1] = "2";
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void simpleSynchronized1() {
+      // Should optimize since array is contained within a try block.
+      synchronized (Main.class) {
+        int[] arr = new int[] {1, 2};
+        System.out.println(Arrays.toString(arr));
+      }
+    }
+
+    @NeverInline
+    private static synchronized void simpleSynchronized2() {
+      // Should optimize since array is contained within a try block.
+      try {
+        try {
+          int[] arr = new int[] {1, 2};
+          System.out.println(Arrays.toString(arr));
+        } catch (Throwable t) {
+          throw new RuntimeException(t);
+        } finally {
+          System.currentTimeMillis();
+        }
+      } catch (Exception e) {
+        // Ignore.
+      }
+    }
+
+    @NeverInline
+    private static void simpleSynchronized3() {
+      // Does not optimize because allocation has different catch handlers.
+      int[] arr = new int[2];
+      synchronized (Main.class) {
+        arr[0] = 1;
+        arr[1] = 2;
+      }
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void simpleSynchronized4() {
+      // Does not optimize because allocation has different catch handlers.
+      int[] arr;
+      synchronized (Main.class) {
+        arr = new int[2];
+      }
+      arr[0] = 1;
+      arr[1] = 2;
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void catchHandlerWithoutSideeffects() {
+      // If we added logic to show that catch handlers exit without side-effects, we could optimize
+      // this case.z
+      int[] arr1;
+      try {
+        arr1 = new int[3];
+      } catch (Throwable t) {
+        throw new RuntimeException("1");
+      }
+      try {
+        arr1[0] = 0;
+      } catch (Throwable t) {
+        throw new RuntimeException("2");
+      }
+      arr1[1] = 1;
+      try {
         arr1[2] = 2;
       } catch (Throwable t) {
-        throw new RuntimeException(t);
+        throw new RuntimeException("3");
       }
       System.out.println(Arrays.toString(arr1));
-
-      try {
-        // Test filled-new-array with a throwing instruction before the last array-put.
-        int[] arr2 = new int[1];
-        System.currentTimeMillis();
-        arr2[0] = 0;
-        System.out.println(Arrays.toString(arr2));
-
-        // Test filled-array-data with a throwing instruction before the last array-put.
-        short[] arr3 = new short[3];
-        arr3[0] = 0;
-        arr3[1] = 1;
-        System.currentTimeMillis();
-        arr3[2] = 2;
-        System.out.println(Arrays.toString(arr3));
-      } catch (Throwable t) {
-        throw new RuntimeException(t);
-      }
     }
 
     @NeverInline
@@ -485,11 +626,123 @@
     @NeverInline
     private static void phiFilledNewArray() {
       // The presence of ? should not affect use of filled-new-array.
-      Integer[] phiArray = {1, System.nanoTime() > 0 ? 2 : 3};
+      Integer[] phiArray = {1, System.nanoTime() > 0 ? 2 : 3, 3};
       System.out.println(Arrays.toString(phiArray));
     }
 
     @NeverInline
+    private static void phiFilledNewArrayBlocks() {
+      int[] phiArray = new int[3];
+      if (System.currentTimeMillis() > 0) {
+        phiArray[0] = 2;
+        phiArray[1] = 2;
+        phiArray[2] = 2;
+      }
+      System.out.println(Arrays.toString(phiArray));
+    }
+
+    @NeverInline
+    private static void arrayWithDominatingPhiUsers() {
+      int[] phiArray = null;
+      try {
+        phiArray = new int[2];
+        phiArray[0] = 6;
+        phiArray[1] = 7;
+      } catch (Throwable t) {
+        System.out.println("Not reached");
+      }
+      System.out.println(Arrays.toString(phiArray));
+    }
+
+    @NeverInline
+    private static void arrayWithNonDominatingPhiUsers() {
+      int[] phiArray = null;
+      try {
+        phiArray = new int[1];
+        // If currentTimeMillis() throws, phiArray will have value of [0].
+        phiArray[0] = System.currentTimeMillis() > 0 ? 7 : 0;
+      } catch (Throwable t) {
+        System.out.println("Not reached");
+      }
+      System.out.println(Arrays.toString(phiArray));
+    }
+
+    @NeverInline
+    private static void phiWithNestedCatchHandler() {
+      int[] phiArray = null;
+      try {
+        phiArray = new int[2];
+        // If currentTimeMillis() throws, phiArray will have value of [0, 0].
+        try {
+          System.currentTimeMillis();
+        } catch (RuntimeException r) {
+          throw new RuntimeException(r);
+        }
+        phiArray[0] = 3;
+        phiArray[1] = 4;
+      } catch (Throwable t) {
+        System.out.println("Not reached");
+      }
+      System.out.println(Arrays.toString(phiArray));
+    }
+
+    @NeverInline
+    private static void phiWithExceptionalPhiUser() {
+      int[] arr = null;
+      try {
+        // Both of these should optimize, but care must be taken to ensure the phiUsers are properly
+        // dominated post-optimization.
+        if (System.currentTimeMillis() > 0) {
+          arr = new int[1];
+          arr[0] = 99;
+        } else {
+          arr = new int[] {1, 2};
+        }
+      } catch (RuntimeException e) {
+        // fall through
+      }
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void multiUseArray() {
+      int[] arr = new int[2];
+      arr[0] = 0;
+      arr[1] = System.nanoTime() > 0 ? 1 : 2;
+      System.out.println(Arrays.toString(arr));
+      System.out.println(Arrays.toString(arr));
+      // Usage in a different basic block.
+      if (System.nanoTime() > 0) {
+        System.nanoTime();
+      }
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void arrayWithHole() {
+      int[] arr = new int[2];
+      arr[1] = 1;
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
+    private static void reassignmentDoesNotOptimize() {
+      // Reassignment in same block, and of last index.
+      Integer[] arr = new Integer[2];
+      arr[0] = 0;
+      arr[1] = 2;
+      arr[1] = 1;
+      System.out.println(Arrays.toString(arr));
+
+      // Reassignment across blocks, of non-last index.
+      arr = new Integer[2];
+      arr[0] = 3;
+      arr[1] = System.nanoTime() > 0 ? 1 : 2;
+      arr[0] = 0;
+      System.out.println(Arrays.toString(arr));
+    }
+
+    @NeverInline
     private static void intsThatUseFilledNewArray() {
       // Up to 5 ints uses filled-new-array rather than filled-array-data.
       int[] intArr = {1, 2, 3, 4, 5};
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 be54d34..68b80fc 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
@@ -46,9 +46,9 @@
 
   private static final String EXPECTED_OUTPUT = StringUtils.lines("100", "50");
 
-  private void inspect(MethodSubject method, int staticGets, int puts, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(MethodSubject method, int staticGets, int puts, boolean isD8) {
+    // D8 cannot optimize due to risk of NoClassDefFoundError.
+    boolean expectingFilledNewArray = !isD8 && canUseFilledNewArrayOfNonStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -66,18 +66,9 @@
   }
 
   private void inspectD8(CodeInspector inspector) {
-    inspect(
-        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"),
-        canUseFilledNewArrayOfNonStringObjects(parameters) ? 100 : 1,
-        100,
-        false);
-    inspect(
-        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
-        canUseFilledNewArrayOfNonStringObjects(parameters)
-            ? 50
-            : (maxMaterializingConstants == 2 ? 42 : 10),
-        50,
-        false);
+    // D8 cannot optimize due to risk of NoClassDefFoundError.
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 100, 100, true);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 50, 50, true);
   }
 
   @Test
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 fce1e79..f64d0e8 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
@@ -52,9 +52,9 @@
     EXPECTING_APUTOBJECT
   }
 
-  private void inspect(MethodSubject method, int puts, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfNonStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(boolean isR8, MethodSubject method, int puts) {
+    // D8 cannot optimize due to risk of NoClassDefFoundError.
+    boolean expectingFilledNewArray = isR8 && canUseFilledNewArrayOfNonStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -84,10 +84,10 @@
     }
   }
 
-  private void inspect(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5, false);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5, true);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"), 100, false);
+  private void inspect(CodeInspector inspector, boolean isR8) {
+    inspect(isR8, inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5);
+    inspect(isR8, inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5);
+    inspect(isR8, inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"), 100);
   }
 
   @Test
@@ -97,7 +97,7 @@
         .addInnerClasses(getClass())
         .setMinApi(parameters)
         .run(parameters.getRuntime(), TestClass.class)
-        .inspect(this::inspect)
+        .inspect(inspector -> inspect(inspector, false))
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
@@ -110,7 +110,7 @@
         .enableInliningAnnotations()
         .addDontObfuscate()
         .run(parameters.getRuntime(), TestClass.class)
-        .inspect(this::inspect)
+        .inspect(inspector -> inspect(inspector, true))
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
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 c433e6d..cf12961 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
@@ -46,10 +46,8 @@
 
   private static final String EXPECTED_OUTPUT = StringUtils.lines("100", "104");
 
-  private void inspect(
-      MethodSubject method, int constStrings, int puts, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(MethodSubject method, int constStrings, int puts) {
+    boolean expectingFilledNewArray = canUseFilledNewArrayOfStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -68,12 +66,11 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 1, 100, false);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 1, 100);
     inspect(
         inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"),
         maxMaterializingConstants == 2 ? 32 : 26,
-        104,
-        false);
+        104);
   }
 
   @Test
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 837bea2..53f7f1f 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
@@ -52,9 +52,8 @@
     EXPECTING_APUTOBJECT
   }
 
-  private void inspect(MethodSubject method, int puts, boolean insideCatchHandler) {
-    boolean expectingFilledNewArray =
-        canUseFilledNewArrayOfStringObjects(parameters) && !insideCatchHandler;
+  private void inspect(MethodSubject method, int puts) {
+    boolean expectingFilledNewArray = canUseFilledNewArrayOfStringObjects(parameters);
     assertEquals(
         expectingFilledNewArray ? 0 : puts,
         method.streamInstructions().filter(InstructionSubject::isArrayPut).count());
@@ -86,9 +85,9 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5, false);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5, true);
-    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"), 100, false);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m1"), 5);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m2"), 5);
+    inspect(inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("m3"), 100);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfApiDependentLibraryTypeTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfApiDependentLibraryTypeTest.java
new file mode 100644
index 0000000..1f49507
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfApiDependentLibraryTypeTest.java
@@ -0,0 +1,104 @@
+// 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 com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.function.Function;
+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 UnusedNewArrayOfApiDependentLibraryTypeTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    parameters.assumeCfRuntime();
+    testForJvm(parameters)
+        .addInnerClasses(getClass())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  @Test
+  public void testD8Release() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8()
+        .addInnerClasses(getClass())
+        .release()
+        .setMinApi(parameters)
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), Main.class)
+        .applyIf(
+            hasFunctionAsRunTime(),
+            TestRunResult::assertSuccessWithEmptyOutput,
+            runResult -> runResult.assertFailureWithErrorThatThrows(NoClassDefFoundError.class));
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .applyIf(
+            !hasFunctionAtCompileTime(), testBuilder -> testBuilder.addDontWarn(Function.class))
+        .setMinApi(parameters)
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), Main.class)
+        .applyIf(
+            hasFunctionAsRunTime(),
+            TestRunResult::assertSuccessWithEmptyOutput,
+            runResult -> runResult.assertFailureWithErrorThatThrows(NoClassDefFoundError.class));
+  }
+
+  private void inspect(CodeInspector inspector) {
+    MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
+    assertThat(mainMethodSubject, isPresent());
+    assertEquals(canOptimize(), mainMethodSubject.getMethod().getCode().isEmptyVoidMethod());
+  }
+
+  private boolean canOptimize() {
+    return hasFunctionAtCompileTime() && parameters.isDexRuntime();
+  }
+
+  private boolean hasFunctionAtCompileTime() {
+    return parameters.isCfRuntime()
+        || parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
+  }
+
+  private boolean hasFunctionAsRunTime() {
+    return parameters.isCfRuntime()
+        || parameters.getDexRuntimeVersion().isNewerThanOrEqual(Version.V7_0_0);
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      Function[] functions = new Function[0];
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfInaccessibleTypeTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfInaccessibleTypeTest.java
new file mode 100644
index 0000000..aaf7c49
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfInaccessibleTypeTest.java
@@ -0,0 +1,88 @@
+// 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 com.android.tools.r8.NoAccessModification;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+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;
+import org.objectweb.asm.MethodVisitor;
+
+@RunWith(Parameterized.class)
+public class UnusedNewArrayOfInaccessibleTypeTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    parameters.assumeCfRuntime();
+    testForJvm(parameters)
+        .addProgramClassFileData(getProgramClassFileData())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(IllegalAccessError.class);
+  }
+
+  @Test
+  public void testD8Release() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8()
+        .addProgramClassFileData(getProgramClassFileData())
+        .release()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(IllegalAccessError.class);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(getProgramClassFileData())
+        .addKeepMainRule(Main.class)
+        .enableNoAccessModificationAnnotationsForClasses()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(IllegalAccessError.class);
+  }
+
+  private static List<byte[]> getProgramClassFileData() throws Exception {
+    return ImmutableList.of(
+        transformer(Main.class)
+            .transformTypeInsnInMethod(
+                "main",
+                (int opcode, String type, MethodVisitor visitor) ->
+                    visitor.visitTypeInsn(
+                        opcode,
+                        type.equals(binaryName(Inaccessible.class)) ? "pkg/Inaccessible" : type))
+            .replaceClassDescriptorInMethodInstructions(
+                descriptor(Inaccessible.class), "Lpkg/Inaccessible;")
+            .transform(),
+        transformer(Inaccessible.class).setClassDescriptor("Lpkg/Inaccessible;").transform());
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      Inaccessible[] array = new Inaccessible[0];
+    }
+  }
+
+  // TODO(b/320445632): Access modifier should not publicize items with illegal accesses.
+  @NoAccessModification
+  static class /*pkg.*/ Inaccessible {}
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfKnownLibraryTypeTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfKnownLibraryTypeTest.java
new file mode 100644
index 0000000..a013ceb
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/UnusedNewArrayOfKnownLibraryTypeTest.java
@@ -0,0 +1,102 @@
+// 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 com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+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 UnusedNewArrayOfKnownLibraryTypeTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    parameters.assumeCfRuntime();
+    testForJvm(parameters)
+        .addInnerClasses(getClass())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  @Test
+  public void testD8Release() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8()
+        .addInnerClasses(getClass())
+        .release()
+        .setMinApi(parameters)
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters)
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  private void inspect(CodeInspector inspector) {
+    MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
+    assertThat(mainMethodSubject, isPresent());
+    assertTrue(mainMethodSubject.getMethod().getCode().isEmptyVoidMethod());
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      // Primitives.
+      boolean[] booleans = new boolean[0];
+      byte[] bytes = new byte[0];
+      char[] chars = new char[0];
+      double[] doubles = new double[0];
+      float[] floats = new float[0];
+      int[] ints = new int[0];
+      long[] longs = new long[0];
+      short[] shorts = new short[0];
+
+      // Boxed primitives.
+      Boolean[] boxedBooleans = new Boolean[0];
+      Byte[] boxedBytes = new Byte[0];
+      Character[] boxedChars = new Character[0];
+      Double[] boxedDoubles = new Double[0];
+      Float[] boxedFloats = new Float[0];
+      Integer[] boxedInts = new Integer[0];
+      Long[] boxedLongs = new Long[0];
+      Short[] boxedShorts = new Short[0];
+
+      // Common classes.
+      Enum<?>[] enums = new Enum<?>[0];
+      Object[] objects = new Object[0];
+      String[] strings = new String[0];
+      StringBuilder[] stringBuilders = new StringBuilder[0];
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
index 2e03043..a2a1119 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
@@ -95,7 +95,7 @@
         "shaking1.Used -> a.a:",
         "# {'id':'sourceFile','fileName':'Used.java'}",
         "    java.lang.String name -> a",
-        "    1:14:void <init>(java.lang.String):0:13 -> <init>",
+        "    1:2:void <init>(java.lang.String):12:13 -> <init>",
         "    1:1:java.lang.String method():17:17 -> a",
         "    1:1:java.lang.String aMethodThatIsNotUsedButKept():21:21 "
             + "-> aMethodThatIsNotUsedButKept");
diff --git a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
index 5d90382..c46d024 100644
--- a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
@@ -10,15 +10,15 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.R8FullTestBuilder;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 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 java.io.FileNotFoundException;
 import java.nio.file.Path;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -115,35 +115,32 @@
             .inspect(this::inspect)
             .writeToZip();
 
-    R8FullTestBuilder builder =
-        testForR8(parameters.getBackend())
-            .addLibraryClasses(BaseClass.class, UninstantiatedClass.class, TestClass.class)
-            .addDefaultRuntimeLibrary(parameters)
-            .addProgramClasses(Caller.class)
-            .addKeepMainRule(Caller.class)
-            .setMinApi(parameters);
-    R8TestRunResult result =
-        builder
-            .compile()
-            .addRunClasspathFiles(firstRunArchive)
-            .run(parameters.getRuntime(), Caller.class);
-    // TODO(b/117302947): Dex runtime should be able to find that framework class.
-    if (parameters.isDexRuntime()) {
-      result.assertFailureWithErrorThatMatches(containsString("NoClassDefFoundError"));
-      result.assertFailureWithErrorThatMatches(containsString("android.util.Log"));
-      return;
-    }
-    result
-        .assertFailureWithErrorThatMatches(
-            containsString(createExpectedMessage(UninstantiatedClass.class)))
-        .assertFailureWithErrorThatMatches(containsString("void <init>()"))
-        .assertFailureWithErrorThatMatches(containsString("void <init>(java.lang.String)"))
-        .assertFailureWithErrorThatMatches(
-            containsString(createExpectedMessage(TestClass.class)))
-        .assertFailureWithErrorThatMatches(containsString("void foo(int,long)"))
-        .assertFailureWithErrorThatMatches(
-            containsString("void bar(" + PACKAGE_NAME + ".TestClass" +")"))
-        .assertFailureWithErrorThatMatches(containsString("Reaching the end"));
+    testForR8(parameters.getBackend())
+        .addLibraryClasses(BaseClass.class, UninstantiatedClass.class, TestClass.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .addProgramClasses(Caller.class)
+        .addKeepMainRule(Caller.class)
+        .setMinApi(parameters)
+        .compile()
+        .addRunClasspathFiles(firstRunArchive)
+        .run(parameters.getRuntime(), Caller.class)
+        .applyIf(
+            parameters.isDexRuntime()
+                && parameters.getDexRuntimeVersion().isEqualToOneOf(Version.V5_1_1, Version.V6_0_1),
+            runResult -> runResult.assertFailureWithErrorThatThrows(FileNotFoundException.class),
+            runResult ->
+                runResult
+                    .assertFailureWithErrorThatMatches(
+                        containsString(createExpectedMessage(UninstantiatedClass.class)))
+                    .assertFailureWithErrorThatMatches(containsString("void <init>()"))
+                    .assertFailureWithErrorThatMatches(
+                        containsString("void <init>(java.lang.String)"))
+                    .assertFailureWithErrorThatMatches(
+                        containsString(createExpectedMessage(TestClass.class)))
+                    .assertFailureWithErrorThatMatches(containsString("void foo(int,long)"))
+                    .assertFailureWithErrorThatMatches(
+                        containsString("void bar(" + PACKAGE_NAME + ".TestClass" + ")"))
+                    .assertFailureWithErrorThatMatches(containsString("Reaching the end")));
   }
 
   private String createExpectedMessage(Class<?> clazz) {
diff --git a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingWithInliningTest.java b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingWithInliningTest.java
index edd31ba..c916ae9 100644
--- a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingWithInliningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingWithInliningTest.java
@@ -10,6 +10,8 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import java.io.FileNotFoundException;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -39,13 +41,9 @@
         .run(parameters.getRuntime(), Main.class)
         // AddConfigurationDebugging will insert a call to android.util.log.
         .applyIf(
-            parameters.isDexRuntime(),
-            result ->
-                result
-                    .assertFailureWithErrorThatThrows(NoClassDefFoundError.class)
-                    .assertFailureWithErrorThatMatches(containsString("Landroid/util/Log;")))
-        .applyIf(
-            parameters.isCfRuntime(),
+            parameters.isDexRuntime()
+                && parameters.getDexRuntimeVersion().isEqualToOneOf(Version.V5_1_1, Version.V6_0_1),
+            result -> result.assertFailureWithErrorThatThrows(FileNotFoundException.class),
             result ->
                 result.assertFailureWithErrorThatMatches(
                     containsString("Missing method in " + typeName(Bar.class))));
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java
index 5b8f002..bf038dd 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java
@@ -8,15 +8,20 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.verticalclassmerging.VerticallyMergedClasses;
+import java.util.HashSet;
+import java.util.Set;
 
 public class VerticallyMergedClassesInspector {
 
   private final DexItemFactory dexItemFactory;
   private final VerticallyMergedClasses verticallyMergedClasses;
 
+  private final Set<ClassReference> seen = new HashSet<>();
+
   public VerticallyMergedClassesInspector(
       DexItemFactory dexItemFactory, VerticallyMergedClasses verticallyMergedClasses) {
     this.dexItemFactory = dexItemFactory;
@@ -24,8 +29,7 @@
   }
 
   public VerticallyMergedClassesInspector assertMergedIntoSubtype(Class<?> clazz) {
-    assertTrue(verticallyMergedClasses.hasBeenMergedIntoSubtype(toDexType(clazz, dexItemFactory)));
-    return this;
+    return assertMergedIntoSubtype(Reference.classFromClass(clazz));
   }
 
   public VerticallyMergedClassesInspector assertMergedIntoSubtype(Class<?>... classes) {
@@ -39,6 +43,7 @@
     assertTrue(
         verticallyMergedClasses.hasBeenMergedIntoSubtype(
             toDexType(classReference, dexItemFactory)));
+    seen.add(classReference);
     return this;
   }
 
@@ -53,4 +58,11 @@
     assertTrue(verticallyMergedClasses.isEmpty());
     return this;
   }
+
+  public VerticallyMergedClassesInspector assertNoOtherClassesMerged() {
+    for (DexType source : verticallyMergedClasses.getSources()) {
+      assertTrue(source.getTypeName(), seen.contains(source.asClassReference()));
+    }
+    return this;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/workaround/FilledNewArrayFromSubtypeWithMissingInterfaceWorkaroundTest.java b/src/test/java/com/android/tools/r8/workaround/FilledNewArrayFromSubtypeWithMissingInterfaceWorkaroundTest.java
index 3f7aba6..53794e3 100644
--- a/src/test/java/com/android/tools/r8/workaround/FilledNewArrayFromSubtypeWithMissingInterfaceWorkaroundTest.java
+++ b/src/test/java/com/android/tools/r8/workaround/FilledNewArrayFromSubtypeWithMissingInterfaceWorkaroundTest.java
@@ -6,14 +6,13 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoVerticalClassMerging;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -44,7 +43,7 @@
         .release()
         .setMinApi(parameters)
         .compile()
-        .inspect(inspector -> inspect(inspector, true))
+        .inspect(this::inspect)
         .apply(
             compileResult ->
                 compileResult.runDex2Oat(parameters.getRuntime()).assertNoVerificationErrors())
@@ -66,18 +65,17 @@
             parameters.isDexRuntime(),
             compileResult ->
                 compileResult
-                    .inspect(inspector -> inspect(inspector, false))
+                    .inspect(this::inspect)
                     .runDex2Oat(parameters.getRuntime())
                     .assertNoVerificationErrors())
         .run(parameters.getRuntime(), Main.class)
         .assertFailureWithErrorThatThrows(NoClassDefFoundError.class);
   }
 
-  private void inspect(CodeInspector inspector, boolean isD8) {
+  private void inspect(CodeInspector inspector) {
     MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
     assertThat(mainMethodSubject, isPresent());
-    assertEquals(
-        isD8 && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N),
+    assertFalse(
         mainMethodSubject.streamInstructions().anyMatch(InstructionSubject::isFilledNewArray));
   }
 
diff --git a/tools/run_on_app_dump.py b/tools/run_on_app_dump.py
index 964d1dc..9ca17ac 100755
--- a/tools/run_on_app_dump.py
+++ b/tools/run_on_app_dump.py
@@ -299,6 +299,7 @@
         'url': 'https://github.com/signalapp/Signal-Android',
         'revision': '91ca19f294362ccee2c2b43c247eba228e2b30a1',
         'folder': 'signal-android',
+        'golem_duration': 300
     }),
     # TODO(b/172815827): Monkey runner does not work
     App({