diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 36adabe..ebebbf1 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -110,7 +110,7 @@
       return;
     }
     if (command.isPrintVersion()) {
-      Version.printToolVersion("D8");
+      System.out.println("D8 " + Version.getVersionString());
       return;
     }
     InternalOptions options = command.getInternalOptions();
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index ab6796b..19a0118 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -656,8 +656,7 @@
             // TODO(b/130721661): Enable this assert.
             // assert Inliner.verifyNoMethodsInlinedDueToSingleCallSite(appView);
 
-            assert appView.verticallyMergedClasses() == null
-                || appView.verticallyMergedClasses().verifyAllSourcesPruned(appViewWithLiveness);
+            assert appView.allMergedClasses().verifyAllSourcesPruned(appViewWithLiveness);
 
             processWhyAreYouKeepingAndCheckDiscarded(
                 appView.rootSet(),
@@ -886,7 +885,7 @@
       return;
     }
     if (command.isPrintVersion()) {
-      Version.printToolVersion("R8");
+      System.out.println("R8 " + Version.getVersionString());
       return;
     }
     InternalOptions options = command.getInternalOptions();
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 9a9c4cb..918c373 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -16,21 +16,79 @@
   private Version() {
   }
 
-  public static void printToolVersion(String toolName) {
-    System.out.println(toolName + " " + Version.LABEL);
-    System.out.println(VersionProperties.INSTANCE.getDescription());
+  /** Returns current R8 version (with additional info) as a string. */
+  public static String getVersionString() {
+    return LABEL + " (" + VersionProperties.INSTANCE.getDescription() + ")";
   }
 
-  /** Is this a development version of the D8/R8 library. */
-  public static boolean isDev() {
+  /**
+   * Returns the major version number of the compiler.
+   *
+   * @return Major version or -1 for an unreleased build.
+   */
+  public static int getMajorVersion() {
+    if (LABEL.equals("master")) {
+      return -1;
+    }
+    int start = 0;
+    int end = LABEL.indexOf('.');
+    return Integer.parseInt(LABEL.substring(start, end));
+  }
+
+  /**
+   * Returns the minor version number of the compiler.
+   *
+   * @return Minor version or -1 for an unreleased build.
+   */
+  public static int getMinorVersion() {
+    if (LABEL.equals("master")) {
+      return -1;
+    }
+    int start = LABEL.indexOf('.') + 1;
+    int end = LABEL.indexOf('.', start);
+    return Integer.parseInt(LABEL.substring(start, end));
+  }
+
+  /**
+   * Returns the patch version number of the compiler.
+   *
+   * @return Patch version or -1 for an unreleased build.
+   */
+  public static int getPatchVersion() {
+    if (LABEL.equals("master")) {
+      return -1;
+    }
+    int skip = LABEL.indexOf('.') + 1;
+    int start = LABEL.indexOf('.', skip) + 1;
+    int end = LABEL.indexOf('.', start);
+    return Integer.parseInt(LABEL.substring(start, end));
+  }
+
+  /**
+   * Returns the pre-release version information of the compiler.
+   *
+   * @return Pre-release information if present, the empty string if absent, and null for an
+   *     unreleased build.
+   */
+  public static String getPreReleaseString() {
+    if (LABEL.equals("master")) {
+      return null;
+    }
+    int start = LABEL.indexOf('-') + 1;
+    if (start > 0) {
+      return LABEL.substring(start);
+    }
+    return "";
+  }
+
+  /**
+   * Is this a development version of the D8/R8 library.
+   *
+   * @return True if the build is not a release or if it is a development release.
+   */
+  public static boolean isDevelopmentVersion() {
     return LABEL.equals("master")
         || LABEL.endsWith("-dev")
         || VersionProperties.INSTANCE.isEngineering();
   }
-
-  /** Returns current R8 version (with additional info) as a string. */
-  @SuppressWarnings("unused") // used by external tools to obtain R8 version
-  public static String getVersionString() {
-    return LABEL + " (" + VersionProperties.INSTANCE.getDescription() + ")";
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/compatdx/CompatDx.java b/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
index 68e9e69..a52c2ea 100644
--- a/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
+++ b/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
@@ -326,7 +326,7 @@
       return;
     }
     if (dexArgs.version) {
-      Version.printToolVersion("CompatDx");
+      System.out.println("CompatDx " + Version.getVersionString());
       return;
     }
     CompilationMode mode = CompilationMode.RELEASE;
diff --git a/src/main/java/com/android/tools/r8/compatproguard/CompatProguard.java b/src/main/java/com/android/tools/r8/compatproguard/CompatProguard.java
index 514f785..177f2ae 100644
--- a/src/main/java/com/android/tools/r8/compatproguard/CompatProguard.java
+++ b/src/main/java/com/android/tools/r8/compatproguard/CompatProguard.java
@@ -173,7 +173,7 @@
   }
 
   private static void printVersion() {
-    Version.printToolVersion("CompatProguard");
+    System.out.println("CompatProguard " + Version.getVersionString());
   }
 
   private static void printHelp() {
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index 6eb6a94..3b51579 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -535,9 +535,12 @@
   public DexEncodedField resolveFieldOn(DexType type, DexField desc) {
     assert checkIfObsolete();
     DexClass holder = definitionFor(type);
-    if (holder == null) {
-      return null;
-    }
+    return holder != null ? resolveFieldOn(holder, desc) : null;
+  }
+
+  public DexEncodedField resolveFieldOn(DexClass holder, DexField desc) {
+    assert checkIfObsolete();
+    assert holder != null;
     // Step 1: Class declares the field.
     DexEncodedField result = holder.lookupField(desc);
     if (result != null) {
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 a2d6967..99a2a2b 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -5,6 +5,9 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis.InitializedClassesInInstanceMethods;
+import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
+import com.android.tools.r8.graph.classmerging.MergedClassesCollection;
+import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker;
 import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteBuilderShrinker;
 import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteShrinker;
@@ -14,7 +17,6 @@
 import com.android.tools.r8.ir.optimize.CallSiteOptimizationInfoPropagator;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
-import com.android.tools.r8.shaking.VerticalClassMerger.VerticallyMergedClasses;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OptionalBool;
 import com.google.common.base.Predicates;
@@ -52,6 +54,7 @@
   private Predicate<DexType> classesEscapingIntoLibrary = Predicates.alwaysTrue();
   private InitializedClassesInInstanceMethods initializedClassesInInstanceMethods;
   private Set<DexMethod> unneededVisibilityBridgeMethods = ImmutableSet.of();
+  private HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses;
   private VerticallyMergedClasses verticallyMergedClasses;
 
   private AppView(
@@ -296,6 +299,28 @@
     this.unneededVisibilityBridgeMethods = unneededVisibilityBridgeMethods;
   }
 
+  public MergedClassesCollection allMergedClasses() {
+    MergedClassesCollection collection = new MergedClassesCollection();
+    if (horizontallyMergedLambdaClasses != null) {
+      collection.add(horizontallyMergedLambdaClasses);
+    }
+    if (verticallyMergedClasses != null) {
+      collection.add(verticallyMergedClasses);
+    }
+    return collection;
+  }
+
+  // Get the result of horizontal lambda class merging. Returns null if horizontal lambda class
+  // merging has not been run.
+  public HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses() {
+    return horizontallyMergedLambdaClasses;
+  }
+
+  public void setHorizontallyMergedLambdaClasses(
+      HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses) {
+    this.horizontallyMergedLambdaClasses = horizontallyMergedLambdaClasses;
+  }
+
   // Get the result of vertical class merging. Returns null if vertical class merging has not been
   // run.
   public VerticallyMergedClasses verticallyMergedClasses() {
diff --git a/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java b/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
index eafa809..e2adfbb 100644
--- a/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
+++ b/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
@@ -107,6 +107,7 @@
     ps.println("#");
     ps.println("# Method: '" + methodName + "':");
     writeAnnotations(method.annotations, ps);
+    ps.println("# " + method.accessFlags);
     ps.println("#");
     ps.println();
     Code code = method.getCode();
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 47930c2..5a7e785 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -1092,15 +1092,6 @@
     return m1.method.slowCompareTo(m2.method);
   }
 
-  public static class ClassInlinerEligibility {
-
-    public final boolean returnsReceiver;
-
-    public ClassInlinerEligibility(boolean returnsReceiver) {
-      this.returnsReceiver = returnsReceiver;
-    }
-  }
-
   public MethodOptimizationInfo getOptimizationInfo() {
     checkIfObsolete();
     return optimizationInfo;
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 523fd85..488b6c7 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -34,7 +34,8 @@
   private String toStringCache = null;
 
   DexType(DexString descriptor) {
-    assert !descriptor.toString().contains(".");
+    assert !descriptor.toString().contains(".")
+        : "Malformed descriptor: " + descriptor.toString();
     this.descriptor = descriptor;
   }
 
@@ -180,12 +181,7 @@
   }
 
   public boolean isPrimitiveType() {
-    return isPrimitiveType((char) descriptor.content[0]);
-  }
-
-  private boolean isPrimitiveType(char c) {
-    return c == 'Z' || c == 'B' || c == 'S' || c == 'C' || c == 'I' || c == 'F' || c == 'J'
-        || c == 'D';
+    return DescriptorUtils.isPrimitiveType((char) descriptor.content[0]);
   }
 
   public boolean isVoidType() {
@@ -244,7 +240,7 @@
     if (!isArrayType()) {
       return false;
     }
-    return isPrimitiveType((char) descriptor.content[1]);
+    return DescriptorUtils.isPrimitiveType((char) descriptor.content[1]);
   }
 
   public boolean isWideType() {
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java b/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java
new file mode 100644
index 0000000..1facc45
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2019, 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.graph.classmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Set;
+
+public class HorizontallyMergedLambdaClasses implements MergedClasses {
+
+  private final Set<DexType> sources;
+
+  public HorizontallyMergedLambdaClasses(Set<DexType> sources) {
+    this.sources = sources;
+  }
+
+  @Override
+  public boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView) {
+    for (DexType source : sources) {
+      assert appView.appInfo().wasPruned(source)
+          : "Expected horizontally merged lambda class `"
+              + source.toSourceString()
+              + "` to be absent";
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java
new file mode 100644
index 0000000..7b9bba3
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2019, 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.graph.classmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+public interface MergedClasses {
+
+  boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView);
+}
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java
new file mode 100644
index 0000000..ad7c71d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2019, 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.graph.classmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MergedClassesCollection implements MergedClasses {
+
+  private List<MergedClasses> collection = new ArrayList<>();
+
+  public void add(MergedClasses mergedClasses) {
+    collection.add(mergedClasses);
+  }
+
+  @Override
+  public boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView) {
+    for (MergedClasses mergedClasses : collection) {
+      assert mergedClasses.verifyAllSourcesPruned(appView);
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java b/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java
new file mode 100644
index 0000000..237f9ab
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java
@@ -0,0 +1,52 @@
+// Copyright (c) 2019, 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.graph.classmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Maps;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class VerticallyMergedClasses implements MergedClasses {
+
+  private final Map<DexType, DexType> mergedClasses;
+  private final Map<DexType, List<DexType>> sources;
+
+  public VerticallyMergedClasses(Map<DexType, DexType> mergedClasses) {
+    Map<DexType, List<DexType>> sources = Maps.newIdentityHashMap();
+    mergedClasses.forEach(
+        (source, target) -> sources.computeIfAbsent(target, key -> new ArrayList<>()).add(source));
+    this.mergedClasses = mergedClasses;
+    this.sources = sources;
+  }
+
+  public List<DexType> getSourcesFor(DexType type) {
+    return sources.getOrDefault(type, ImmutableList.of());
+  }
+
+  public DexType getTargetFor(DexType type) {
+    assert mergedClasses.containsKey(type);
+    return mergedClasses.get(type);
+  }
+
+  public boolean hasBeenMergedIntoSubtype(DexType type) {
+    return mergedClasses.containsKey(type);
+  }
+
+  @Override
+  public boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView) {
+    for (List<DexType> sourcesForTarget : sources.values()) {
+      for (DexType source : sourcesForTarget) {
+        assert appView.appInfo().wasPruned(source)
+            : "Expected vertically merged class `" + source.toSourceString() + "` to be absent";
+      }
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
index d9f4e2d..0605623 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
@@ -109,7 +109,7 @@
       if (isConstantArrayThroughoutMethod(root, assumedNotToDependOnEnvironment)) {
         return false;
       }
-      if (root.getAbstractValue(appView).isSingleEnumValue()) {
+      if (root.getAbstractValue(appView, context).isSingleEnumValue()) {
         return false;
       }
       if (isNewInstanceWithoutEnvironmentDependentFields(root, assumedNotToDependOnEnvironment)) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java
index 8e327aa..4adc57e 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java
@@ -83,6 +83,11 @@
     return new ClassTypeLatticeElement(type, nullability, lazyInterfaces, variants, appView);
   }
 
+  public boolean isRelatedTo(ClassTypeLatticeElement other, AppView<?> appView) {
+    return lessThanOrEqualUpToNullability(other, appView)
+        || other.lessThanOrEqualUpToNullability(this, appView);
+  }
+
   @Override
   public ReferenceTypeLatticeElement getOrCreateVariant(Nullability nullability) {
     ClassTypeLatticeElement variant = variants.get(nullability);
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 a4c8d4b..b2273e9 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
@@ -559,13 +559,30 @@
   }
 
   public int numberInstructions(int nextInstructionNumber) {
+    return numberInstructions(nextInstructionNumber, INSTRUCTION_NUMBER_DELTA);
+  }
+
+  public int numberInstructions(int nextInstructionNumber, int increment) {
     for (Instruction instruction : instructions) {
       instruction.setNumber(nextInstructionNumber);
-      nextInstructionNumber += INSTRUCTION_NUMBER_DELTA;
+      nextInstructionNumber += increment;
     }
     return nextInstructionNumber;
   }
 
+  public void clearInstructionNumbers() {
+    for (Instruction instruction : instructions) {
+      instruction.clearNumber();
+    }
+  }
+
+  public boolean hasNoInstructionNumbers() {
+    for (Instruction instruction : instructions) {
+      assert instruction.getNumber() == -1;
+    }
+    return true;
+  }
+
   public LinkedList<Instruction> getInstructions() {
     return instructions;
   }
@@ -1881,7 +1898,7 @@
    * {@code target} is the same block than the current {@link BasicBlock}.
    */
   public boolean hasPathTo(BasicBlock target) {
-    List<BasicBlock> visitedBlocks = new ArrayList<>();
+    Set<BasicBlock> visitedBlocks = Sets.newIdentityHashSet();
     ArrayDeque<BasicBlock> blocks = new ArrayDeque<>();
     blocks.push(this);
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index 8740a9e..805aad9 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -9,6 +9,7 @@
 import com.android.tools.r8.graph.DebugLocalInfo;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.ir.analysis.TypeChecker;
 import com.android.tools.r8.ir.analysis.ValueMayDependOnEnvironmentAnalysis;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
@@ -17,7 +18,6 @@
 import com.android.tools.r8.ir.code.Phi.RegisterReadType;
 import com.android.tools.r8.ir.conversion.IRBuilder;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.VerticalClassMerger.VerticallyMergedClasses;
 import com.android.tools.r8.utils.CfgPrinter;
 import com.android.tools.r8.utils.DequeUtils;
 import com.android.tools.r8.utils.InternalOptions;
@@ -958,6 +958,25 @@
     return blocks;
   }
 
+  public void numberInstructionsPerBlock() {
+    for (BasicBlock block : blocks) {
+      block.numberInstructions(0, 1);
+    }
+  }
+
+  public void clearInstructionNumbers() {
+    for (BasicBlock block : blocks) {
+      block.clearInstructionNumbers();
+    }
+  }
+
+  public boolean hasNoInstructionNumbers() {
+    for (BasicBlock block : blocks) {
+      assert block.hasNoInstructionNumbers();
+    }
+    return true;
+  }
+
   public int numberRemainingInstructions() {
     for (Instruction instruction : instructions()) {
       if (instruction.getNumber() == -1) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java b/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java
index 3fc4de0..f6054e1 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRMetadata.java
@@ -201,4 +201,9 @@
   public boolean mayHaveStringSwitch() {
     return get(Opcodes.STRING_SWITCH);
   }
+
+  public boolean mayHaveArithmeticOrLogicalBinop() {
+    // TODO(b/7145202413): Implement this.
+    return true;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index 228dc2b..6893464 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -362,6 +362,10 @@
     this.number = number;
   }
 
+  public void clearNumber() {
+    this.number = -1;
+  }
+
   /**
    * Compare equality of two class-equivalent instructions modulo their values and positions.
    */
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 c7aeff1..f9ca31d 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
@@ -9,7 +9,6 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DebugLocalInfo;
 import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
@@ -847,7 +846,7 @@
     return definition.isOutConstant() && !hasLocalInfo();
   }
 
-  public AbstractValue getAbstractValue(AppView<?> appView) {
+  public AbstractValue getAbstractValue(AppView<?> appView, DexType context) {
     if (!appView.enableWholeProgramOptimizations()) {
       return UnknownValue.getInstance();
     }
@@ -857,15 +856,7 @@
       return UnknownValue.getInstance();
     }
 
-    if (root.definition.isFieldGet()) {
-      FieldInstruction fieldGet = root.definition.asFieldInstruction();
-      DexEncodedField field = appView.appInfo().resolveField(fieldGet.getField());
-      if (field != null) {
-        return field.getOptimizationInfo().getAbstractValue();
-      }
-    }
-
-    return UnknownValue.getInstance();
+    return root.definition.getAbstractValue(appView, context);
   }
 
   public boolean isPhi() {
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 7a64973..fd1b111 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
@@ -1106,7 +1106,7 @@
     }
 
     if (lambdaMerger != null) {
-      lambdaMerger.rewriteCode(method, code);
+      lambdaMerger.rewriteCode(method, code, inliner);
       assert code.isConsistentSSA();
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index 3092293..21f800c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -30,6 +30,7 @@
 import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription;
 import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.graph.UseRegistry.MethodHandleUse;
+import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.ir.analysis.type.DestructivePhiTypeUpdater;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.BasicBlock;
@@ -61,7 +62,6 @@
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.desugar.LambdaRewriter;
 import com.android.tools.r8.logging.Log;
-import com.android.tools.r8.shaking.VerticalClassMerger.VerticallyMergedClasses;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.HashSet;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
index 6e96719..0f6bd4f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
@@ -6,12 +6,12 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -57,7 +57,7 @@
 
   void markTriggerClassInitBeforeAnySideEffect(DexEncodedMethod method, boolean mark);
 
-  void setClassInlinerEligibility(DexEncodedMethod method, ClassInlinerEligibility eligibility);
+  void setClassInlinerEligibility(DexEncodedMethod method, ClassInlinerEligibilityInfo eligibility);
 
   void setInitializerInfo(DexEncodedMethod method, InitializerInfo info);
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
index 4da2dcd..49b11a5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
@@ -91,12 +91,18 @@
           if (!resolutionResult.isValidVirtualTarget(appView.options())) {
             continue;
           }
+          // If the resolution ended up with a single target, check if it is a library override.
+          // And if so, bail out early (to avoid expensive target lookup).
+          if (resolutionResult.hasSingleTarget()
+              && isLibraryMethodOrLibraryMethodOverride(resolutionResult.getSingleTarget())) {
+            continue;
+          }
         }
         Collection<DexEncodedMethod> targets = invoke.lookupTargets(appView, context.method.holder);
         assert invoke.isInvokeMethodWithDynamicDispatch()
             // For other invocation types, the size of targets should be at most one.
             || targets == null || targets.size() <= 1;
-        if (targets == null || targets.isEmpty()) {
+        if (targets == null || targets.isEmpty() || hasLibraryOverrides(targets)) {
           continue;
         }
         for (DexEncodedMethod target : targets) {
@@ -110,7 +116,7 @@
         Collection<DexEncodedMethod> targets =
             appView.appInfo().lookupLambdaImplementedMethods(
                 instruction.asInvokeCustom().getCallSite());
-        if (targets == null) {
+        if (targets == null || targets.isEmpty() || hasLibraryOverrides(targets)) {
           continue;
         }
         for (DexEncodedMethod target : targets) {
@@ -120,6 +126,30 @@
     }
   }
 
+  // TODO(b/140204899): Instead of reprocessing here, pass stopping criteria to lookup?
+  // If any of target method is a library method override, bail out entirely/early.
+  private boolean hasLibraryOverrides(Collection<DexEncodedMethod> targets) {
+    for (DexEncodedMethod target : targets) {
+      if (isLibraryMethodOrLibraryMethodOverride(target)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean isLibraryMethodOrLibraryMethodOverride(DexEncodedMethod target) {
+    // Not a program method.
+    if (!target.isProgramMethod(appView)) {
+      return true;
+    }
+    // If the method overrides a library method, it is unsure how the method would be invoked by
+    // that library.
+    if (target.isLibraryMethodOverride().isTrue()) {
+      return true;
+    }
+    return false;
+  }
+
   // Record arguments for the given method if necessary.
   // At the same time, if it decides to bail out, make the corresponding info immutable so that we
   // can avoid recording arguments for the same method accidentally.
@@ -142,9 +172,19 @@
     if (appView.appInfo().isPinned(target.method)) {
       return CallSiteOptimizationInfo.TOP;
     }
+    // Not a program method.
+    if (!target.isProgramMethod(appView)) {
+      // But, should not be reachable, since we already bail out.
+      assert false
+          : "Trying to compute call site optimization info for " + target.toSourceString();
+      return CallSiteOptimizationInfo.TOP;
+    }
     // If the method overrides a library method, it is unsure how the method would be invoked by
     // that library.
     if (target.isLibraryMethodOverride().isTrue()) {
+      // But, should not be reachable, since we already bail out.
+      assert false
+          : "Trying to compute call site optimization info for " + target.toSourceString();
       return CallSiteOptimizationInfo.TOP;
     }
     // If the program already has illegal accesses, method resolution results will reflect that too.
@@ -165,11 +205,9 @@
       return;
     }
     // TODO(b/139246447): Assert no BOTTOM left.
-    if (!callSiteOptimizationInfo.isConcreteCallSiteOptimizationInfo()) {
+    if (!callSiteOptimizationInfo.hasUsefulOptimizationInfo(appView, code.method)) {
       return;
     }
-    assert callSiteOptimizationInfo.asConcreteCallSiteOptimizationInfo()
-        .hasUsefulOptimizationInfo(appView, code.method);
     Set<Value> affectedValues = Sets.newIdentityHashSet();
     List<Assume<?>> assumeInstructions = new LinkedList<>();
     List<Instruction> constants = new LinkedList<>();
@@ -264,17 +302,16 @@
     for (DexProgramClass clazz : appView.appInfo().classes()) {
       for (DexEncodedMethod method : clazz.methods()) {
         assert !method.isObsolete();
-        if (method.shouldNotHaveCode()) {
-          assert !method.hasCode();
+        if (method.shouldNotHaveCode()
+            || !method.hasCode()
+            || method.getCode().isEmptyVoidMethod()) {
           continue;
         }
         // TODO(b/139246447): Assert no BOTTOM left.
         CallSiteOptimizationInfo callSiteOptimizationInfo = method.getCallSiteOptimizationInfo();
-        if (!callSiteOptimizationInfo.isConcreteCallSiteOptimizationInfo()) {
+        if (!callSiteOptimizationInfo.hasUsefulOptimizationInfo(appView, method)) {
           continue;
         }
-        assert callSiteOptimizationInfo.asConcreteCallSiteOptimizationInfo()
-            .hasUsefulOptimizationInfo(appView, method);
         targetsToRevisit.add(method);
         if (appView.options().testing.callSiteOptimizationInfoInspector != null) {
           appView.options().testing.callSiteOptimizationInfoInspector.accept(method);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index e1c583d..d48d1f2 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -1635,28 +1635,61 @@
   }
 
   /**
-   * If an instruction is known to be a /lit8 or /lit16 instruction, update the instruction to use
-   * its own constant that will be defined just before the instruction. This transformation allows
-   * to decrease pressure on register allocation by defining the shortest range of constant used
-   * by this kind of instruction. D8 knowns at build time that constant will be encoded
-   * directly into the final Dex instruction.
+   * If an instruction is known to be a binop/lit8 or binop//lit16 instruction, update the
+   * instruction to use its own constant that will be defined just before the instruction. This
+   * transformation allows to decrease pressure on register allocation by defining the shortest
+   * range of constant used by this kind of instruction. D8 knowns at build time that constant will
+   * be encoded directly into the final Dex instruction.
    */
   public void useDedicatedConstantForLitInstruction(IRCode code) {
+    if (!code.metadata().mayHaveArithmeticOrLogicalBinop()) {
+      return;
+    }
+
+    code.numberInstructionsPerBlock();
+
     for (BasicBlock block : code.blocks) {
       InstructionListIterator instructionIterator = block.listIterator(code);
+      // Collect all the non constant in values for binop/lit8 or binop/lit16 instructions.
+      Set<Value> binopsWithLit8OrLit16NonConstantValues = Sets.newIdentityHashSet();
       while (instructionIterator.hasNext()) {
         Instruction currentInstruction = instructionIterator.next();
-        if (shouldBeLitInstruction(currentInstruction)) {
-          assert currentInstruction.isBinop();
-          Binop binop = currentInstruction.asBinop();
-          Value constValue;
-          if (binop.leftValue().isConstNumber()) {
-            constValue = binop.leftValue();
-          } else if (binop.rightValue().isConstNumber()) {
-            constValue = binop.rightValue();
-          } else {
-            throw new Unreachable();
+        if (!isBinopWithLit8OrLit16(currentInstruction)) {
+          continue;
+        }
+        Value value = binopWithLit8OrLit16NonConstant(currentInstruction.asBinop());
+        assert value != null;
+        binopsWithLit8OrLit16NonConstantValues.add(value);
+      }
+      if (binopsWithLit8OrLit16NonConstantValues.isEmpty()) {
+        continue;
+      }
+      // Find last use in block of all the non constant in values for binop/lit8 or binop/lit16
+      // instructions.
+      Reference2IntMap<Value> lastUseOfBinopsWithLit8OrLit16NonConstantValues =
+          new Reference2IntOpenHashMap<>();
+      lastUseOfBinopsWithLit8OrLit16NonConstantValues.defaultReturnValue(-1);
+      while (instructionIterator.hasPrevious()) {
+        Instruction currentInstruction = instructionIterator.previous();
+        for (Value value : Iterables.concat(currentInstruction.inValues(), currentInstruction.getDebugValues())) {
+          if (!binopsWithLit8OrLit16NonConstantValues.contains(value)) {
+            continue;
           }
+          if (!lastUseOfBinopsWithLit8OrLit16NonConstantValues.containsKey(value)) {
+            lastUseOfBinopsWithLit8OrLit16NonConstantValues.put(
+                value, currentInstruction.getNumber());
+          }
+        }
+      }
+      // Do the transformation except if the binop can use the binop/2addr format.
+      while (instructionIterator.hasNext()) {
+        Instruction currentInstruction = instructionIterator.next();
+        if (!isBinopWithLit8OrLit16(currentInstruction)) {
+          continue;
+        }
+        Binop binop = currentInstruction.asBinop();
+        if (!canBe2AddrInstruction(binop, lastUseOfBinopsWithLit8OrLit16NonConstantValues)) {
+          Value constValue = binopWithLit8OrLit16Constant(currentInstruction);
           if (constValue.numberOfAllUsers() > 1) {
             // No need to do the transformation if the const value is already used only one time.
             ConstNumber newConstant = ConstNumber
@@ -1673,24 +1706,48 @@
       }
     }
 
+    code.clearInstructionNumbers();
+    assert code.hasNoInstructionNumbers();
+
     assert code.isConsistentSSA();
   }
 
-  /**
-   * A /lit8 or /lit16 instruction only concerns arithmetic or logical instruction. /lit8 or /lit16
-   * instructions generate bigger code than 2addr instructions, thus we favor 2addr instructions
-   * rather than /lit8 or /lit16 instructions.
-   */
-  private static boolean shouldBeLitInstruction(Instruction instruction) {
-    if (instruction.isArithmeticBinop() || instruction.isLogicalBinop()) {
-      Binop binop = instruction.asBinop();
-      if (!binop.needsValueInRegister(binop.leftValue()) ||
-          !binop.needsValueInRegister(binop.rightValue())) {
-        return !canBe2AddrInstruction(binop);
-      }
+  // Check if a binop can be represented in the binop/lit8 or binop/lit16 form.
+  private static boolean isBinopWithLit8OrLit16(Instruction instruction) {
+    if (!instruction.isArithmeticBinop() && !instruction.isLogicalBinop()) {
+      return false;
     }
+    Binop binop = instruction.asBinop();
+    // If one of the values does not need a register it is implicitly a binop/lit8 or binop/lit16.
+    boolean result =
+        !binop.needsValueInRegister(binop.leftValue())
+            || !binop.needsValueInRegister(binop.rightValue());
+    assert !result || binop.leftValue().isConstNumber() || binop.rightValue().isConstNumber();
+    return result;
+  }
 
-    return false;
+  // Return the constant in-value of a binop/lit8 or binop/lit16 instruction.
+  private static Value binopWithLit8OrLit16Constant(Instruction instruction) {
+    assert isBinopWithLit8OrLit16(instruction);
+    Binop binop = instruction.asBinop();
+    if (binop.leftValue().isConstNumber()) {
+      return binop.leftValue();
+    } else if (binop.rightValue().isConstNumber()) {
+      return binop.rightValue();
+    } else {
+      throw new Unreachable();
+    }
+  }
+
+  // Return the non-constant in-value of a binop/lit8 or binop/lit16 instruction.
+  private static Value binopWithLit8OrLit16NonConstant(Binop binop) {
+    if (binop.leftValue().isConstNumber()) {
+      return binop.rightValue();
+    } else if (binop.rightValue().isConstNumber()) {
+      return binop.leftValue();
+    } else {
+      throw new Unreachable();
+    }
   }
 
   /**
@@ -1698,28 +1755,28 @@
    * argument is no longer needed after the binary operation and can be overwritten. That is
    * definitely the case if there is no path between the binary operation and all other usages.
    */
-  private static boolean canBe2AddrInstruction(Binop binop) {
-    Value value = null;
-    if (binop.needsValueInRegister(binop.leftValue())) {
-      value = binop.leftValue();
-    } else if (binop.isCommutative() && binop.needsValueInRegister(binop.rightValue())) {
-      value = binop.rightValue();
+  private static boolean canBe2AddrInstruction(
+      Binop binop, Reference2IntMap<Value> lastUseOfRelevantValue) {
+    Value value = binopWithLit8OrLit16NonConstant(binop);
+    assert value != null;
+    int number = lastUseOfRelevantValue.getInt(value);
+    if (number > 0 && number > binop.getNumber()) {
+      return false;
+    }
+    Iterable<Instruction> users =
+        value.debugUsers() != null
+            ? Iterables.concat(value.uniqueUsers(), value.debugUsers())
+            : value.uniqueUsers();
+
+    for (Instruction user : users) {
+      if (hasPath(binop, user)) {
+        return false;
+      }
     }
 
-    if (value != null) {
-      Iterable<Instruction> users = value.debugUsers() != null ?
-          Iterables.concat(value.uniqueUsers(), value.debugUsers()) : value.uniqueUsers();
-
-      for (Instruction user : users) {
-        if (hasPath(binop, user)) {
-          return false;
-        }
-      }
-
-      for (Phi user : value.uniquePhiUsers()) {
-        if (binop.getBlock().hasPathTo(user.getBlock())) {
-          return false;
-        }
+    for (Phi user : value.uniquePhiUsers()) {
+      if (binop.getBlock().hasPathTo(user.getBlock())) {
+        return false;
       }
     }
 
@@ -1734,8 +1791,10 @@
     BasicBlock sourceBlock = source.getBlock();
     BasicBlock targetBlock = target.getBlock();
     if (sourceBlock == targetBlock) {
-      return sourceBlock.getInstructions().indexOf(source) <
-          targetBlock.getInstructions().indexOf(target);
+      // Instructions must be numbered when getting here.
+      assert source.getNumber() != -1;
+      assert target.getNumber() != -1;
+      return source.getNumber() < target.getNumber();
     }
 
     return source.getBlock().hasPathTo(targetBlock);
@@ -2542,9 +2601,10 @@
               }
             }
           } else {
-            AbstractValue abstractValue = lhs.getAbstractValue(appView);
+            DexType context = code.method.method.holder;
+            AbstractValue abstractValue = lhs.getAbstractValue(appView, context);
             if (abstractValue.isSingleEnumValue()) {
-              AbstractValue otherAbstractValue = rhs.getAbstractValue(appView);
+              AbstractValue otherAbstractValue = rhs.getAbstractValue(appView, context);
               if (abstractValue == otherAbstractValue) {
                 simplifyIfWithKnownCondition(code, block, theIf, 0);
               } else if (otherAbstractValue.isSingleEnumValue()) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java b/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
index f53d6d8..1382317 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
@@ -131,7 +131,7 @@
       }
       // Only canonicalize enum values. This is only OK if the instruction cannot have side effects.
       if (current.isStaticGet()) {
-        if (!current.outValue().getAbstractValue(appView).isSingleEnumValue()) {
+        if (!current.outValue().getAbstractValue(appView, context).isSingleEnumValue()) {
           continue;
         }
         if (current.instructionMayHaveSideEffects(appView, context)) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index c3fe726..6a9c3af 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -812,6 +812,14 @@
   public void performForcedInlining(
       DexEncodedMethod method,
       IRCode code,
+      Map<? extends InvokeMethod, InliningInfo> invokesToInline) {
+    performForcedInlining(
+        method, code, invokesToInline, new InliningIRProvider(appView, method, code));
+  }
+
+  public void performForcedInlining(
+      DexEncodedMethod method,
+      IRCode code,
       Map<? extends InvokeMethod, InliningInfo> invokesToInline,
       InliningIRProvider inliningIRProvider) {
     ForcedInliningOracle oracle = new ForcedInliningOracle(appView, method, invokesToInline);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index 2945c6e..ddb7e99 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -220,16 +220,25 @@
           continue;
         }
 
+        assert processor.getReceivers().verifyReceiverSetsAreDisjoint();
+
         // Is inlining allowed.
-        if (processor.getEstimatedCombinedSizeForInlining()
-            >= appView.options().classInliningInstructionAllowance) {
+        InliningIRProvider inliningIRProvider = new InliningIRProvider(appView, method, code);
+        ClassInlinerCostAnalysis costAnalysis =
+            new ClassInlinerCostAnalysis(
+                appView, inliningIRProvider, processor.getReceivers().getDefiniteReceiverAliases());
+        if (costAnalysis.willExceedInstructionBudget(
+            code, processor.getDirectInlinees(), processor.getIndirectInlinees())) {
+          // This root is unlikely to be inlined in the future.
+          rootsIterator.remove();
           continue;
         }
 
         // Inline the class instance.
-        InliningIRProvider inliningIRProvider = new InliningIRProvider(appView, method, code);
         anyInlinedMethods |= processor.processInlining(code, defaultOracle, inliningIRProvider);
 
+        assert inliningIRProvider.verifyIRCacheIsEmpty();
+
         // Restore normality.
         Set<Value> affectedValues = Sets.newIdentityHashSet();
         code.removeAllTrivialPhis(affectedValues);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerCostAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerCostAnalysis.java
new file mode 100644
index 0000000..9b9670e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerCostAnalysis.java
@@ -0,0 +1,149 @@
+// Copyright (c) 2019, 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.classinliner;
+
+import static com.android.tools.r8.ir.code.Opcodes.ARGUMENT;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_GET;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_PUT;
+import static com.android.tools.r8.ir.code.Opcodes.RETURN;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.optimize.inliner.InliningIRProvider;
+import com.google.common.collect.Sets;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/** Analysis that estimates the cost of class inlining an object allocation. */
+class ClassInlinerCostAnalysis {
+
+  private final AppView<?> appView;
+  private final InliningIRProvider inliningIRProvider;
+  private final Set<Value> definiteReceiverAliases;
+
+  private int estimatedCost = 0;
+
+  ClassInlinerCostAnalysis(
+      AppView<?> appView,
+      InliningIRProvider inliningIRProvider,
+      Set<Value> definiteReceiverAliases) {
+    this.appView = appView;
+    this.inliningIRProvider = inliningIRProvider;
+    this.definiteReceiverAliases = definiteReceiverAliases;
+  }
+
+  boolean willExceedInstructionBudget(
+      IRCode code,
+      Map<InvokeMethod, DexEncodedMethod> directInlinees,
+      List<DexEncodedMethod> indirectInlinees) {
+    for (DexEncodedMethod inlinee : indirectInlinees) {
+      // We do not have the corresponding invoke instruction for the inlinees that are not called
+      // directly from `code` (these are called indirectly from one of the methods in
+      // `directInlinees`). Therefore, we currently choose not to build IR for estimating the number
+      // of non-materializing instructions, since we cannot cache the IR (it would have the wrong
+      // position).
+      int increment = inlinee.getCode().estimatedSizeForInlining();
+      if (exceedsInstructionBudgetAfterIncrement(increment)) {
+        return true;
+      }
+    }
+
+    // Visit the direct inlinees in a deterministic order to ensure that the state of the value
+    // number generated is deterministic for each inlinee.
+    int numberOfSeenDirectInlinees = 0;
+    int numberOfDirectInlinees = directInlinees.size();
+    for (InvokeMethod invoke : code.<InvokeMethod>instructions(Instruction::isInvokeMethod)) {
+      DexEncodedMethod inlinee = directInlinees.get(invoke);
+      if (inlinee == null) {
+        // Not a direct inlinee.
+        continue;
+      }
+      IRCode inliningIR = inliningIRProvider.getAndCacheInliningIR(invoke, inlinee);
+      int increment =
+          inlinee.getCode().estimatedSizeForInlining()
+              - estimateNumberOfNonMaterializingInstructions(invoke, inliningIR);
+      assert increment >= 0;
+      if (exceedsInstructionBudgetAfterIncrement(increment)) {
+        return true;
+      }
+      if (++numberOfSeenDirectInlinees == numberOfDirectInlinees) {
+        break;
+      }
+    }
+
+    // Verify that all direct inlinees have been visited.
+    assert numberOfSeenDirectInlinees == numberOfDirectInlinees;
+
+    return false;
+  }
+
+  private boolean exceedsInstructionBudgetAfterIncrement(int increment) {
+    estimatedCost += increment;
+    return estimatedCost > appView.options().classInliningInstructionAllowance;
+  }
+
+  // TODO(b/143176500): Do not include instructions that will be canonicalized after inlining.
+  //  Take care of that fact that after inlining the first method, this could introduce a constant
+  //  in the caller, which could then lead to a constant in the second inlinee being canonicalized.
+  // TODO(b/143176500): Do not include instructions that will be dead code eliminated as a result of
+  //  constant arguments.
+  private int estimateNumberOfNonMaterializingInstructions(InvokeMethod invoke, IRCode inlinee) {
+    int result = 0;
+    Set<Value> receiverAliasesInInlinee = null;
+    for (Instruction instruction : inlinee.instructions()) {
+      switch (instruction.opcode()) {
+        case ARGUMENT:
+          // Intentionally not counted as a non-materializing instruction, since there are no
+          // argument instructions in the CF/DEX code.
+          break;
+
+        case INSTANCE_GET:
+        case INSTANCE_PUT:
+          // Will not materialize after class inlining if the object is the "root" instance.
+          Value object =
+              instruction.isInstanceGet()
+                  ? instruction.asInstanceGet().object()
+                  : instruction.asInstancePut().object();
+          Value root = object.getAliasedValue();
+          if (receiverAliasesInInlinee == null) {
+            receiverAliasesInInlinee = getReceiverAliasesInInlinee(invoke, inlinee);
+          }
+          if (receiverAliasesInInlinee.contains(root)) {
+            result++;
+          }
+          break;
+
+        case RETURN:
+          // Wil not materialize after class inlining.
+          result++;
+          break;
+
+        default:
+          // Will materialize.
+          break;
+      }
+    }
+    return result;
+  }
+
+  private Set<Value> getReceiverAliasesInInlinee(InvokeMethod invoke, IRCode inlinee) {
+    List<Value> arguments = inlinee.collectArguments();
+    Set<Value> receiverAliasesInInlinee = Sets.newIdentityHashSet();
+    for (int i = 0; i < invoke.inValues().size(); i++) {
+      Value inValue = invoke.inValues().get(i);
+      if (definiteReceiverAliases.contains(inValue)) {
+        receiverAliasesInInlinee.add(arguments.get(i));
+      } else {
+        assert !definiteReceiverAliases.contains(inValue.getAliasedValue());
+      }
+    }
+    return receiverAliasesInInlinee;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerEligibilityInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerEligibilityInfo.java
new file mode 100644
index 0000000..a80a9ec
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerEligibilityInfo.java
@@ -0,0 +1,21 @@
+// Copyright (c) 2019, 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.classinliner;
+
+import com.android.tools.r8.utils.OptionalBool;
+
+public class ClassInlinerEligibilityInfo {
+
+  /**
+   * Set to {@link OptionalBool#TRUE} if the method is guaranteed to return the receiver, {@link
+   * OptionalBool#FALSE} if the method is guaranteed not to return the receiver, and {@link
+   * OptionalBool#UNKNOWN} if the method may return the receiver.
+   */
+  final OptionalBool returnsReceiver;
+
+  public ClassInlinerEligibilityInfo(OptionalBool returnsReceiver) {
+    this.returnsReceiver = returnsReceiver;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerReceiverAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerReceiverAnalysis.java
new file mode 100644
index 0000000..f6e6e70
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerReceiverAnalysis.java
@@ -0,0 +1,135 @@
+// Copyright (c) 2019, 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.classinliner;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
+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.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.utils.BooleanLatticeElement;
+import com.android.tools.r8.utils.OptionalBool;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This analysis determines whether a method returns the receiver. The analysis is specific to the
+ * class inliner, and the result is therefore not sound in general.
+ *
+ * <p>The analysis makes the following assumptions.
+ *
+ * <ul>
+ *   <li>None of the given method's arguments is an alias of the receiver (except for the receiver
+ *       itself).
+ *   <li>The receiver is not stored in the heap. Thus, it is guaranteed that (i) all field-get
+ *       instructions do not return an alias of the receiver, and (ii) invoke instructions can only
+ *       return an alias of the receiver if the receiver is given as an argument.
+ * </ul>
+ */
+public class ClassInlinerReceiverAnalysis {
+
+  private final AppView<?> appView;
+  private final DexEncodedMethod method;
+  private final IRCode code;
+  private final Value receiver;
+
+  private final Map<Value, OptionalBool> isReceiverAliasCache = new IdentityHashMap<>();
+
+  public ClassInlinerReceiverAnalysis(AppView<?> appView, DexEncodedMethod method, IRCode code) {
+    this.appView = appView;
+    this.method = method;
+    this.code = code;
+    this.receiver = code.getThis();
+    assert !receiver.hasAliasedValue();
+    assert receiver.getTypeLattice().isClassType();
+  }
+
+  public OptionalBool computeReturnsReceiver() {
+    if (method.method.proto.returnType.isVoidType()) {
+      return OptionalBool.FALSE;
+    }
+
+    List<BasicBlock> normalExitBlocks = code.computeNormalExitBlocks();
+    if (normalExitBlocks.isEmpty()) {
+      return OptionalBool.FALSE;
+    }
+
+    BooleanLatticeElement result = OptionalBool.BOTTOM;
+    for (BasicBlock block : normalExitBlocks) {
+      Value returnValue = block.exit().asReturn().returnValue();
+      result = result.join(getOrComputeIsReceiverAlias(returnValue));
+
+      // Stop as soon as we reach unknown.
+      if (result.isUnknown()) {
+        return OptionalBool.UNKNOWN;
+      }
+    }
+    assert !result.isBottom();
+    return result.asOptionalBool();
+  }
+
+  private OptionalBool getOrComputeIsReceiverAlias(Value value) {
+    Value root = value.getAliasedValue();
+    return isReceiverAliasCache.computeIfAbsent(root, this::computeIsReceiverAlias);
+  }
+
+  private OptionalBool computeIsReceiverAlias(Value value) {
+    assert !value.hasAliasedValue();
+
+    if (value == receiver) {
+      // Guaranteed to return the receiver.
+      return OptionalBool.TRUE;
+    }
+
+    ClassTypeLatticeElement valueType = value.getTypeLattice().asClassTypeLatticeElement();
+    if (valueType == null) {
+      return OptionalBool.FALSE;
+    }
+
+    ClassTypeLatticeElement receiverType = receiver.getTypeLattice().asClassTypeLatticeElement();
+    if (!valueType.isRelatedTo(receiverType, appView)) {
+      // Guaranteed not to return the receiver.
+      return OptionalBool.FALSE;
+    }
+
+    if (value.isPhi()) {
+      // Not sure what is returned.
+      return OptionalBool.UNKNOWN;
+    }
+
+    Instruction definition = value.definition;
+    if (definition.isArrayGet() || definition.isFieldGet()) {
+      // Guaranteed not to return the receiver, since the class inliner does not allow the
+      // receiver to flow into any arrays or fields.
+      return OptionalBool.FALSE;
+    }
+
+    if (definition.isConstInstruction() || definition.isCreatingInstanceOrArray()) {
+      // Guaranteed not to return the receiver.
+      return OptionalBool.FALSE;
+    }
+
+    if (definition.isInvokeMethod()) {
+      // Since the class inliner does not allow the receiver to flow into the heap, the only way for
+      // the invoked method to return the receiver is if one of the given arguments is an alias of
+      // the receiver.
+      InvokeMethod invoke = definition.asInvokeMethod();
+      for (Value argument : invoke.arguments()) {
+        if (getOrComputeIsReceiverAlias(argument).isPossiblyTrue()) {
+          return OptionalBool.UNKNOWN;
+        }
+      }
+
+      return OptionalBool.FALSE;
+    }
+
+    // Not sure what is returned.
+    return OptionalBool.UNKNOWN;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerReceiverSet.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerReceiverSet.java
new file mode 100644
index 0000000..5a8c59d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerReceiverSet.java
@@ -0,0 +1,127 @@
+// Copyright (c) 2019, 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.classinliner;
+
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.optimize.classinliner.InlineCandidateProcessor.AliasKind;
+import com.android.tools.r8.utils.SetUtils;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BooleanSupplier;
+
+class ClassInlinerReceiverSet {
+
+  private final Value root;
+
+  private final Set<Value> definiteReceiverAliases;
+  private final Set<Value> maybeReceiverAliases = Sets.newIdentityHashSet();
+
+  // Set of values that are not allowed to become an alias of the receiver.
+  private final Set<Value> illegalReceiverAliases = Sets.newIdentityHashSet();
+
+  // Set of values that are allowed to become an alias of the receiver under certain circumstances.
+  private final Map<Value, List<BooleanSupplier>> deferredAliasValidityChecks =
+      new IdentityHashMap<>();
+
+  ClassInlinerReceiverSet(Value root) {
+    this.definiteReceiverAliases = SetUtils.newIdentityHashSet(root);
+    this.root = root;
+  }
+
+  Set<Value> getDefiniteReceiverAliases() {
+    return definiteReceiverAliases;
+  }
+
+  Set<Value> getMaybeReceiverAliases() {
+    return maybeReceiverAliases;
+  }
+
+  boolean addReceiverAlias(Value alias, AliasKind kind) {
+    if (isIllegalReceiverAlias(alias)) {
+      return false; // Not allowed.
+    }
+    // All checks passed.
+    deferredAliasValidityChecks.remove(alias);
+    boolean changed;
+    if (kind == AliasKind.DEFINITE) {
+      assert !maybeReceiverAliases.contains(alias);
+      changed = definiteReceiverAliases.add(alias);
+    } else {
+      assert !definiteReceiverAliases.contains(alias);
+      changed = maybeReceiverAliases.add(alias);
+    }
+    // Verify that the state changed. Otherwise, we are analyzing the same instruction more than
+    // once.
+    assert changed : alias.toString() + " already added as an alias";
+    return true;
+  }
+
+  boolean addIllegalReceiverAlias(Value value) {
+    if (isReceiverAlias(value)) {
+      return false;
+    }
+    illegalReceiverAliases.add(value);
+    // Since `value` is never allowed as a receiver, there is no need to keep the validity checks
+    // around.
+    deferredAliasValidityChecks.remove(value);
+    return true;
+  }
+
+  void addDeferredAliasValidityCheck(Value value, BooleanSupplier deferredValidityCheck) {
+    assert !isReceiverAlias(value);
+    // Only add the deferred validity check if `value` may be allowed as a receiver (i.e., it is not
+    // already illegal).
+    if (illegalReceiverAliases.contains(value)) {
+      assert !deferredAliasValidityChecks.containsKey(value);
+    } else {
+      deferredAliasValidityChecks
+          .computeIfAbsent(value, ignore -> new ArrayList<>())
+          .add(deferredValidityCheck);
+    }
+  }
+
+  boolean isReceiverAlias(Value value) {
+    return isDefiniteReceiverAlias(value) || isMaybeReceiverAlias(value);
+  }
+
+  boolean isDefiniteReceiverAlias(Value value) {
+    return definiteReceiverAliases.contains(value);
+  }
+
+  private boolean isMaybeReceiverAlias(Value value) {
+    return maybeReceiverAliases.contains(value);
+  }
+
+  private boolean isIllegalReceiverAlias(Value value) {
+    if (illegalReceiverAliases.contains(value)) {
+      return true;
+    }
+    List<BooleanSupplier> deferredValidityChecks = deferredAliasValidityChecks.get(value);
+    if (deferredValidityChecks != null) {
+      for (BooleanSupplier deferredValidityCheck : deferredValidityChecks) {
+        if (!deferredValidityCheck.getAsBoolean()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  void reset() {
+    deferredAliasValidityChecks.clear();
+    definiteReceiverAliases.clear();
+    definiteReceiverAliases.add(root);
+    maybeReceiverAliases.clear();
+  }
+
+  boolean verifyReceiverSetsAreDisjoint() {
+    assert Sets.intersection(getMaybeReceiverAliases(), getDefiniteReceiverAliases()).isEmpty();
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 096699b..36112c9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -4,11 +4,12 @@
 
 package com.android.tools.r8.ir.optimize.classinliner;
 
+
 import com.android.tools.r8.errors.Unreachable;
 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.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
@@ -21,6 +22,7 @@
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.InstanceGet;
+import com.android.tools.r8.ir.code.InstancePut;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionOrPhi;
 import com.android.tools.r8.ir.code.Invoke.Type;
@@ -43,9 +45,7 @@
 import com.android.tools.r8.ir.optimize.inliner.NopWhyAreYouNotInliningReporter;
 import com.android.tools.r8.kotlin.KotlinInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.Pair;
-import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
@@ -63,6 +63,12 @@
 import java.util.function.Supplier;
 
 final class InlineCandidateProcessor {
+
+  enum AliasKind {
+    DEFINITE,
+    MAYBE
+  }
+
   private static final ImmutableSet<If.Type> ALLOWED_ZERO_TEST_TYPES =
       ImmutableSet.of(If.Type.EQ, If.Type.NE);
 
@@ -86,12 +92,12 @@
   private final List<Pair<InvokeMethod, Integer>> unusedArguments
       = new ArrayList<>();
 
-  private int estimatedCombinedSizeForInlining = 0;
+  private final Map<InvokeMethod, DexEncodedMethod> directInlinees = new IdentityHashMap<>();
+  private final List<DexEncodedMethod> indirectInlinees = new ArrayList<>();
 
-  // Set of values that may be an alias of the "root" instance (including the root instance itself).
-  // TODO(b/144825216): Distinguish the "may-aliases" from the "must-aliases" such that the cost
-  //  analysis is not optimistic.
-  private final Set<Value> receivers;
+  // Sets of values that must/may be an alias of the "root" instance (including the root instance
+  // itself).
+  private final ClassInlinerReceiverSet receivers;
 
   InlineCandidateProcessor(
       AppView<AppInfoWithLiveness> appView,
@@ -108,14 +114,18 @@
     this.method = method;
     this.root = root;
     this.isProcessedConcurrently = isProcessedConcurrently;
-    this.receivers = SetUtils.newIdentityHashSet(root.outValue());
+    this.receivers = new ClassInlinerReceiverSet(root.outValue());
   }
 
-  int getEstimatedCombinedSizeForInlining() {
-    return estimatedCombinedSizeForInlining;
+  Map<InvokeMethod, DexEncodedMethod> getDirectInlinees() {
+    return directInlinees;
   }
 
-  Set<Value> getReceivers() {
+  List<DexEncodedMethod> getIndirectInlinees() {
+    return indirectInlinees;
+  }
+
+  ClassInlinerReceiverSet getReceivers() {
     return receivers;
   }
 
@@ -282,24 +292,28 @@
       for (Instruction user : currentUsers) {
         if (user.isAssume()) {
           Value alias = user.outValue();
+          if (receivers.isReceiverAlias(alias)) {
+            continue; // Already processed.
+          }
           if (alias.hasPhiUsers()) {
             return alias.firstPhiUser(); // Not eligible.
           }
-          receivers.add(alias);
+          if (!receivers.addReceiverAlias(alias, AliasKind.DEFINITE)) {
+            return user; // Not eligible.
+          }
           indirectUsers.addAll(alias.uniqueUsers());
           continue;
         }
         // Field read/write.
         if (user.isInstanceGet()
-            || (user.isInstancePut() && user.asInstancePut().value() != eligibleInstance)) {
-          DexField field = user.asFieldInstruction().getField();
-          if (field.holder == eligibleClass
-              && eligibleClassDefinition.lookupInstanceField(field) != null) {
-            // Since class inliner currently only supports classes directly extending
-            // java.lang.Object, we don't need to worry about fields defined in superclasses.
-            continue;
+            || (user.isInstancePut()
+                && receivers.addIllegalReceiverAlias(user.asInstancePut().value()))) {
+          DexEncodedField field =
+              appView.appInfo().resolveField(user.asFieldInstruction().getField());
+          if (field == null || field.isStatic()) {
+            return user; // Not eligible.
           }
-          return user; // Not eligible.
+          continue;
         }
 
         if (user.isInvokeMethod()) {
@@ -393,7 +407,7 @@
       methodCallsOnInstance.clear();
       extraMethodCalls.clear();
       unusedArguments.clear();
-      estimatedCombinedSizeForInlining = 0;
+      receivers.reset();
 
       // Repeat user analysis
       InstructionOrPhi ineligibleUser = areInstanceUsersEligible(defaultOracle);
@@ -405,6 +419,7 @@
         // methods (which is bad for memory), or we would need to analyze the called methods before
         // inlining them. The latter could be good solution, since we are going to build IR for the
         // methods that need to be inlined anyway.
+        assert appView.options().testing.allowClassInlinerGracefulExit;
         return true;
       }
       assert extraMethodCalls.isEmpty()
@@ -432,7 +447,7 @@
       block.listIterator(code, invoke).add(nullValue);
       assert nullValue.getBlock() == block;
 
-      int argIndex = unusedArgument.getSecond() + (invoke.isInvokeMethodWithReceiver() ? 1 : 0);
+      int argIndex = unusedArgument.getSecond();
       invoke.replaceValue(argIndex, nullValue.outValue());
     }
     unusedArguments.clear();
@@ -453,10 +468,44 @@
     if (methodCallsOnInstance.isEmpty()) {
       return false;
     }
+
     assert methodCallsOnInstance.keySet().stream()
         .map(InvokeMethodWithReceiver::getReceiver)
-        .allMatch(receivers::contains);
+        .allMatch(receivers::isReceiverAlias);
+
     inliner.performForcedInlining(method, code, methodCallsOnInstance, inliningIRProvider);
+
+    // In case we are class inlining an object allocation that does not inherit directly from
+    // java.lang.Object, we need keep force inlining the constructor until we reach
+    // java.lang.Object.<init>().
+    if (root.isNewInstance()) {
+      do {
+        methodCallsOnInstance.clear();
+        for (Instruction instruction : eligibleInstance.uniqueUsers()) {
+          if (instruction.isInvokeDirect()) {
+            InvokeDirect invoke = instruction.asInvokeDirect();
+            Value receiver = invoke.getReceiver();
+            if (receiver == eligibleInstance) {
+              DexMethod invokedMethod = invoke.getInvokedMethod();
+              if (appView.dexItemFactory().isConstructor(invokedMethod)
+                  && invokedMethod != appView.dexItemFactory().objectMethods.constructor) {
+                methodCallsOnInstance.put(
+                    invoke,
+                    new InliningInfo(
+                        appView.definitionFor(invokedMethod), root.asNewInstance().clazz));
+                break;
+              }
+            } else {
+              assert receiver.getAliasedValue() != eligibleInstance;
+            }
+          }
+        }
+        if (!methodCallsOnInstance.isEmpty()) {
+          inliner.performForcedInlining(method, code, methodCallsOnInstance, inliningIRProvider);
+        }
+      } while (!methodCallsOnInstance.isEmpty());
+    }
+
     return true;
   }
 
@@ -468,7 +517,7 @@
       Assume<?> assumeInstruction = user.asAssume();
       Value src = assumeInstruction.src();
       Value dest = assumeInstruction.outValue();
-      assert receivers.contains(dest);
+      assert receivers.isReceiverAlias(dest);
       assert !dest.hasPhiUsers();
       dest.replaceUsers(src);
       removeInstruction(user);
@@ -481,13 +530,14 @@
   private void removeMiscUsages(IRCode code) {
     boolean needToRemoveUnreachableBlocks = false;
     for (Instruction user : eligibleInstance.uniqueUsers()) {
-      // Remove the call to superclass constructor.
-      if (root.isNewInstance()
-          && user.isInvokeDirect()
-          && appView.dexItemFactory().isConstructor(user.asInvokeDirect().getInvokedMethod())
-          && user.asInvokeDirect().getInvokedMethod().holder == eligibleClassDefinition.superType) {
-        removeInstruction(user);
-        continue;
+      // Remove the call to java.lang.Object.<init>().
+      if (user.isInvokeDirect()) {
+        InvokeDirect invoke = user.asInvokeDirect();
+        if (root.isNewInstance()
+            && invoke.getInvokedMethod() == appView.dexItemFactory().objectMethods.constructor) {
+          removeInstruction(invoke);
+          continue;
+        }
       }
 
       if (user.isIf()) {
@@ -601,7 +651,10 @@
                 + "` after field reads removed: "
                 + user);
       }
-      if (user.asInstancePut().getField().holder != eligibleClass) {
+      InstancePut instancePut = user.asInstancePut();
+      DexEncodedField field =
+          appView.appInfo().resolveFieldOn(eligibleClassDefinition, instancePut.getField());
+      if (field == null) {
         throw new Unreachable(
             "Unexpected field write left in method `"
                 + method.method.toSourceString()
@@ -618,11 +671,18 @@
     assert isEligibleSingleTarget(singleTarget);
 
     // Must be a constructor called on the receiver.
-    if (ListUtils.lastIndexMatching(
-        invoke.inValues(), v -> v.getAliasedValue() == eligibleInstance) != 0) {
+    if (!receivers.isDefiniteReceiverAlias(invoke.getReceiver())) {
       return null;
     }
 
+    // None of the subsequent arguments may be an alias of the receiver.
+    List<Value> inValues = invoke.inValues();
+    for (int i = 1; i < inValues.size(); i++) {
+      if (!receivers.addIllegalReceiverAlias(inValues.get(i))) {
+        return null;
+      }
+    }
+
     // Must be a constructor of the exact same class.
     DexMethod init = invoke.getInvokedMethod();
     if (init.holder != eligibleClass) {
@@ -639,7 +699,7 @@
 
     if (isDesugaredLambda) {
       // Lambda desugaring synthesizes eligible constructors.
-      markSizeForInlining(singleTarget);
+      markSizeForInlining(invoke, singleTarget);
       return new InliningInfo(singleTarget, eligibleClass);
     }
 
@@ -681,10 +741,10 @@
   //   other invocations. In that case, we should add all indirect users of the out value to ensure
   //   they can also be inlined.
   private boolean isEligibleInvokeWithAllUsersAsReceivers(
-      ClassInlinerEligibility eligibility,
+      ClassInlinerEligibilityInfo eligibility,
       InvokeMethodWithReceiver invoke,
       Set<Instruction> indirectUsers) {
-    if (!eligibility.returnsReceiver) {
+    if (eligibility.returnsReceiver.isFalse()) {
       return true;
     }
 
@@ -700,9 +760,13 @@
       return false;
     }
 
-    // Since the invoke-instruction may return the receiver, the out-value may be an alias of the
-    // receiver.
-    receivers.add(outValue);
+    // Add the out-value as a definite-alias if the invoke instruction is guaranteed to return the
+    // receiver. Otherwise, the out-value may be an alias of the receiver, and it is added to the
+    // may-alias set.
+    AliasKind kind = eligibility.returnsReceiver.isTrue() ? AliasKind.DEFINITE : AliasKind.MAYBE;
+    if (!receivers.addReceiverAlias(outValue, kind)) {
+      return false;
+    }
 
     Set<Instruction> currentUsers = outValue.uniqueUsers();
     while (!currentUsers.isEmpty()) {
@@ -713,24 +777,29 @@
           if (outValueAlias.hasPhiUsers() || outValueAlias.hasDebugUsers()) {
             return false;
           }
-          receivers.add(outValueAlias);
+          if (!receivers.addReceiverAlias(outValueAlias, kind)) {
+            return false;
+          }
           indirectOutValueUsers.addAll(outValueAlias.uniqueUsers());
           continue;
         }
-        if (!instruction.isInvokeMethodWithReceiver()) {
-          return false;
-        }
-        InvokeMethodWithReceiver user = instruction.asInvokeMethodWithReceiver();
-        if (user.getReceiver().getAliasedValue() != outValue) {
-          return false;
-        }
-        for (int i = 1; i < user.inValues().size(); i++) {
-          if (user.inValues().get(i).getAliasedValue() == outValue) {
+
+        if (instruction.isInvokeMethodWithReceiver()) {
+          InvokeMethodWithReceiver user = instruction.asInvokeMethodWithReceiver();
+          if (user.getReceiver().getAliasedValue() != outValue) {
             return false;
           }
+          for (int i = 1; i < user.inValues().size(); i++) {
+            if (user.inValues().get(i).getAliasedValue() == outValue) {
+              return false;
+            }
+          }
+          indirectUsers.add(user);
+          continue;
         }
+
+        return false;
       }
-      indirectUsers.addAll(currentUsers);
       currentUsers = indirectOutValueUsers;
     }
 
@@ -743,10 +812,15 @@
       Set<Instruction> indirectUsers,
       Supplier<InliningOracle> defaultOracle) {
     assert isEligibleSingleTarget(singleTarget);
-    if (ListUtils.lastIndexMatching(
-        invoke.inValues(), v -> v.getAliasedValue() == eligibleInstance) > 0) {
-      return null; // Instance passed as an argument.
+
+    // None of the none-receiver arguments may be an alias of the receiver.
+    List<Value> inValues = invoke.inValues();
+    for (int i = 1; i < inValues.size(); i++) {
+      if (!receivers.addIllegalReceiverAlias(inValues.get(i))) {
+        return null;
+      }
     }
+
     // TODO(b/141719453): Should not constrain library overrides if all instantiations are inlined.
     if (singleTarget.isLibraryMethodOverride().isTrue()) {
       InliningOracle inliningOracle = defaultOracle.get();
@@ -756,7 +830,7 @@
       }
     }
     return isEligibleVirtualMethodCall(
-        !invoke.getBlock().hasCatchHandlers(),
+        invoke,
         invoke.getInvokedMethod(),
         singleTarget,
         eligibility -> isEligibleInvokeWithAllUsersAsReceivers(eligibility, invoke, indirectUsers));
@@ -766,16 +840,16 @@
     DexEncodedMethod singleTarget = eligibleClassDefinition.lookupVirtualMethod(callee);
     if (isEligibleSingleTarget(singleTarget)) {
       return isEligibleVirtualMethodCall(
-          false, callee, singleTarget, eligibility -> !eligibility.returnsReceiver);
+          null, callee, singleTarget, eligibility -> eligibility.returnsReceiver.isFalse());
     }
     return null;
   }
 
   private InliningInfo isEligibleVirtualMethodCall(
-      boolean allowMethodsWithoutNormalReturns,
+      InvokeMethodWithReceiver invoke,
       DexMethod callee,
       DexEncodedMethod singleTarget,
-      Predicate<ClassInlinerEligibility> eligibilityAcceptanceCheck) {
+      Predicate<ClassInlinerEligibilityInfo> eligibilityAcceptanceCheck) {
     assert isEligibleSingleTarget(singleTarget);
 
     // We should not inline a method if the invocation has type interface or virtual and the
@@ -794,13 +868,13 @@
     }
 
     if (isDesugaredLambda && !singleTarget.accessFlags.isBridge()) {
-      markSizeForInlining(singleTarget);
+      markSizeForInlining(invoke, singleTarget);
       return new InliningInfo(singleTarget, eligibleClass);
     }
 
     MethodOptimizationInfo optimizationInfo = singleTarget.getOptimizationInfo();
 
-    ClassInlinerEligibility eligibility = optimizationInfo.getClassInlinerEligibility();
+    ClassInlinerEligibilityInfo eligibility = optimizationInfo.getClassInlinerEligibility();
     if (eligibility == null) {
       return null;
     }
@@ -811,7 +885,7 @@
       return null;
     }
 
-    markSizeForInlining(singleTarget);
+    markSizeForInlining(invoke, singleTarget);
     return new InliningInfo(singleTarget, eligibleClass);
   }
 
@@ -820,10 +894,11 @@
         && appView.dexItemFactory().isConstructor(invoke.getInvokedMethod())) {
       return false;
     }
-    if (invoke.isInvokeMethodWithReceiver()
-        && invoke.asInvokeMethodWithReceiver().getReceiver().getAliasedValue()
-            == eligibleInstance) {
-      return false;
+    if (invoke.isInvokeMethodWithReceiver()) {
+      Value receiver = invoke.asInvokeMethodWithReceiver().getReceiver();
+      if (!receivers.addIllegalReceiverAlias(receiver)) {
+        return false;
+      }
     }
     if (invoke.isInvokeSuper()) {
       return false;
@@ -863,13 +938,13 @@
 
     // If we got here with invocation on receiver the user is ineligible.
     if (invoke.isInvokeMethodWithReceiver()) {
-      if (arguments.get(0).getAliasedValue() == eligibleInstance) {
+      InvokeMethodWithReceiver invokeMethodWithReceiver = invoke.asInvokeMethodWithReceiver();
+      Value receiver = invokeMethodWithReceiver.getReceiver();
+      if (!receivers.addIllegalReceiverAlias(receiver)) {
         return false;
       }
 
       // TODO(b/124842076) Extend this check to use checksNullReceiverBeforeAnySideEffect.
-      InvokeMethodWithReceiver invokeMethodWithReceiver = invoke.asInvokeMethodWithReceiver();
-      Value receiver = invokeMethodWithReceiver.getReceiver();
       if (receiver.getTypeLattice().isNullable()) {
         return false;
       }
@@ -883,8 +958,11 @@
     }
 
     for (int argIndex = 0; argIndex < arguments.size(); argIndex++) {
-      Value argument = arguments.get(argIndex);
-      if (argument == eligibleInstance && optimizationInfo.getParameterUsages(argIndex).notUsed()) {
+      Value argument = arguments.get(argIndex).getAliasedValue();
+      ParameterUsage parameterUsage = optimizationInfo.getParameterUsages(argIndex);
+      if (receivers.isDefiniteReceiverAlias(argument)
+          && parameterUsage != null
+          && parameterUsage.notUsed()) {
         // Reference can be removed since it's not used.
         unusedArguments.add(new Pair<>(invoke, argIndex));
       }
@@ -893,7 +971,7 @@
     extraMethodCalls.put(invoke, new InliningInfo(singleTarget, null));
 
     // Looks good.
-    markSizeForInlining(singleTarget);
+    markSizeForInlining(invoke, singleTarget);
     return true;
   }
 
@@ -904,16 +982,19 @@
       Supplier<InliningOracle> defaultOracle) {
     // Go through all arguments, see if all usages of eligibleInstance are good.
     for (int argIndex = 0; argIndex < arguments.size(); argIndex++) {
-      Value argument = arguments.get(argIndex).getAliasedValue();
-      if (argument != eligibleInstance) {
-        continue; // Nothing to worry about.
-      }
-
-      // Have parameter usage info?
       MethodOptimizationInfo optimizationInfo = singleTarget.getOptimizationInfo();
       ParameterUsage parameterUsage = optimizationInfo.getParameterUsages(argIndex);
-      if (!isEligibleParameterUsage(parameterUsage, invoke, defaultOracle)) {
-        return false;
+
+      Value argument = arguments.get(argIndex);
+      if (receivers.isReceiverAlias(argument)) {
+        // Have parameter usage info?
+        if (!isEligibleParameterUsage(parameterUsage, invoke, defaultOracle)) {
+          return false;
+        }
+      } else {
+        // Nothing to worry about, unless `argument` becomes an alias of the receiver later.
+        receivers.addDeferredAliasValidityCheck(
+            argument, () -> isEligibleParameterUsage(parameterUsage, invoke, defaultOracle));
       }
     }
     return true;
@@ -1015,9 +1096,14 @@
         kotlinInfo.asSyntheticClass().isLambda();
   }
 
-  private void markSizeForInlining(DexEncodedMethod inlinee) {
+  private void markSizeForInlining(InvokeMethod invoke, DexEncodedMethod inlinee) {
+    assert !isProcessedConcurrently.test(inlinee);
     if (!exemptFromInstructionLimit(inlinee)) {
-      estimatedCombinedSizeForInlining += inlinee.getCode().estimatedSizeForInlining();
+      if (invoke != null) {
+        directInlinees.put(invoke, inlinee);
+      } else {
+        indirectInlinees.add(inlinee);
+      }
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
index c38c0ed..702074a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
 import java.util.List;
@@ -99,6 +100,11 @@
   public boolean hasUsefulOptimizationInfo(AppView<?> appView, DexEncodedMethod encodedMethod) {
     TypeLatticeElement[] staticTypes = getStaticTypes(appView, encodedMethod);
     for (int i = 0; i < size; i++) {
+      ParameterUsage parameterUsage = encodedMethod.getOptimizationInfo().getParameterUsages(i);
+      // If the parameter is not used, passing accurate argument info doesn't matter.
+      if (parameterUsage != null && parameterUsage.notUsed()) {
+        continue;
+      }
       AbstractValue abstractValue = getAbstractArgumentValue(i);
       if (abstractValue.isNonTrivial()) {
         assert appView.options().enablePropagationOfConstantsAtCallSites;
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 e6d0589..7ecbf18 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
@@ -4,12 +4,12 @@
 
 package com.android.tools.r8.ir.optimize.info;
 
-import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.DefaultInstanceInitializerInfo;
@@ -32,7 +32,7 @@
   static boolean DOES_NOT_USE_IDENTIFIER_NAME_STRING = false;
   static boolean UNKNOWN_CHECKS_NULL_RECEIVER_BEFORE_ANY_SIDE_EFFECT = false;
   static boolean UNKNOWN_TRIGGERS_CLASS_INIT_BEFORE_ANY_SIDE_EFFECT = false;
-  static ClassInlinerEligibility UNKNOWN_CLASS_INLINER_ELIGIBILITY = null;
+  static ClassInlinerEligibilityInfo UNKNOWN_CLASS_INLINER_ELIGIBILITY = null;
   static boolean UNKNOWN_INITIALIZER_ENABLING_JAVA_ASSERTIONS = false;
   static ParameterUsagesInfo UNKNOWN_PARAMETER_USAGE_INFO = null;
   static boolean UNKNOWN_MAY_HAVE_SIDE_EFFECTS = true;
@@ -140,7 +140,7 @@
   }
 
   @Override
-  public ClassInlinerEligibility getClassInlinerEligibility() {
+  public ClassInlinerEligibilityInfo getClassInlinerEligibility() {
     return UNKNOWN_CLASS_INLINER_ELIGIBILITY;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
index 26aab1b..d9c4083 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
@@ -4,11 +4,11 @@
 
 package com.android.tools.r8.ir.optimize.info;
 
-import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
@@ -55,7 +55,7 @@
 
   boolean neverReturnsNormally();
 
-  ClassInlinerEligibility getClassInlinerEligibility();
+  ClassInlinerEligibilityInfo getClassInlinerEligibility();
 
   Set<DexType> getInitializedClassesOnNormalExit();
 
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 13844a6..ee49c97 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
@@ -10,7 +10,6 @@
 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.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -38,6 +37,8 @@
 import com.android.tools.r8.ir.code.StaticPut;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.optimize.DynamicTypeOptimization;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerReceiverAnalysis;
 import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsageBuilder;
 import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
@@ -123,7 +124,6 @@
       return;
     }
 
-    boolean receiverUsedAsReturnValue = false;
     boolean seenSuperInitCall = false;
     for (Instruction insn : receiver.aliasedUsers()) {
       if (insn.isAssume()) {
@@ -134,11 +134,6 @@
         continue;
       }
 
-      if (insn.isReturn()) {
-        receiverUsedAsReturnValue = true;
-        continue;
-      }
-
       if (insn.isInstanceGet() || insn.isInstancePut()) {
         if (insn.isInstancePut()) {
           InstancePut instancePutInstruction = insn.asInstancePut();
@@ -176,16 +171,23 @@
         return;
       }
 
+      if (insn.isReturn()) {
+        continue;
+      }
+
       // Other receiver usages make the method not eligible.
       return;
     }
+
     if (instanceInitializer && !seenSuperInitCall) {
       // Call to super constructor not found?
       return;
     }
 
     feedback.setClassInlinerEligibility(
-        method, new ClassInlinerEligibility(receiverUsedAsReturnValue));
+        method,
+        new ClassInlinerEligibilityInfo(
+            new ClassInlinerReceiverAnalysis(appView, method, code).computeReturnsReceiver()));
   }
 
   private void identifyParameterUsages(
@@ -442,7 +444,7 @@
 
       if (insn.isInstancePut()) {
         InstancePut instancePut = insn.asInstancePut();
-        DexEncodedField field = clazz.lookupInstanceField(instancePut.getField());
+        DexEncodedField field = appView.appInfo().resolveFieldOn(clazz, instancePut.getField());
         if (field == null
             || instancePut.object() != receiver
             || (instancePut.value() != receiver && !instancePut.value().isArgument())) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
index 2f9c55b..a0828e9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
@@ -7,12 +7,12 @@
 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.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.IteratorUtils;
@@ -228,7 +228,7 @@
 
   @Override
   public synchronized void setClassInlinerEligibility(
-      DexEncodedMethod method, ClassInlinerEligibility eligibility) {
+      DexEncodedMethod method, ClassInlinerEligibilityInfo eligibility) {
     getMethodOptimizationInfoForUpdating(method).setClassInlinerEligibility(eligibility);
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
index 1be0c5c..e106dc8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
@@ -7,12 +7,12 @@
 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.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.BitSet;
@@ -109,8 +109,7 @@
 
   @Override
   public void setClassInlinerEligibility(
-      DexEncodedMethod method, ClassInlinerEligibility eligibility) {
-  }
+      DexEncodedMethod method, ClassInlinerEligibilityInfo eligibility) {}
 
   @Override
   public void setInitializerInfo(DexEncodedMethod method, InitializerInfo info) {}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index 1d1dea5..0178a2d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -7,12 +7,12 @@
 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.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.BitSet;
@@ -156,7 +156,7 @@
 
   @Override
   public void setClassInlinerEligibility(
-      DexEncodedMethod method, ClassInlinerEligibility eligibility) {
+      DexEncodedMethod method, ClassInlinerEligibilityInfo eligibility) {
     // Ignored.
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java
index e41989a..ef87dcf 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java
@@ -118,8 +118,8 @@
     }
 
     public boolean notUsed() {
-      return ifZeroTest == null
-          && callsReceiver == null
+      return (ifZeroTest == null || ifZeroTest.isEmpty())
+          && (callsReceiver == null || callsReceiver.isEmpty())
           && !hasFieldAssignment
           && !hasFieldRead
           && !isAssignedToField
@@ -147,8 +147,9 @@
     // Returns false if the instruction is not supported.
     public boolean note(Instruction instruction) {
       if (instruction.isAssume()) {
-        // Keep examining other users, but the param usage builder should consider aliased users.
-        return true;
+        // Keep examining other users if there are no phi users, but the param usage builder should
+        // consider aliased users.
+        return !instruction.outValue().hasPhiUsers();
       }
       if (instruction.isIf()) {
         return note(instruction.asIf());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
index c5a12c2..74dd886 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
@@ -6,11 +6,11 @@
 
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
 import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
 import com.android.tools.r8.ir.optimize.info.initializer.DefaultInstanceInitializerInfo;
@@ -49,7 +49,7 @@
       DefaultMethodOptimizationInfo.UNKNOWN_TRIGGERS_CLASS_INIT_BEFORE_ANY_SIDE_EFFECT;
   // Stores information about instance methods and constructors for
   // class inliner, null value indicates that the method is not eligible.
-  private ClassInlinerEligibility classInlinerEligibility =
+  private ClassInlinerEligibilityInfo classInlinerEligibility =
       DefaultMethodOptimizationInfo.UNKNOWN_CLASS_INLINER_ELIGIBILITY;
   private InitializerInfo initializerInfo = null;
   private boolean initializerEnablingJavaAssertions =
@@ -235,7 +235,7 @@
   }
 
   @Override
-  public ClassInlinerEligibility getClassInlinerEligibility() {
+  public ClassInlinerEligibilityInfo getClassInlinerEligibility() {
     return classInlinerEligibility;
   }
 
@@ -300,7 +300,7 @@
     this.reachabilitySensitive = reachabilitySensitive;
   }
 
-  void setClassInlinerEligibility(ClassInlinerEligibility eligibility) {
+  void setClassInlinerEligibility(ClassInlinerEligibilityInfo eligibility) {
     this.classInlinerEligibility = eligibility;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/inliner/InliningIRProvider.java b/src/main/java/com/android/tools/r8/ir/optimize/inliner/InliningIRProvider.java
index 580e1b2..b1408dd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/inliner/InliningIRProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/inliner/InliningIRProvider.java
@@ -38,6 +38,12 @@
     return method.buildInliningIR(context, appView, valueNumberGenerator, position, origin);
   }
 
+  public IRCode getAndCacheInliningIR(InvokeMethod invoke, DexEncodedMethod method) {
+    IRCode inliningIR = getInliningIR(invoke, method);
+    cacheInliningIR(invoke, inliningIR);
+    return inliningIR;
+  }
+
   public void cacheInliningIR(InvokeMethod invoke, IRCode code) {
     IRCode existing = cache.put(invoke, code);
     assert existing == null;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
index 5c3e91c..ae5e066 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
@@ -80,10 +80,6 @@
     }
   }
 
-  public final boolean allLambdas(Predicate<LambdaInfo> predicate) {
-    return !anyLambda(lambda -> !predicate.test(lambda));
-  }
-
   public final boolean anyLambda(Predicate<LambdaInfo> predicate) {
     assert verifyLambdaIds(false);
     for (LambdaInfo info : lambdas.values()) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
index a165998..3bb09ce 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
@@ -15,18 +15,23 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
 import com.android.tools.r8.ir.analysis.type.DestructivePhiTypeUpdater;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InstanceGet;
 import com.android.tools.r8.ir.code.InstancePut;
+import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.NewInstance;
 import com.android.tools.r8.ir.code.Phi;
 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.IRConverter;
+import com.android.tools.r8.ir.optimize.Inliner;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.Inliner.InliningInfo;
 import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
@@ -40,6 +45,8 @@
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
 import com.google.common.collect.Sets;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
@@ -84,7 +91,8 @@
 
   private abstract static class Mode {
 
-    void rewriteCode(DexEncodedMethod method, IRCode code, DexEncodedMethod context) {}
+    void rewriteCode(
+        DexEncodedMethod method, IRCode code, Inliner inliner, DexEncodedMethod context) {}
 
     void analyzeCode(DexEncodedMethod method, IRCode code) {}
   }
@@ -99,22 +107,50 @@
 
   private class ApplyMode extends Mode {
 
-    private final Set<DexType> lambdaGroupsClasses;
+    private final Map<DexProgramClass, LambdaGroup> lambdaGroups;
     private final LambdaMergerOptimizationInfoFixer optimizationInfoFixer;
 
     ApplyMode(
-        Set<DexType> lambdaGroupTypes, LambdaMergerOptimizationInfoFixer optimizationInfoFixer) {
-      this.lambdaGroupsClasses = lambdaGroupTypes;
+        Map<DexProgramClass, LambdaGroup> lambdaGroups,
+        LambdaMergerOptimizationInfoFixer optimizationInfoFixer) {
+      this.lambdaGroups = lambdaGroups;
       this.optimizationInfoFixer = optimizationInfoFixer;
     }
 
     @Override
-    void rewriteCode(DexEncodedMethod method, IRCode code, DexEncodedMethod context) {
-      if (lambdaGroupsClasses.contains(method.method.holder)) {
-        // Don't rewrite the methods that we have synthesized for the lambda group classes.
+    void rewriteCode(
+        DexEncodedMethod method, IRCode code, Inliner inliner, DexEncodedMethod context) {
+      DexProgramClass clazz = appView.definitionFor(method.method.holder).asProgramClass();
+      assert clazz != null;
+
+      LambdaGroup lambdaGroup = lambdaGroups.get(clazz);
+      if (lambdaGroup == null) {
+        // Only rewrite the methods that have not been synthesized for the lambda group classes.
+        new ApplyStrategy(method, code, context, optimizationInfoFixer).processCode();
         return;
       }
-      new ApplyStrategy(method, code, context, optimizationInfoFixer).processCode();
+
+      if (method.isInitializer()) {
+        // Should not require rewriting.
+        return;
+      }
+
+      assert method.isVirtualMethod();
+      assert context == null;
+
+      Map<InvokeVirtual, InliningInfo> invokesToInline = new IdentityHashMap<>();
+      for (InvokeVirtual invoke : code.<InvokeVirtual>instructions(Instruction::isInvokeVirtual)) {
+        DexType holder = invoke.getInvokedMethod().holder;
+        if (lambdaGroup.containsLambda(holder)) {
+          DexEncodedMethod singleTarget = invoke.lookupSingleTarget(appView, method.method.holder);
+          assert singleTarget != null;
+          invokesToInline.put(invoke, new InliningInfo(singleTarget, singleTarget.method.holder));
+        }
+      }
+
+      assert invokesToInline.size() > 1;
+
+      inliner.performForcedInlining(method, code, invokesToInline);
     }
   }
 
@@ -143,7 +179,6 @@
   private final Set<DexEncodedMethod> methodsToReprocess = Sets.newIdentityHashSet();
 
   private final AppView<AppInfoWithLiveness> appView;
-  private final DexItemFactory factory;
   private final Kotlin kotlin;
   private final DiagnosticsHandler reporter;
 
@@ -155,17 +190,20 @@
   private final LambdaTypeVisitor lambdaChecker;
 
   public LambdaMerger(AppView<AppInfoWithLiveness> appView) {
+    DexItemFactory factory = appView.dexItemFactory();
     this.appView = appView;
-    this.factory = appView.dexItemFactory();
     this.kotlin = factory.kotlin;
     this.reporter = appView.options().reporter;
 
-    this.lambdaInvalidator = new LambdaTypeVisitor(factory, this::isMergeableLambda,
-        this::invalidateLambda);
-    this.lambdaChecker = new LambdaTypeVisitor(factory, this::isMergeableLambda,
-        type -> {
-          throw new Unreachable("Unexpected lambda " + type.toSourceString());
-        });
+    this.lambdaInvalidator =
+        new LambdaTypeVisitor(factory, this::isMergeableLambda, this::invalidateLambda);
+    this.lambdaChecker =
+        new LambdaTypeVisitor(
+            factory,
+            this::isMergeableLambda,
+            type -> {
+              throw new Unreachable("Unexpected lambda " + type.toSourceString());
+            });
   }
 
   private void invalidateLambda(DexType lambda) {
@@ -251,20 +289,20 @@
    *       no more invalid lambda class references.
    * </ol>
    */
-  public final void rewriteCode(DexEncodedMethod method, IRCode code) {
+  public final void rewriteCode(DexEncodedMethod method, IRCode code, Inliner inliner) {
     if (mode != null) {
-      mode.rewriteCode(method, code, null);
+      mode.rewriteCode(method, code, inliner, null);
     }
   }
 
   /**
-   * Similar to {@link #rewriteCode(DexEncodedMethod, IRCode)}, but for rewriting code for inlining.
-   * The {@param context} is the caller that {@param method} is being inlined into.
+   * Similar to {@link #rewriteCode(DexEncodedMethod, IRCode, Inliner)}, but for rewriting code for
+   * inlining. The {@param context} is the caller that {@param method} is being inlined into.
    */
   public final void rewriteCodeForInlining(
       DexEncodedMethod method, IRCode code, DexEncodedMethod context) {
     if (mode != null) {
-      mode.rewriteCode(method, code, context);
+      mode.rewriteCode(method, code, null, context);
     }
   }
 
@@ -288,12 +326,7 @@
 
     // Remove invalidated lambdas, compact groups to ensure
     // sequential lambda ids, create group lambda classes.
-    Map<LambdaGroup, DexProgramClass> lambdaGroupsClasses = finalizeLambdaGroups();
-
-    // Mark all the implementation methods for force inlining.
-    for (LambdaGroup group : lambdaGroupsClasses.keySet()) {
-      group.forEachLambda(info -> info.clazz.virtualMethods().forEach(feedback::markForceInline));
-    }
+    BiMap<LambdaGroup, DexProgramClass> lambdaGroupsClasses = finalizeLambdaGroups();
 
     // Fixup optimization info to ensure that the optimization info does not refer to any merged
     // lambdas.
@@ -302,9 +335,7 @@
     feedback.fixupOptimizationInfos(appView, executorService, optimizationInfoFixer);
 
     // Switch to APPLY strategy.
-    Set<DexType> lambdaGroupTypes =
-        lambdaGroupsClasses.values().stream().map(clazz -> clazz.type).collect(Collectors.toSet());
-    this.mode = new ApplyMode(lambdaGroupTypes, optimizationInfoFixer);
+    this.mode = new ApplyMode(lambdaGroupsClasses.inverse(), optimizationInfoFixer);
 
     // Add synthesized lambda group classes to the builder.
     for (Entry<LambdaGroup, DexProgramClass> entry : lambdaGroupsClasses.entrySet()) {
@@ -323,23 +354,15 @@
           encodedMethod -> encodedMethod.markProcessed(ConstraintWithTarget.NEVER));
     }
 
-    // Verify that all implementation methods are marked for force inlining (i.e., check that the
-    // delayed optimization feedback has been flushed).
-    assert lambdaGroupsClasses.keySet().stream()
-        .allMatch(
-            group ->
-                group.allLambdas(
-                    lambda ->
-                        lambda.clazz.virtualMethods().stream()
-                            .map(DexEncodedMethod::getOptimizationInfo)
-                            .allMatch(MethodOptimizationInfo::forceInline)));
-
     converter.optimizeSynthesizedClasses(lambdaGroupsClasses.values(), executorService);
 
     // Rewrite lambda class references into lambda group class
     // references inside methods from the processing queue.
     rewriteLambdaReferences(converter, executorService, feedback);
     this.mode = null;
+
+    appView.setHorizontallyMergedLambdaClasses(
+        new HorizontallyMergedLambdaClasses(lambdas.keySet()));
   }
 
   private void analyzeLambdaClassesStructure(ExecutorService service) throws ExecutionException {
@@ -365,7 +388,7 @@
     ThreadUtils.awaitFutures(futures);
   }
 
-  private Map<LambdaGroup, DexProgramClass> finalizeLambdaGroups() {
+  private BiMap<LambdaGroup, DexProgramClass> finalizeLambdaGroups() {
     for (DexType lambda : invalidatedLambdas) {
       LambdaGroup group = lambdas.get(lambda);
       assert group != null;
@@ -378,7 +401,7 @@
     removeTrivialLambdaGroups();
 
     // Compact lambda groups, synthesize lambda group classes.
-    Map<LambdaGroup, DexProgramClass> result = new LinkedHashMap<>();
+    BiMap<LambdaGroup, DexProgramClass> result = HashBiMap.create();
     for (LambdaGroup group : groups.values()) {
       assert !group.isTrivial() : "No trivial group is expected here.";
       group.compact();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
index b9ef1c9..a467cb2 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
@@ -35,6 +35,7 @@
 import com.android.tools.r8.utils.ThreadUtils;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
 import java.util.ArrayList;
@@ -57,7 +58,8 @@
   private final ClassStaticizer classStaticizer;
   private final IRConverter converter;
 
-  private final Map<DexEncodedMethod, Collection<Consumer<IRCode>>> processingQueue =
+  // Optimization order matters, hence a collection that preserves orderings.
+  private final Map<DexEncodedMethod, ImmutableList.Builder<Consumer<IRCode>>> processingQueue =
       new IdentityHashMap<>();
 
   private final Set<DexEncodedMethod> referencingExtraMethods = Sets.newIdentityHashSet();
@@ -75,7 +77,7 @@
     this.converter = converter;
   }
 
-  final void run(OptimizationFeedback optimizationFeedback, ExecutorService executorService)
+  final void run(OptimizationFeedback feedback, ExecutorService executorService)
       throws ExecutionException {
     // Filter out candidates based on the information we collected while examining methods.
     finalEligibilityCheck();
@@ -84,15 +86,20 @@
     prepareCandidates();
 
     // Enqueue all host class initializers (only remove instantiations).
-    enqueueMethodsWithCodeOptimization(
-        hostClassInits.keySet(), this::removeCandidateInstantiation);
+    enqueueMethodsWithCodeOptimizations(
+        hostClassInits.keySet(),
+        optimizations ->
+            optimizations
+                .add(this::removeCandidateInstantiation)
+                .add(this::insertAssumeInstructions)
+                .add(collectOptimizationInfo(feedback)));
 
     // Enqueue instance methods to be staticized (only remove references to 'this').
-    enqueueMethodsWithCodeOptimization(
-        methodsToBeStaticized, this::removeReferencesToThis);
+    enqueueMethodsWithCodeOptimizations(
+        methodsToBeStaticized, optimizations -> optimizations.add(this::removeReferencesToThis));
 
     // Process queued methods with associated optimizations
-    processMethodsConcurrently(optimizationFeedback, executorService);
+    processMethodsConcurrently(feedback, executorService);
 
     // TODO(b/140767158): Merge the remaining part below.
     // Convert instance methods into static methods with an extra parameter.
@@ -103,10 +110,16 @@
     // a result of staticizing.)
     methods.addAll(referencingExtraMethods);
     methods.addAll(hostClassInits.keySet());
-    enqueueMethodsWithCodeOptimization(methods, this::rewriteReferences);
+    enqueueMethodsWithCodeOptimizations(
+        methods,
+        optimizations ->
+            optimizations
+                .add(this::rewriteReferences)
+                .add(this::insertAssumeInstructions)
+                .add(collectOptimizationInfo(feedback)));
 
     // Process queued methods with associated optimizations
-    processMethodsConcurrently(optimizationFeedback, executorService);
+    processMethodsConcurrently(feedback, executorService);
   }
 
   private void finalEligibilityCheck() {
@@ -249,15 +262,11 @@
     referencingExtraMethods.removeAll(removedInstanceMethods);
   }
 
-  private void enqueueMethodsWithCodeOptimization(
-      Iterable<DexEncodedMethod> methods, Consumer<IRCode> optimization) {
+  private void enqueueMethodsWithCodeOptimizations(
+      Iterable<DexEncodedMethod> methods,
+      Consumer<ImmutableList.Builder<Consumer<IRCode>>> extension) {
     for (DexEncodedMethod method : methods) {
-      processingQueue
-          .computeIfAbsent(
-              method,
-              // Optimization order might matter, hence a collection that preserves orderings.
-              k -> new ArrayList<>())
-          .add(optimization);
+      extension.accept(processingQueue.computeIfAbsent(method, ignore -> ImmutableList.builder()));
     }
   }
 
@@ -275,7 +284,7 @@
       OptimizationFeedback feedback, ExecutorService executorService) throws ExecutionException {
     ThreadUtils.processItems(
         processingQueue.keySet(),
-        method -> forEachMethod(method, processingQueue.get(method), feedback),
+        method -> forEachMethod(method, processingQueue.get(method).build(), feedback),
         executorService);
     // TODO(b/140767158): No need to clear if we can do every thing in one go.
     processingQueue.clear();
@@ -289,12 +298,18 @@
     Origin origin = appView.appInfo().originFor(method.method.holder);
     IRCode code = method.buildIR(appView, origin);
     codeOptimizations.forEach(codeOptimization -> codeOptimization.accept(code));
-    CodeRewriter.insertAssumeInstructions(code, converter.assumers);
-    converter.collectOptimizationInfo(code, feedback);
     CodeRewriter.removeAssumeInstructions(appView, code);
     converter.finalizeIR(method, code, feedback);
   }
 
+  private void insertAssumeInstructions(IRCode code) {
+    CodeRewriter.insertAssumeInstructions(code, converter.assumers);
+  }
+
+  private Consumer<IRCode> collectOptimizationInfo(OptimizationFeedback feedback) {
+    return code -> converter.collectOptimizationInfo(code, feedback);
+  }
+
   private void removeCandidateInstantiation(IRCode code) {
     CandidateInfo candidateInfo = hostClassInits.get(code.method);
     assert candidateInfo != null;
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java
index a83c407..acb6c55 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java
@@ -11,7 +11,9 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.DescriptorUtils;
+import java.util.ListIterator;
 import kotlinx.metadata.KmClass;
+import kotlinx.metadata.KmType;
 import kotlinx.metadata.KmTypeVisitor;
 import kotlinx.metadata.jvm.KotlinClassHeader;
 import kotlinx.metadata.jvm.KotlinClassMetadata;
@@ -40,23 +42,36 @@
 
   @Override
   void rewrite(AppView<AppInfoWithLiveness> appView, NamingLens lens) {
-    kmClass.getSupertypes().removeIf(
-        kmType -> {
-          Box<Boolean> isLive = new Box<>(false);
-          kmType.accept(new KmTypeVisitor() {
-            @Override
-            public void visitClass(String name) {
-              String descriptor = DescriptorUtils.javaTypeToDescriptorIfValidJavaType(name);
-              if (descriptor != null) {
-                DexType type = appView.dexItemFactory().createType(name);
-                DexType renamedType = lens.lookupType(type, appView.dexItemFactory());
-                isLive.set(appView.appInfo().isLiveProgramType(renamedType));
-              }
-            }
-          });
-          return !isLive.get();
+    ListIterator<KmType> superTypeIterator = kmClass.getSupertypes().listIterator();
+    while (superTypeIterator.hasNext()) {
+      KmType kmType = superTypeIterator.next();
+      Box<Boolean> isLive = new Box<>(false);
+      Box<DexType> renamed = new Box<>(null);
+      kmType.accept(new KmTypeVisitor() {
+        @Override
+        public void visitClass(String name) {
+          String descriptor = DescriptorUtils.getDescriptorFromKotlinClassifier(name);
+          DexType type = appView.dexItemFactory().createType(descriptor);
+          isLive.set(appView.appInfo().isLiveProgramType(type));
+          DexType renamedType = lens.lookupType(type, appView.dexItemFactory());
+          if (renamedType != type) {
+            renamed.set(renamedType);
+          }
         }
-    );
+      });
+      if (!isLive.get()) {
+        superTypeIterator.remove();
+        continue;
+      }
+      if (renamed.get() != null) {
+        // TODO(b/70169921): need a general util to convert the current clazz's access flag.
+        KmType renamedKmType = new KmType(kmType.getFlags());
+        renamedKmType.visitClass(
+            DescriptorUtils.descriptorToInternalName(renamed.get().toDescriptorString()));
+        superTypeIterator.remove();
+        superTypeIterator.add(renamedKmType);
+      }
+    }
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
index 5ccf3e8..226a5f9 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
@@ -9,6 +9,7 @@
 import com.android.tools.r8.naming.MemberNaming.Signature.SignatureKind;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
@@ -30,9 +31,10 @@
   public static class Builder extends ClassNaming.Builder {
     private final String originalName;
     private final String renamedName;
-    private final Map<MethodSignature, MemberNaming> methodMembers = new HashMap<>();
-    private final Map<FieldSignature, MemberNaming> fieldMembers = new HashMap<>();
-    private final Map<String, List<MappedRange>> mappedRangesByName = new HashMap<>();
+    private final Map<MethodSignature, MemberNaming> methodMembers = Maps.newHashMap();
+    private final Map<FieldSignature, MemberNaming> fieldMembers = Maps.newHashMap();
+    private final Map<String, List<MappedRange>> mappedRangesByName = Maps.newHashMap();
+    private final Map<String, List<MemberNaming>> mappedNamingsByName = Maps.newHashMap();
 
     private Builder(String renamedName, String originalName) {
       this.originalName = originalName;
@@ -46,6 +48,9 @@
       } else {
         fieldMembers.put((FieldSignature) entry.getRenamedSignature(), entry);
       }
+      mappedNamingsByName
+          .computeIfAbsent(entry.getRenamedName(), m -> new ArrayList<>())
+          .add(entry);
       return this;
     }
 
@@ -63,7 +68,7 @@
       }
 
       return new ClassNamingForNameMapper(
-          renamedName, originalName, methodMembers, fieldMembers, map);
+          renamedName, originalName, methodMembers, fieldMembers, map, mappedNamingsByName);
     }
 
     /** The parameters are forwarded to MappedRange constructor, see explanation there. */
@@ -192,17 +197,21 @@
   /** Map of renamed name -> MappedRangesOfName */
   public final Map<String, MappedRangesOfName> mappedRangesByRenamedName;
 
+  public final Map<String, List<MemberNaming>> mappedNamingsByName;
+
   private ClassNamingForNameMapper(
       String renamedName,
       String originalName,
       Map<MethodSignature, MemberNaming> methodMembers,
       Map<FieldSignature, MemberNaming> fieldMembers,
-      Map<String, MappedRangesOfName> mappedRangesByRenamedName) {
+      Map<String, MappedRangesOfName> mappedRangesByRenamedName,
+      Map<String, List<MemberNaming>> mappedNamingsByName) {
     this.renamedName = renamedName;
     this.originalName = originalName;
     this.methodMembers = ImmutableMap.copyOf(methodMembers);
     this.fieldMembers = ImmutableMap.copyOf(fieldMembers);
     this.mappedRangesByRenamedName = mappedRangesByRenamedName;
+    this.mappedNamingsByName = mappedNamingsByName;
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 18f8459..054917e 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -87,6 +87,10 @@
     return signature.kind() == SignatureKind.METHOD;
   }
 
+  public boolean isFieldNaming() {
+    return signature.kind() == SignatureKind.FIELD;
+  }
+
   public Position getPosition() {
     return position;
   }
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java
index 011a7ba..0cee87f 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java
@@ -91,7 +91,7 @@
     if (minApiLevel != null) {
       builder.append("# " + MARKER_KEY_MIN_API + ": " + minApiLevel + "\n");
     }
-    if (Version.isDev()) {
+    if (Version.isDevelopmentVersion()) {
       builder.append(
           "# " + MARKER_KEY_COMPILER_HASH + ": " + VersionProperties.INSTANCE.getSha() + "\n");
     }
diff --git a/src/main/java/com/android/tools/r8/references/ArrayReference.java b/src/main/java/com/android/tools/r8/references/ArrayReference.java
index 96cb926..f95a60c 100644
--- a/src/main/java/com/android/tools/r8/references/ArrayReference.java
+++ b/src/main/java/com/android/tools/r8/references/ArrayReference.java
@@ -5,6 +5,7 @@
 
 import com.android.tools.r8.Keep;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.utils.DescriptorUtils;
 
 /** Reference to an array type. */
 @Keep
@@ -34,6 +35,13 @@
     throw new Unreachable("Invalid array type descriptor: " + descriptor);
   }
 
+  static ArrayReference fromBaseType(TypeReference baseType, int dimensions) {
+    return new ArrayReference(
+        dimensions,
+        baseType,
+        DescriptorUtils.toArrayDescriptor(dimensions, baseType.getDescriptor()));
+  }
+
   public int getDimensions() {
     return dimensions;
   }
diff --git a/src/main/java/com/android/tools/r8/references/ClassReference.java b/src/main/java/com/android/tools/r8/references/ClassReference.java
index 1159ec3..9c0f479 100644
--- a/src/main/java/com/android/tools/r8/references/ClassReference.java
+++ b/src/main/java/com/android/tools/r8/references/ClassReference.java
@@ -30,6 +30,11 @@
   }
 
   @Override
+  public ClassReference asClass() {
+    return this;
+  }
+
+  @Override
   public String getDescriptor() {
     return descriptor;
   }
diff --git a/src/main/java/com/android/tools/r8/references/PrimitiveReference.java b/src/main/java/com/android/tools/r8/references/PrimitiveReference.java
index 66c1ae7..eb4ae72 100644
--- a/src/main/java/com/android/tools/r8/references/PrimitiveReference.java
+++ b/src/main/java/com/android/tools/r8/references/PrimitiveReference.java
@@ -105,6 +105,11 @@
   }
 
   @Override
+  public PrimitiveReference asPrimitive() {
+    return this;
+  }
+
+  @Override
   public abstract String getDescriptor();
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/references/Reference.java b/src/main/java/com/android/tools/r8/references/Reference.java
index 8a3d278..94d4ea0 100644
--- a/src/main/java/com/android/tools/r8/references/Reference.java
+++ b/src/main/java/com/android/tools/r8/references/Reference.java
@@ -118,6 +118,16 @@
     return getInstance().arrays.computeIfAbsent(descriptor, ArrayReference::fromDescriptor);
   }
 
+  /** Get an array reference from a base type and dimensions. */
+  public static ArrayReference array(TypeReference baseType, int dimensions) {
+    String arrayDescriptor =
+        DescriptorUtils.toArrayDescriptor(dimensions, baseType.getDescriptor());
+    return getInstance()
+        .arrays
+        .computeIfAbsent(
+            arrayDescriptor, descriptor -> ArrayReference.fromBaseType(baseType, dimensions));
+  }
+
   /** Get a method reference from its full reference specification. */
   public static MethodReference method(
       ClassReference holderClass,
diff --git a/src/main/java/com/android/tools/r8/references/TypeReference.java b/src/main/java/com/android/tools/r8/references/TypeReference.java
index 44fb54a..bfef3f6 100644
--- a/src/main/java/com/android/tools/r8/references/TypeReference.java
+++ b/src/main/java/com/android/tools/r8/references/TypeReference.java
@@ -31,6 +31,33 @@
     return false;
   }
 
+  /**
+   * Return a non-null ClassTypeReference if this type is ClassTypeReference
+   *
+   * @return this with static type of ClassTypeReference
+   */
+  default ClassReference asClass() {
+    return null;
+  }
+
+  /**
+   * Return a non-null ArrayReference if this type is ArrayReference
+   *
+   * @return this with static type of ArrayReference
+   */
+  default ArrayReference asArray() {
+    return null;
+  }
+
+  /**
+   * Return a non-null PrimitiveReference if this type is PrimitiveReference
+   *
+   * @return this with static type of PrimitiveReference
+   */
+  default PrimitiveReference asPrimitive() {
+    return null;
+  }
+
   default String getTypeName() {
     return DescriptorUtils.descriptorToJavaType(getDescriptor());
   }
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 f5b0de8..d004c90 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -567,7 +567,7 @@
 
   public boolean isLiveProgramType(DexType type) {
     DexClass clazz = definitionFor(type);
-    return clazz.isProgramClass() && isLiveProgramClass(clazz.asProgramClass());
+    return clazz != null && clazz.isProgramClass() && isLiveProgramClass(clazz.asProgramClass());
   }
 
   public boolean isNonProgramTypeOrLiveProgramType(DexType type) {
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index 0652a33..cee2d66 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -395,7 +395,7 @@
       } else {
         String unknownOption = acceptString();
         String devMessage = "";
-        if (Version.isDev()
+        if (Version.isDevelopmentVersion()
             && unknownOption != null
             && (unknownOption.equals("forceinline") || unknownOption.equals("neverinline"))) {
           devMessage = ", this option needs to be turned on explicitly if used for tests.";
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index af0efe5..e7a7fe5 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -289,7 +289,8 @@
         // Final classes cannot be abstract, so we have to keep the method in that case.
         // Also some other kinds of methods cannot be abstract, so keep them around.
         boolean allowAbstract =
-            clazz.accessFlags.isAbstract()
+            (!options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
+                    || clazz.accessFlags.isAbstract())
                 && !method.accessFlags.isFinal()
                 && !method.accessFlags.isNative()
                 && !method.accessFlags.isStrict()
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index f07499b..9f4b3e3 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -33,6 +33,7 @@
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.graph.TopDownClassHierarchyTraversal;
 import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.MemberPoolCollection.MemberPool;
@@ -47,10 +48,8 @@
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence;
 import com.google.common.base.Equivalence.Wrapper;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
@@ -88,44 +87,6 @@
  */
 public class VerticalClassMerger {
 
-  public static class VerticallyMergedClasses {
-
-    private final Map<DexType, DexType> mergedClasses;
-    private final Map<DexType, List<DexType>> sources;
-
-    private VerticallyMergedClasses(Map<DexType, DexType> mergedClasses) {
-      Map<DexType, List<DexType>> sources = Maps.newIdentityHashMap();
-      mergedClasses.forEach(
-          (source, target) ->
-              sources.computeIfAbsent(target, key -> new ArrayList<>()).add(source));
-      this.mergedClasses = mergedClasses;
-      this.sources = sources;
-    }
-
-    public List<DexType> getSourcesFor(DexType type) {
-      return sources.getOrDefault(type, ImmutableList.of());
-    }
-
-    public DexType getTargetFor(DexType type) {
-      assert mergedClasses.containsKey(type);
-      return mergedClasses.get(type);
-    }
-
-    public boolean hasBeenMergedIntoSubtype(DexType type) {
-      return mergedClasses.containsKey(type);
-    }
-
-    public boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView) {
-      for (List<DexType> sourcesForTarget : sources.values()) {
-        for (DexType source : sourcesForTarget) {
-          assert appView.appInfo().wasPruned(source)
-              : "Expected vertically merged class `" + source.toSourceString() + "` to be absent";
-        }
-      }
-      return true;
-    }
-  }
-
   private enum AbortReason {
     ALREADY_MERGED,
     ALWAYS_INLINE,
diff --git a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
index 09fa0fe..c3916cb 100644
--- a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
@@ -96,6 +96,23 @@
   }
 
   /**
+   * Produces an array descriptor having the number of dimensions specified and the
+   * baseTypeDescriptor as base.
+   *
+   * @param dimensions number of dimensions
+   * @param baseTypeDescriptor the base type
+   * @return the descriptor string
+   */
+  public static String toArrayDescriptor(int dimensions, String baseTypeDescriptor) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < dimensions; i++) {
+      sb.append('[');
+    }
+    sb.append(baseTypeDescriptor);
+    return sb.toString();
+  }
+
+  /**
    * Determine the given {@param typeName} is a valid jvms binary name or not (jvms 4.2.1).
    *
    * @param typeName the jvms binary name
@@ -177,13 +194,40 @@
             classNameMapper == null ? clazz : classNameMapper.deobfuscateClassName(clazz);
         return originalName;
       case '[':
-        return descriptorToJavaType(descriptor.substring(1, descriptor.length()), classNameMapper)
-            + "[]";
+        return descriptorToJavaType(descriptor.substring(1), classNameMapper) + "[]";
       default:
         return primitiveDescriptorToJavaType(c);
     }
   }
 
+  public static boolean isPrimitiveDescriptor(String descriptor) {
+    if (descriptor.length() != 1) {
+      return false;
+    }
+    return isPrimitiveType(descriptor.charAt(0));
+  }
+
+  public static boolean isPrimitiveType(char c) {
+    return c == 'Z' || c == 'B' || c == 'S' || c == 'C' || c == 'I' || c == 'F' || c == 'J'
+        || c == 'D';
+  }
+
+  public static boolean isArrayDescriptor(String descriptor) {
+    if (descriptor.length() < 2) {
+      return false;
+    }
+    if (descriptor.charAt(0) == '[') {
+      return isDescriptor(descriptor.substring(1));
+    }
+    return false;
+  }
+
+  public static boolean isDescriptor(String descriptor) {
+    return isClassDescriptor(descriptor)
+        || isPrimitiveDescriptor(descriptor)
+        || isArrayDescriptor(descriptor);
+  }
+
   public static String primitiveDescriptorToJavaType(char primitive) {
     switch (primitive) {
       case 'V':
@@ -300,6 +344,17 @@
   }
 
   /**
+   * Convert a fully qualified name of a classifier in Kotlin metadata to a descriptor.
+   * @param className "org/foo/bar/Baz.Nested"
+   * @return a class descriptor like "Lorg/foo/bar/Baz$Nested;"
+   */
+  public static String getDescriptorFromKotlinClassifier(String className) {
+    assert className != null;
+    assert !className.contains("[") : className;
+    return 'L' + className.replace(JAVA_PACKAGE_SEPARATOR, INNER_CLASS_SEPARATOR) + ';';
+  }
+
+  /**
    * Get unqualified class name from its binary name.
    *
    * @param classBinaryName a class binary name i.e. "java/lang/Object" or "a/b/C$Inner"
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 3a0b969..dc998e2 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -202,7 +202,8 @@
   public boolean enableDevirtualization = true;
   public boolean enableNonNullTracking = true;
   public boolean enableInlining =
-      !Version.isDev() || System.getProperty("com.android.tools.r8.disableinlining") == null;
+      !Version.isDevelopmentVersion()
+          || System.getProperty("com.android.tools.r8.disableinlining") == null;
   // TODO(b/141451716): Evaluate the effect of allowing inlining in the inlinee.
   public boolean applyInliningToInlinee = false;
   public int applyInliningToInlineeMaxDepth = 0;
@@ -293,7 +294,7 @@
     if (!isGeneratingClassFiles()) {
       marker.setMinApi(minApiLevel);
     }
-    if (Version.isDev()) {
+    if (Version.isDevelopmentVersion()) {
       marker.setSha1(VersionProperties.INSTANCE.getSha());
     }
     return marker;
@@ -985,9 +986,11 @@
     public boolean addCallEdgesForLibraryInvokes = false;
 
     public boolean allowTypeErrors =
-        !Version.isDev() || System.getProperty("com.android.tools.r8.allowTypeErrors") != null;
+        !Version.isDevelopmentVersion()
+            || System.getProperty("com.android.tools.r8.allowTypeErrors") != null;
     public boolean allowInvokeErrors = false;
     public boolean disableL8AnnotationRemoval = false;
+    public boolean allowClassInlinerGracefulExit = true;
     public boolean allowUnusedProguardConfigurationRules = true;
     public boolean reportUnusedProguardConfigurationRules = false;
     public boolean alwaysUsePessimisticRegisterAllocation = false;
diff --git a/src/main/java/com/android/tools/r8/utils/OptionalBool.java b/src/main/java/com/android/tools/r8/utils/OptionalBool.java
index 54029d5..abb048d 100644
--- a/src/main/java/com/android/tools/r8/utils/OptionalBool.java
+++ b/src/main/java/com/android/tools/r8/utils/OptionalBool.java
@@ -62,4 +62,18 @@
   public OptionalBool asOptionalBool() {
     return this;
   }
+
+  @Override
+  public boolean equals(Object other) {
+    return this == other;
+  }
+
+  @Override
+  public int hashCode() {
+    return System.identityHashCode(this);
+  }
+
+  // Force all subtypes to implement toString().
+  @Override
+  public abstract String toString();
 }
diff --git a/src/main/java/com/android/tools/r8/utils/StringUtils.java b/src/main/java/com/android/tools/r8/utils/StringUtils.java
index 44a26be..265d333 100644
--- a/src/main/java/com/android/tools/r8/utils/StringUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/StringUtils.java
@@ -309,4 +309,13 @@
     }
     return true;
   }
+
+  public static char lastChar(String s) {
+    return charFromEnd(s, 0);
+  }
+
+  public static char charFromEnd(String s, int charsFromEnd) {
+    assert s.length() > charsFromEnd;
+    return s.charAt(s.length() - (charsFromEnd + 1));
+  }
 }
diff --git a/src/main/keep.txt b/src/main/keep.txt
index 2748f63..d33b879 100644
--- a/src/main/keep.txt
+++ b/src/main/keep.txt
@@ -12,7 +12,13 @@
 -keep public class com.android.tools.r8.compatdx.CompatDx { public static void main(java.lang.String[]); }
 -keep public class com.android.tools.r8.dexfilemerger.DexFileMerger { public static void main(java.lang.String[]); }
 -keep public class com.android.tools.r8.dexsplitter.DexSplitter { public static void main(java.lang.String[]); }
+
 -keep public class com.android.tools.r8.Version { public static java.lang.String getVersionString(); }
+-keep public class com.android.tools.r8.Version { public static int getMajorVersion(); }
+-keep public class com.android.tools.r8.Version { public static int getMinorVersion(); }
+-keep public class com.android.tools.r8.Version { public static int getPatchVersion(); }
+-keep public class com.android.tools.r8.Version { public static java.lang.String getPreReleaseString(); }
+-keep public class com.android.tools.r8.Version { public static boolean isDevelopmentVersion(); }
 
 -keepattributes LineNumberTable, InnerClasses, EnclosingMethod, Exceptions, Signature
 
diff --git a/src/test/apiUsageSample/com/android/tools/apiusagesample/R8ApiUsageSample.java b/src/test/apiUsageSample/com/android/tools/apiusagesample/R8ApiUsageSample.java
index 4c14226..7203f39 100644
--- a/src/test/apiUsageSample/com/android/tools/apiusagesample/R8ApiUsageSample.java
+++ b/src/test/apiUsageSample/com/android/tools/apiusagesample/R8ApiUsageSample.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.ResourceException;
 import com.android.tools.r8.StringConsumer;
+import com.android.tools.r8.Version;
 import com.android.tools.r8.origin.ArchiveEntryOrigin;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
@@ -59,6 +60,8 @@
    * </pre>
    */
   public static void main(String[] args) {
+    // Check version API
+    checkVersionApi();
     // Parse arguments with the commandline parser to make use of its API.
     R8Command.Builder cmd = R8Command.parse(args, origin);
     CompilationMode mode = cmd.getMode();
@@ -507,4 +510,25 @@
       }
     }
   }
+
+  private static void checkVersionApi() {
+    if (Version.getVersionString() == null) {
+      throw new RuntimeException("Expected getVersionString API");
+    }
+    if (Version.getMajorVersion() < -1) {
+      throw new RuntimeException("Expected getMajorVersion API");
+    }
+    if (Version.getMinorVersion() < -1) {
+      throw new RuntimeException("Expected getMinorVersion API");
+    }
+    if (Version.getPatchVersion() < -1) {
+      throw new RuntimeException("Expected getPatchVersion API");
+    }
+    if (Version.getPreReleaseString() == null && false) {
+      throw new RuntimeException("Expected getPreReleaseString API");
+    }
+    if (Version.isDevelopmentVersion() && false) {
+      throw new RuntimeException("Expected isDevelopmentVersion API");
+    }
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index db0c7b2..a483cfa 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -191,6 +191,10 @@
     return self();
   }
 
+  public T allowClassInlinerGracefulExit() {
+    return addOptionsModification(options -> options.testing.allowClassInlinerGracefulExit = true);
+  }
+
   public T allowUnusedProguardConfigurationRules() {
     return addOptionsModification(
         options -> options.testing.allowUnusedProguardConfigurationRules = true);
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index b90b40c..023e0e7 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -19,13 +19,33 @@
 import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppServices;
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
 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.SmaliWriter;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.EnqueuerFactory;
+import com.android.tools.r8.shaking.ProguardClassFilter;
+import com.android.tools.r8.shaking.ProguardClassNameList;
+import com.android.tools.r8.shaking.ProguardConfigurationRule;
+import com.android.tools.r8.shaking.ProguardKeepRule;
+import com.android.tools.r8.shaking.ProguardKeepRule.Builder;
+import com.android.tools.r8.shaking.ProguardKeepRuleType;
+import com.android.tools.r8.shaking.ProguardTypeMatcher;
+import com.android.tools.r8.shaking.RootSetBuilder;
+import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.shaking.serviceloader.ServiceLoaderMultipleTest.Greeter;
 import com.android.tools.r8.transformers.ClassFileTransformer;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -34,6 +54,7 @@
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.PreloadedClassFileProvider;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.TestDescriptionWatcher;
@@ -52,6 +73,7 @@
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -66,6 +88,8 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -387,6 +411,11 @@
     return buildClasses(programClasses, libraryClasses).build();
   }
 
+  protected static AndroidApp.Builder buildClasses(Collection<Class<?>> programClasses)
+      throws IOException {
+    return buildClasses(programClasses, Collections.emptyList());
+  }
+
   protected static AndroidApp.Builder buildClasses(
       Collection<Class<?>> programClasses, Collection<Class<?>> libraryClasses) throws IOException {
     AndroidApp.Builder builder = AndroidApp.builder();
@@ -527,6 +556,73 @@
     }
   }
 
+  protected static AppView<AppInfoWithSubtyping> computeAppViewWithSubtyping(AndroidApp app)
+      throws Exception {
+    Timing timing = new Timing();
+    InternalOptions options = new InternalOptions();
+    DexApplication application = new ApplicationReader(app, options, timing).read().toDirect();
+    AppView<AppInfoWithSubtyping> appView =
+        AppView.createForR8(new AppInfoWithSubtyping(application), options);
+    appView.setAppServices(AppServices.builder(appView).build());
+    return appView;
+  }
+
+  protected static AppView<AppInfoWithLiveness> computeAppViewWithLiveness(
+      AndroidApp app, Class<?> mainClass) throws Exception {
+    AppView<AppInfoWithSubtyping> appView = computeAppViewWithSubtyping(app);
+    // Run the tree shaker to compute an instance of AppInfoWithLiveness.
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+    DexApplication application = appView.appInfo().app();
+    RootSet rootSet =
+        new RootSetBuilder(
+                appView, application, buildKeepRuleForClass(mainClass, application.dexItemFactory))
+            .run(executor);
+    AppInfoWithLiveness appInfoWithLiveness =
+        EnqueuerFactory.createForInitialTreeShaking(appView)
+            .traceApplication(rootSet, ProguardClassFilter.empty(), executor, application.timing);
+    // We do not run the tree pruner to ensure that the hierarchy is as designed and not modified
+    // due to liveness.
+    return appView.setAppInfo(appInfoWithLiveness);
+  }
+
+  protected static DexType buildType(Class<?> clazz, DexItemFactory factory) {
+    return buildType(Reference.classFromClass(clazz), factory);
+  }
+
+  protected static DexType buildType(TypeReference type, DexItemFactory factory) {
+    return factory.createType(type.getDescriptor());
+  }
+
+  protected static DexMethod buildMethod(Method method, DexItemFactory factory) {
+    return buildMethod(Reference.methodFromMethod(method), factory);
+  }
+
+  protected static DexMethod buildMethod(MethodReference method, DexItemFactory factory) {
+    return factory.createMethod(
+        buildType(method.getHolderClass(), factory),
+        buildProto(method.getReturnType(), method.getFormalTypes(), factory),
+        method.getMethodName());
+  }
+
+  protected static DexProto buildProto(
+      TypeReference returnType, List<TypeReference> formalTypes, DexItemFactory factory) {
+    return factory.createProto(
+        returnType == null ? factory.voidType : buildType(returnType, factory),
+        ListUtils.map(formalTypes, type -> buildType(type, factory)));
+  }
+
+  private static List<ProguardConfigurationRule> buildKeepRuleForClass(
+      Class clazz, DexItemFactory factory) {
+    Builder keepRuleBuilder = ProguardKeepRule.builder();
+    keepRuleBuilder.setSource("buildKeepRuleForClass " + clazz.getTypeName());
+    keepRuleBuilder.setType(ProguardKeepRuleType.KEEP);
+    keepRuleBuilder.setClassNames(
+        ProguardClassNameList.singletonList(
+            ProguardTypeMatcher.create(
+                factory.createType(DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName())))));
+    return Collections.singletonList(keepRuleBuilder.build());
+  }
+
   /** Returns a list containing all the data resources in the given app. */
   public static List<DataEntryResource> getDataResources(AndroidApp app) throws ResourceException {
     List<DataEntryResource> dataResources = new ArrayList<>();
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index 882459b..5d8e69b 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -33,6 +33,7 @@
 
   public static final Consumer<InternalOptions> DEFAULT_OPTIONS =
       options -> {
+        options.testing.allowClassInlinerGracefulExit = false;
         options.testing.allowUnusedProguardConfigurationRules = false;
         options.testing.reportUnusedProguardConfigurationRules = true;
       };
diff --git a/src/test/java/com/android/tools/r8/VersionTests.java b/src/test/java/com/android/tools/r8/VersionTests.java
new file mode 100644
index 0000000..ba5ee78
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/VersionTests.java
@@ -0,0 +1,65 @@
+// Copyright (c) 2019, 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;
+
+import static com.android.tools.r8.Version.LABEL;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class VersionTests extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  private final TestParameters parameters;
+
+  public VersionTests(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testSemVerInfo() {
+    int majorVersion = Version.getMajorVersion();
+    int minorVersion = Version.getMinorVersion();
+    int patchVersion = Version.getPatchVersion();
+    String preReleaseString = Version.getPreReleaseString();
+    if (LABEL.equals("master")) {
+      assertEquals(-1, majorVersion);
+      assertEquals(-1, minorVersion);
+      assertEquals(-1, patchVersion);
+      assertNull(preReleaseString);
+      assertTrue(Version.getVersionString().startsWith("master"));
+    } else {
+      assertTrue(majorVersion > 0);
+      assertTrue(minorVersion >= 0);
+      assertTrue(patchVersion >= 0);
+      assertNotNull(preReleaseString);
+      assertTrue(
+          Version.getVersionString()
+              .startsWith(
+                  ""
+                      + majorVersion
+                      + "."
+                      + minorVersion
+                      + "."
+                      + patchVersion
+                      + (preReleaseString.isEmpty() ? "" : "-" + preReleaseString)));
+    }
+  }
+
+  @Test
+  public void testDevelopmentPredicate() {
+    assertEquals(LABEL.equals("master") || LABEL.contains("-dev"), Version.isDevelopmentVersion());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/access/NestMethodAccessTest.java b/src/test/java/com/android/tools/r8/graph/access/NestMethodAccessTest.java
new file mode 100644
index 0000000..786177c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/graph/access/NestMethodAccessTest.java
@@ -0,0 +1,153 @@
+// Copyright (c) 2019, 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.graph.access;
+
+import static com.android.tools.r8.TestRuntime.CfVm.JDK11;
+import static org.hamcrest.core.StringContains.containsString;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.ir.optimize.NestUtils;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.transformers.ClassFileTransformer;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class NestMethodAccessTest extends TestBase {
+  static final String EXPECTED = StringUtils.lines("A::bar", "A::baz");
+
+  private final TestParameters parameters;
+  private final boolean inSameNest;
+
+  @Parameterized.Parameters(name = "{0}, in-same-nest:{1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withCfRuntimesStartingFromIncluding(JDK11)
+            .withDexRuntimes()
+            .withAllApiLevels()
+            .build(),
+        BooleanUtils.values());
+  }
+
+  public NestMethodAccessTest(TestParameters parameters, boolean inSameNest) {
+    this.parameters = parameters;
+    this.inSameNest = inSameNest;
+  }
+
+  public Collection<Class<?>> getClasses() {
+    return ImmutableList.of(Main.class);
+  }
+
+  public Collection<byte[]> getTransformedClasses() throws Exception {
+    return ImmutableList.of(
+        withNest(A.class)
+            .setPrivate(A.class.getDeclaredMethod("bar"))
+            .setPrivate(A.class.getDeclaredMethod("baz"))
+            .transform(),
+        withNest(B.class).transform());
+  }
+
+  @Test
+  public void testResolutionAccess() throws Exception {
+    AppView<AppInfoWithLiveness> appView =
+        computeAppViewWithLiveness(
+            buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+            Main.class);
+    AppInfoWithLiveness appInfo = appView.appInfo();
+    DexProgramClass bClass =
+        appInfo.definitionFor(buildType(B.class, appInfo.dexItemFactory())).asProgramClass();
+    DexMethod bar = buildMethod(A.class.getDeclaredMethod("bar"), appInfo.dexItemFactory());
+    ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
+    // TODO(b/145187573): Update to check the full access control once possible.
+    assertEquals(
+        inSameNest,
+        NestUtils.sameNest(bClass.type, resolutionResult.getSingleTarget().method.holder, appView));
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(getClasses())
+        .addProgramClassFileData(getTransformedClasses())
+        .run(parameters.getRuntime(), Main.class)
+        .apply(this::checkExpectedResult);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(getClasses())
+        .addProgramClassFileData(getTransformedClasses())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .run(parameters.getRuntime(), Main.class)
+        .disassemble()
+        .apply(
+            result -> {
+              if (parameters.isDexRuntime() && inSameNest) {
+                // TODO(b/145187969): R8 incorrectly compiles the nest based access away.
+                result.assertFailureWithErrorThatMatches(
+                    containsString(NullPointerException.class.getName()));
+              } else {
+                checkExpectedResult(result);
+              }
+            });
+  }
+
+  private void checkExpectedResult(TestRunResult<?> result) {
+    if (inSameNest) {
+      result.assertSuccessWithOutput(EXPECTED);
+    } else {
+      result.assertFailureWithErrorThatMatches(containsString(IllegalAccessError.class.getName()));
+    }
+  }
+
+  private ClassFileTransformer withNest(Class<?> clazz) throws Exception {
+    if (inSameNest) {
+      // If in the same nest make A host and B a member.
+      return transformer(clazz).setNest(A.class, B.class);
+    }
+    // Otherwise, set the class to be its own host and no additional members.
+    return transformer(clazz).setNest(clazz);
+  }
+
+  static class A {
+    /* will be private */ void bar() {
+      System.out.println("A::bar");
+    }
+
+    /* will be private */ static void baz() {
+      System.out.println("A::baz");
+    }
+  }
+
+  static class B {
+    public void foo() {
+      // Virtual invoke to private method.
+      new A().bar();
+      // Static invoke to private method.
+      A.baz();
+    }
+  }
+
+  static class Main {
+    public static void main(String[] args) {
+      new B().foo();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialForInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialForInvokeVirtualTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java
index 816288d..283f479 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialForInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java
@@ -2,7 +2,7 @@
 // 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static org.junit.Assert.assertEquals;
 import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialForNonDeclaredInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
index a54fa1d..1477df4 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
@@ -2,7 +2,7 @@
 // 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static org.junit.Assert.assertEquals;
 import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java
similarity index 98%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialInterfaceTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java
index f49c764..24ae2fc 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java
@@ -2,7 +2,7 @@
 // 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertEquals;
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialInterfaceWithBridgeTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialInterfaceWithBridgeTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java
index 1253df8..647881d 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialInterfaceWithBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java
@@ -2,7 +2,7 @@
 // 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static org.junit.Assert.assertEquals;
 import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialMissingInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialMissingInvokeVirtualTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java
index e046730..5343c5a 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialMissingInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java
@@ -2,7 +2,7 @@
 // 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertEquals;
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialOnSameClassTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialOnSameClassTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java
index 00f4bb3..7fae808 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialOnSameClassTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java
@@ -2,7 +2,7 @@
 // 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSpecialTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialTest.java
similarity index 90%
rename from src/test/java/com/android/tools/r8/graph/InvokeSpecialTest.java
rename to src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialTest.java
index 83d0b83..44b676a 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSpecialTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialTest.java
@@ -1,8 +1,8 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2019, 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.graph;
+package com.android.tools.r8.graph.invokespecial;
 
 import static com.android.tools.r8.utils.DescriptorUtils.javaTypeToDescriptor;
 import static org.hamcrest.CoreMatchers.containsString;
@@ -13,9 +13,6 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.DexVm.Version;
-import com.android.tools.r8.graph.invokespecial.Main;
-import com.android.tools.r8.graph.invokespecial.TestClass;
-import com.android.tools.r8.graph.invokespecial.TestClassDump;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
 import org.junit.BeforeClass;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java
new file mode 100644
index 0000000..2a2ad92
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2019, 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.callsites;
+
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class HashCodeTest extends TestBase {
+  private static final Class<?> MAIN = TestClass.class;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+
+  public HashCodeTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(HashCodeTest.class)
+        .addKeepMainRule(MAIN)
+        .enableMergeAnnotations()
+        .addOptionsModification(o -> {
+          o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+        })
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutputLines("10");
+  }
+
+  private void callSiteOptimizationInfoInspect(DexEncodedMethod encodedMethod) {
+    // TODO(b/139246447): should avoid visiting A#<init>, which is trivial, default init!
+    assert encodedMethod.method.holder.toSourceString().endsWith("A")
+        && encodedMethod.toSourceString().contains("<init>")
+        : "Unexpected revisit: " + encodedMethod.toSourceString();
+  }
+
+  static class TestClass {
+    public static void main(String[] args) {
+      A obj = System.currentTimeMillis() > 0 ? new B() : new C();
+      System.out.println(obj.hashCode());
+    }
+  }
+
+  @NeverMerge
+  static class A {
+    @Override
+    public int hashCode() {
+      return 1;
+    }
+  }
+
+  @NeverMerge
+  static class B extends A {
+    @Override
+    public int hashCode() {
+      return super.hashCode() * 7 + 3;
+    }
+  }
+
+  static class C extends B {
+    @Override
+    public int hashCode() {
+      return super.hashCode() * 31 + 17;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
similarity index 98%
rename from src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceWithRefinedReceiverTest.java
rename to src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
index 8e9e61f..b804cbe 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
@@ -1,7 +1,7 @@
 // Copyright (c) 2019, 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.callsites.nullability;
+package com.android.tools.r8.ir.optimize.callsites;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
similarity index 98%
rename from src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualWithRefinedReceiverTest.java
rename to src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
index 354ba3b..c69f0c1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
@@ -1,7 +1,7 @@
 // Copyright (c) 2019, 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.callsites.nullability;
+package com.android.tools.r8.ir.optimize.callsites;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/KeptMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/KeptMethodTest.java
rename to src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
index 3822a49..3e87f06 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/KeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
@@ -1,7 +1,7 @@
 // Copyright (c) 2019, 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.callsites.nullability;
+package com.android.tools.r8.ir.optimize.callsites;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/LibraryMethodOverridesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
similarity index 98%
rename from src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/LibraryMethodOverridesTest.java
rename to src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
index ba8c1fd..19172e7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/LibraryMethodOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
@@ -1,7 +1,7 @@
 // Copyright (c) 2019, 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.callsites.nullability;
+package com.android.tools.r8.ir.optimize.callsites;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/WithStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
similarity index 97%
rename from src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/WithStaticizerTest.java
rename to src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
index e600ebc..4fe7fde 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/WithStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
@@ -1,7 +1,7 @@
 // Copyright (c) 2019, 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.callsites.nullability;
+package com.android.tools.r8.ir.optimize.callsites;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
index baea5e4..5f0a56c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
@@ -65,6 +65,7 @@
     if (methodName.equals("test")) {
       upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
     } else {
+      // TODO(b/139246447): should avoid visiting <init>, which is trivial, default init!
       // For testing purpose, `Base` is not merged and kept. The system correctly caught that, when
       // the default initializer is invoked, the receiver had a refined type, `Sub1`.
       upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
index e3bd783..f31919a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
@@ -60,6 +60,7 @@
         : "Unexpected revisit: " + encodedMethod.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo = encodedMethod.getCallSiteOptimizationInfo();
     // `arg` for `test` or the receiver of `Base#<init>`.
+    // TODO(b/139246447): should avoid visiting <init>, which is trivial, default init!
     // For testing purpose, `Base` is not merged and kept. The system correctly caught that, when
     // the default initializer is invoked, the receiver had a refined type, `Sub1`.
     TypeLatticeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
index b6dae68..81da3d5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
@@ -65,6 +65,7 @@
     if (methodName.equals("m")) {
       upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
     } else {
+      // TODO(b/139246447): should avoid visiting <init>, which is trivial, default init!
       // For testing purpose, `Base` is not merged and kept. The system correctly caught that, when
       // the default initializer is invoked, the receiver had a refined type, `Sub1`.
       upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
index 37e5a31..a1042ce 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
@@ -5,12 +5,14 @@
 package com.android.tools.r8.ir.optimize.classinliner;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NeverMerge;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -21,29 +23,31 @@
 @RunWith(Parameterized.class)
 public class BuilderWithInheritanceTest extends TestBase {
 
-  private final Backend backend;
+  private final TestParameters parameters;
 
-  @Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
-  public BuilderWithInheritanceTest(Backend backend) {
-    this.backend = backend;
+  public BuilderWithInheritanceTest(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
   public void test() throws Exception {
     CodeInspector inspector =
-        testForR8(backend)
+        testForR8(parameters.getBackend())
             .addInnerClasses(BuilderWithInheritanceTest.class)
             .addKeepMainRule(TestClass.class)
+            // TODO(b/145090972): Should never need to exit gracefully during testing.
+            .allowClassInlinerGracefulExit()
             .enableInliningAnnotations()
             .enableMergeAnnotations()
-            .run(TestClass.class)
+            .run(parameters.getRuntime(), TestClass.class)
             .assertSuccessWithOutput("42")
             .inspector();
-    assertThat(inspector.clazz(Builder.class), isPresent());
+    assertThat(inspector.clazz(Builder.class), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java
new file mode 100644
index 0000000..2062667
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java
@@ -0,0 +1,84 @@
+// Copyright (c) 2019, 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.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+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 org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class EscapeFromParentConstructorTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public EscapeFromParentConstructorTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(EscapeFromParentConstructorTest.class)
+        .addKeepMainRule(TestClass.class)
+        .enableInliningAnnotations()
+        .enableMergeAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    // The receiver escapes from BuilderBase.<init>(), and therefore, Builder is not considered
+    // eligible for class inlining.
+    assertThat(inspector.clazz(BuilderBase.class), isPresent());
+    assertThat(inspector.clazz(Builder.class), isPresent());
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      System.out.println(new Builder().build());
+    }
+  }
+
+  @NeverMerge
+  static class BuilderBase {
+
+    String greeting;
+
+    BuilderBase() {
+      initialize();
+    }
+
+    @NeverInline
+    void initialize() {
+      this.greeting = "Hello world!";
+    }
+  }
+
+  static class Builder extends BuilderBase {
+
+    String build() {
+      return greeting;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/cost/NonMaterializingFieldAccessesAfterClassInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/cost/NonMaterializingFieldAccessesAfterClassInliningTest.java
new file mode 100644
index 0000000..c95fa85
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/cost/NonMaterializingFieldAccessesAfterClassInliningTest.java
@@ -0,0 +1,216 @@
+// Copyright (c) 2019, 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.classinliner.cost;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+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 org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class NonMaterializingFieldAccessesAfterClassInliningTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public NonMaterializingFieldAccessesAfterClassInliningTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(NonMaterializingFieldAccessesAfterClassInliningTest.class)
+        .addKeepMainRule(TestClass.class)
+        // Should be able to class inline Builder even when the threshold is low.
+        .addOptionsModification(options -> options.classInliningInstructionAllowance = 3)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    assertThat(inspector.clazz(Greeter.class), isPresent());
+    assertThat(inspector.clazz(Builder.class), not(isPresent()));
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      System.out.println(
+          new Builder()
+              .setC1('H')
+              .setC2('e')
+              .setC3('l')
+              .setC4('l')
+              .setC5('o')
+              .setC6(' ')
+              .setC7('w')
+              .setC8('o')
+              .setC9('r')
+              .setC10('l')
+              .setC11('d')
+              .setC12('!')
+              .build());
+    }
+  }
+
+  static class Greeter {
+
+    final char c1;
+    final char c2;
+    final char c3;
+    final char c4;
+    final char c5;
+    final char c6;
+    final char c7;
+    final char c8;
+    final char c9;
+    final char c10;
+    final char c11;
+    final char c12;
+
+    Greeter(
+        char c1,
+        char c2,
+        char c3,
+        char c4,
+        char c5,
+        char c6,
+        char c7,
+        char c8,
+        char c9,
+        char c10,
+        char c11,
+        char c12) {
+      this.c1 = c1;
+      this.c2 = c2;
+      this.c3 = c3;
+      this.c4 = c4;
+      this.c5 = c5;
+      this.c6 = c6;
+      this.c7 = c7;
+      this.c8 = c8;
+      this.c9 = c9;
+      this.c10 = c10;
+      this.c11 = c11;
+      this.c12 = c12;
+    }
+
+    @Override
+    public String toString() {
+      return Character.toString(c1) + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 + c12;
+    }
+  }
+
+  static class Builder {
+
+    char c1;
+    char c2;
+    char c3;
+    char c4;
+    char c5;
+    char c6;
+    char c7;
+    char c8;
+    char c9;
+    char c10;
+    char c11;
+    char c12;
+
+    @NeverInline
+    Builder setC1(char c) {
+      this.c1 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC2(char c) {
+      this.c2 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC3(char c) {
+      this.c3 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC4(char c) {
+      this.c4 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC5(char c) {
+      this.c5 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC6(char c) {
+      this.c6 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC7(char c) {
+      this.c7 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC8(char c) {
+      this.c8 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC9(char c) {
+      this.c9 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC10(char c) {
+      this.c10 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC11(char c) {
+      this.c11 = c;
+      return this;
+    }
+
+    @NeverInline
+    Builder setC12(char c) {
+      this.c12 = c;
+      return this;
+    }
+
+    @NeverInline
+    Greeter build() {
+      return new Greeter(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
new file mode 100644
index 0000000..cdb5538
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2019, 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.kotlin.metadata;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.utils.DescriptorUtils;
+
+abstract class KotlinMetadataTestBase extends KotlinTestBase {
+
+  KotlinMetadataTestBase(KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+  }
+
+  static final String PKG_PREFIX =
+      DescriptorUtils.getBinaryNameFromJavaType(
+          KotlinMetadataTestBase.class.getPackage().getName());
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java
similarity index 72%
rename from src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameTest.java
rename to src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java
index c7ba86e..3ba5ecd 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java
@@ -11,16 +11,13 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinTestBase;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import java.nio.file.Path;
 import java.util.Collection;
@@ -30,7 +27,7 @@
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class MetadataRenameTest extends KotlinTestBase {
+public class MetadataRenameInExtensionTest extends KotlinMetadataTestBase {
 
   private final TestParameters parameters;
 
@@ -40,33 +37,19 @@
         getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
   }
 
-  public MetadataRenameTest(TestParameters parameters, KotlinTargetVersion targetVersion) {
+  public MetadataRenameInExtensionTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
     super(targetVersion);
     this.parameters = parameters;
   }
 
-  private static final String PKG_PREFIX =
-      DescriptorUtils.getBinaryNameFromJavaType(MetadataRenameTest.class.getPackage().getName());
-  private static Path supertypeLibJar;
   private static Path extLibJar;
 
   @BeforeClass
   public static void createLibJar() throws Exception {
-    String supertypeLibFolder = PKG_PREFIX + "/supertype_lib";
-    supertypeLibJar = getStaticTemp().newFile("supertype_lib.jar").toPath();
-    ProcessResult processResult =
-        ToolHelper.runKotlinc(
-            null,
-            supertypeLibJar,
-            null,
-            getKotlinFileInTest(supertypeLibFolder, "impl"),
-            getKotlinFileInTest(supertypeLibFolder + "/internal", "itf")
-        );
-    assertEquals(0, processResult.exitCode);
-
     String extLibFolder = PKG_PREFIX + "/extension_lib";
     extLibJar = getStaticTemp().newFile("ext_lib.jar").toPath();
-    processResult =
+    ProcessResult processResult =
         ToolHelper.runKotlinc(
             null,
             extLibJar,
@@ -77,55 +60,7 @@
   }
 
   @Test
-  public void b143687784() throws Exception {
-    assumeTrue(parameters.getRuntime().isCf());
-
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(supertypeLibJar)
-            // Keep non-private members except for ones in `internal` definitions.
-            .addKeepRules("-keep public class !**.internal.**, * { !private *; }")
-            .addKeepAttributes("*Annotation*")
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String itfClassName = pkg + ".supertype_lib.internal.Itf";
-    final String implClassName = pkg + ".supertype_lib.Impl";
-    compileResult.inspect(inspector -> {
-      ClassSubject itf = inspector.clazz(itfClassName);
-      assertThat(itf, not(isPresent()));
-
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
-      assertNotNull(metadata);
-      assertThat(metadata.toString(), not(containsString("internal")));
-      assertThat(metadata.toString(), not(containsString("Itf")));
-    });
-
-    Path r8ProcessedLibZip = temp.newFile("r8-lib.zip").toPath();
-    compileResult.writeToZip(r8ProcessedLibZip);
-
-    String appFolder = PKG_PREFIX + "/supertype_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf())
-            .addClasspathFiles(r8ProcessedLibZip)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), r8ProcessedLibZip)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".supertype_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::foo", "Program::foo");
-  }
-
-  @Test
-  public void testMetadataInExtension() throws Exception {
-    assumeTrue(parameters.getRuntime().isCf());
-
+  public void testMetadataInExtension_merged() throws Exception {
     R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
             .addProgramFiles(extLibJar)
@@ -161,11 +96,61 @@
         kotlinc(parameters.getRuntime().asCf())
             .addClasspathFiles(r8ProcessedLibZip)
             .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            // TODO(b/143687784): update to just .compile() once fixed.
             .setOutputPath(temp.newFolder().toPath())
+            // TODO(b/143687784): update to just .compile() once fixed.
             .compileRaw();
     // TODO(b/143687784): should be able to compile!
     assertNotEquals(0, kotlinTestCompileResult.exitCode);
     assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: doStuff"));
   }
+
+  @Test
+  public void testMetadataInExtension_renamed() throws Exception {
+    R8TestCompileResult compileResult =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(extLibJar)
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep Super, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Super")
+            // Keep the BKt extension method which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes("*Annotation*")
+            .compile();
+    String pkg = getClass().getPackage().getName();
+    final String superClassName = pkg + ".extension_lib.Super";
+    final String bClassName = pkg + ".extension_lib.B";
+    compileResult.inspect(inspector -> {
+      ClassSubject sup = inspector.clazz(superClassName);
+      assertThat(sup, isPresent());
+      assertThat(sup, isRenamed());
+
+      ClassSubject impl = inspector.clazz(bClassName);
+      assertThat(impl, isPresent());
+      assertThat(impl, not(isRenamed()));
+      // API entry is kept, hence the presence of Metadata.
+      DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
+      assertNotNull(metadata);
+      assertThat(metadata.toString(), not(containsString("Super")));
+    });
+
+    Path r8ProcessedLibZip = temp.newFile("r8-lib.zip").toPath();
+    compileResult.writeToZip(r8ProcessedLibZip);
+
+    String appFolder = PKG_PREFIX + "/extension_app";
+    Path output =
+        kotlinc(parameters.getRuntime().asCf())
+            .addClasspathFiles(r8ProcessedLibZip)
+            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), r8ProcessedLibZip)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), pkg + ".extension_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSupertypeTest.java
similarity index 68%
copy from src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameTest.java
copy to src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSupertypeTest.java
index c7ba86e..7001909 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSupertypeTest.java
@@ -9,18 +9,14 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinTestBase;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import java.nio.file.Path;
 import java.util.Collection;
@@ -30,7 +26,7 @@
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class MetadataRenameTest extends KotlinTestBase {
+public class MetadataRenameInSupertypeTest extends KotlinMetadataTestBase {
 
   private final TestParameters parameters;
 
@@ -40,15 +36,13 @@
         getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
   }
 
-  public MetadataRenameTest(TestParameters parameters, KotlinTargetVersion targetVersion) {
+  public MetadataRenameInSupertypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
     super(targetVersion);
     this.parameters = parameters;
   }
 
-  private static final String PKG_PREFIX =
-      DescriptorUtils.getBinaryNameFromJavaType(MetadataRenameTest.class.getPackage().getName());
   private static Path supertypeLibJar;
-  private static Path extLibJar;
 
   @BeforeClass
   public static void createLibJar() throws Exception {
@@ -63,23 +57,10 @@
             getKotlinFileInTest(supertypeLibFolder + "/internal", "itf")
         );
     assertEquals(0, processResult.exitCode);
-
-    String extLibFolder = PKG_PREFIX + "/extension_lib";
-    extLibJar = getStaticTemp().newFile("ext_lib.jar").toPath();
-    processResult =
-        ToolHelper.runKotlinc(
-            null,
-            extLibJar,
-            null,
-            getKotlinFileInTest(extLibFolder, "B")
-        );
-    assertEquals(0, processResult.exitCode);
   }
 
   @Test
-  public void b143687784() throws Exception {
-    assumeTrue(parameters.getRuntime().isCf());
-
+  public void b143687784_merged() throws Exception {
     R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
             .addProgramFiles(supertypeLibJar)
@@ -123,49 +104,50 @@
   }
 
   @Test
-  public void testMetadataInExtension() throws Exception {
-    assumeTrue(parameters.getRuntime().isCf());
-
+  public void b143687784_renamed() throws Exception {
     R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
-            .addProgramFiles(extLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep the BKt extension method which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addProgramFiles(supertypeLibJar)
+            // Keep non-private members except for ones in `internal` definitions.
+            .addKeepRules("-keep public class !**.internal.**, * { !private *; }")
+            // Keep `internal` definitions, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.internal.** { *; }")
             .addKeepAttributes("*Annotation*")
             .compile();
     String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".extension_lib.Super";
-    final String bClassName = pkg + ".extension_lib.B";
+    final String itfClassName = pkg + ".supertype_lib.internal.Itf";
+    final String implClassName = pkg + ".supertype_lib.Impl";
     compileResult.inspect(inspector -> {
-      ClassSubject sup = inspector.clazz(superClassName);
-      assertThat(sup, not(isPresent()));
+      ClassSubject itf = inspector.clazz(itfClassName);
+      assertThat(itf, isPresent());
+      assertThat(itf, isRenamed());
 
-      ClassSubject impl = inspector.clazz(bClassName);
+      ClassSubject impl = inspector.clazz(implClassName);
       assertThat(impl, isPresent());
       assertThat(impl, not(isRenamed()));
       // API entry is kept, hence the presence of Metadata.
       DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
       assertNotNull(metadata);
-      assertThat(metadata.toString(), not(containsString("Super")));
+      assertThat(metadata.toString(), not(containsString("internal")));
+      assertThat(metadata.toString(), not(containsString("Itf")));
+      assertThat(metadata.toString(), containsString("a/a"));
     });
 
     Path r8ProcessedLibZip = temp.newFile("r8-lib.zip").toPath();
     compileResult.writeToZip(r8ProcessedLibZip);
 
-    String appFolder = PKG_PREFIX + "/extension_app";
-    ProcessResult kotlinTestCompileResult =
+    String appFolder = PKG_PREFIX + "/supertype_app";
+    Path output =
         kotlinc(parameters.getRuntime().asCf())
             .addClasspathFiles(r8ProcessedLibZip)
             .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            // TODO(b/143687784): update to just .compile() once fixed.
             .setOutputPath(temp.newFolder().toPath())
-            .compileRaw();
-    // TODO(b/143687784): should be able to compile!
-    assertNotEquals(0, kotlinTestCompileResult.exitCode);
-    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: doStuff"));
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), r8ProcessedLibZip)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), pkg + ".supertype_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::foo", "Program::foo");
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
index 155c91c..fa46140 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
@@ -15,8 +15,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.util.Collection;
@@ -53,6 +51,8 @@
             .addKeepMainRule(mainClassName)
             .addKeepAttributes("*Annotation*")
             .addKeepRules("-keep class kotlin.Metadata")
+            // TODO(b/145090972): Should never need to exit gracefully during testing.
+            .allowClassInlinerGracefulExit()
             .setMinApi(parameters.getApiLevel())
             .run(parameters.getRuntime(), mainClassName);
     CodeInspector inspector = result.inspector();
@@ -67,5 +67,4 @@
     // All other classes can be renamed, hence the absence of Metadata;
     assertNull(retrieveMetadata(impl1.getDexClass()));
   }
-
 }
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
index ec01f62..b1bcb52 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
@@ -6,17 +6,12 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.AsmTestBase;
-import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.graph.AppInfo;
-import com.android.tools.r8.graph.AppInfoWithSubtyping;
-import com.android.tools.r8.graph.AppServices;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.resolution.singletarget.Main;
 import com.android.tools.r8.resolution.singletarget.one.AbstractSubClass;
 import com.android.tools.r8.resolution.singletarget.one.AbstractTopClass;
@@ -34,26 +29,10 @@
 import com.android.tools.r8.resolution.singletarget.two.OtherSubSubClassOne;
 import com.android.tools.r8.resolution.singletarget.two.OtherSubSubClassTwo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.EnqueuerFactory;
-import com.android.tools.r8.shaking.ProguardClassFilter;
-import com.android.tools.r8.shaking.ProguardClassNameList;
-import com.android.tools.r8.shaking.ProguardConfigurationRule;
-import com.android.tools.r8.shaking.ProguardKeepRule;
-import com.android.tools.r8.shaking.ProguardKeepRule.Builder;
-import com.android.tools.r8.shaking.ProguardKeepRuleType;
-import com.android.tools.r8.shaking.ProguardTypeMatcher;
-import com.android.tools.r8.shaking.RootSetBuilder;
-import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
-import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.ImmutableList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
 import org.junit.Assert;
 import org.junit.BeforeClass;
@@ -103,42 +82,11 @@
     this.allTargetHolders = allTargetHolders;
   }
 
-  public static AppInfoWithLiveness createAppInfoWithLiveness(AndroidApp app, Class<?> mainClass)
-      throws Exception {
-    // Run the tree shaker to compute an instance of AppInfoWithLiveness.
-    Timing timing = new Timing();
-    InternalOptions options = new InternalOptions();
-    DexApplication application = new ApplicationReader(app, options, timing).read().toDirect();
-    AppView<? extends AppInfoWithSubtyping> appView =
-        AppView.createForR8(new AppInfoWithSubtyping(application), options);
-    appView.setAppServices(AppServices.builder(appView).build());
-
-    ExecutorService executor = Executors.newSingleThreadExecutor();
-    RootSet rootSet =
-        new RootSetBuilder(
-                appView, application, buildKeepRuleForClass(mainClass, application.dexItemFactory))
-            .run(executor);
-    return EnqueuerFactory.createForInitialTreeShaking(appView)
-        .traceApplication(rootSet, ProguardClassFilter.empty(), executor, timing);
-    // We do not run the tree pruner to ensure that the hierarchy is as designed and not modified
-    // due to liveness.
-  }
-
   @BeforeClass
   public static void computeAppInfo() throws Exception {
-    appInfo = createAppInfoWithLiveness(readClassesAndAsmDump(CLASSES, ASM_CLASSES), Main.class);
-  }
-
-  private static List<ProguardConfigurationRule> buildKeepRuleForClass(Class clazz,
-      DexItemFactory factory) {
-    Builder keepRuleBuilder = ProguardKeepRule.builder();
-    keepRuleBuilder.setSource("buildKeepRuleForClass " + clazz.getTypeName());
-    keepRuleBuilder.setType(ProguardKeepRuleType.KEEP);
-    keepRuleBuilder.setClassNames(
-        ProguardClassNameList.singletonList(
-            ProguardTypeMatcher.create(
-                factory.createType(DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName())))));
-    return Collections.singletonList(keepRuleBuilder.build());
+    appInfo =
+        computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, ASM_CLASSES), Main.class)
+            .appInfo();
   }
 
   private static Object[] singleTarget(String name, Class<?> receiverAndTarget) {
@@ -244,19 +192,14 @@
         });
   }
 
-  public static DexMethod buildMethod(Class clazz, String name, AppInfo appInfo) {
-    return appInfo
-        .dexItemFactory()
-        .createMethod(
-            toType(clazz, appInfo),
-            appInfo.dexItemFactory().createProto(appInfo.dexItemFactory().voidType),
-            name);
+  public static DexMethod buildNullaryVoidMethod(Class clazz, String name, AppInfo appInfo) {
+    return buildMethod(
+        Reference.method(Reference.classFromClass(clazz), name, Collections.emptyList(), null),
+        appInfo.dexItemFactory());
   }
 
-  public static DexType toType(Class clazz, AppInfo appInfo) {
-    return appInfo
-        .dexItemFactory()
-        .createType(DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName()));
+  private static DexType toType(Class clazz, AppInfo appInfo) {
+    return buildType(clazz, appInfo.dexItemFactory());
   }
 
   private final String methodName;
@@ -266,7 +209,7 @@
 
   @Test
   public void lookupSingleTarget() {
-    DexMethod method = buildMethod(invokeReceiver, methodName, appInfo);
+    DexMethod method = buildNullaryVoidMethod(invokeReceiver, methodName, appInfo);
     Assert.assertNotNull(
         appInfo.resolveMethod(toType(invokeReceiver, appInfo), method).getSingleTarget());
     DexEncodedMethod singleVirtualTarget = appInfo.lookupSingleVirtualTarget(method, method.holder);
@@ -281,7 +224,7 @@
 
   @Test
   public void lookupVirtualTargets() {
-    DexMethod method = buildMethod(invokeReceiver, methodName, appInfo);
+    DexMethod method = buildNullaryVoidMethod(invokeReceiver, methodName, appInfo);
     Assert.assertNotNull(
         appInfo.resolveMethod(toType(invokeReceiver, appInfo), method).getSingleTarget());
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
index ccdb49b..5fe17d5 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
@@ -59,11 +59,11 @@
 
   @BeforeClass
   public static void computeAppInfo() throws Exception {
-    appInfo = SingleTargetLookupTest.createAppInfoWithLiveness(readClasses(CLASSES), Main.class);
+    appInfo = computeAppViewWithLiveness(readClasses(CLASSES), Main.class).appInfo();
   }
 
   private static DexMethod buildMethod(Class clazz, String name) {
-    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+    return SingleTargetLookupTest.buildNullaryVoidMethod(clazz, name, appInfo);
   }
 
   @Parameters(name = "{0}")
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
index f3191ac..22445e6 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
@@ -108,12 +108,11 @@
   @BeforeClass
   public static void computeAppInfo() throws Exception {
     appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            readClassesAndAsmDump(CLASSES, DUMPS), Main.class);
+        computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, DUMPS), Main.class).appInfo();
   }
 
   private static DexMethod buildMethod(Class clazz, String name) {
-    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+    return SingleTargetLookupTest.buildNullaryVoidMethod(clazz, name, appInfo);
   }
 
   @Parameters(name = "{0}")
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
index 7c435d3..63aa76f 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
@@ -95,12 +95,11 @@
   @BeforeClass
   public static void computeAppInfo() throws Exception {
     appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            readClassesAndAsmDump(CLASSES, DUMPS), Main.class);
+        computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, DUMPS), Main.class).appInfo();
   }
 
   private static DexMethod buildMethod(Class clazz, String name) {
-    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+    return SingleTargetLookupTest.buildNullaryVoidMethod(clazz, name, appInfo);
   }
 
   @Parameters(name = "{0}")
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
index e876ce0..22a12f2 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
@@ -142,12 +142,11 @@
   @BeforeClass
   public static void computeAppInfo() throws Exception {
     appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            readClassesAndAsmDump(CLASSES, DUMPS), Main.class);
+        computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, DUMPS), Main.class).appInfo();
   }
 
   private static DexMethod buildMethod(Class clazz, String name) {
-    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+    return SingleTargetLookupTest.buildNullaryVoidMethod(clazz, name, appInfo);
   }
 
   @Parameters(name = "{0}")
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java
index c9a1c5e..2117ed6 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java
@@ -15,8 +15,8 @@
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.resolution.SingleTargetLookupTest;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.AndroidApp;
 import com.google.common.collect.ImmutableList;
-import java.util.Collections;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -43,10 +43,9 @@
   public void testResolution() throws Exception {
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
-    AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList()).build(), Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+    AndroidApp app = readClasses(CLASSES);
+    AppInfoWithLiveness appInfo = computeAppViewWithLiveness(app, Main.class).appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     // Currently R8 will resolve to L::f as that is the first in the topological search.
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
index 075e399..a9c79fc 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
@@ -44,12 +44,13 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList())
-                .addClassProgramData(Collections.singletonList(transformB()))
-                .build(),
-            Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(
+                buildClasses(CLASSES)
+                    .addClassProgramData(Collections.singletonList(transformB()))
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     assertEquals(L.class.getTypeName(), resolutionTarget.method.holder.toSourceString());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
index 58d0891..a65c188 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
@@ -44,12 +44,13 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList())
-                .addClassProgramData(Collections.singletonList(transformB()))
-                .build(),
-            Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(
+                buildClasses(CLASSES)
+                    .addClassProgramData(Collections.singletonList(transformB()))
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     assertEquals(R.class.getTypeName(), resolutionTarget.method.holder.toSourceString());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java
index 30295fd..053fba0 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java
@@ -47,12 +47,13 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList())
-                .addClassProgramData(Collections.singletonList(transformB()))
-                .build(),
-            Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(
+                buildClasses(CLASSES)
+                    .addClassProgramData(Collections.singletonList(transformB()))
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     assertEquals(L.class.getTypeName(), resolutionTarget.method.holder.toSourceString());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java
index 6c4070e..5163bc2 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java
@@ -47,12 +47,13 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList())
-                .addClassProgramData(Collections.singletonList(transformB()))
-                .build(),
-            Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(
+                buildClasses(CLASSES)
+                    .addClassProgramData(Collections.singletonList(transformB()))
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     assertEquals(R.class.getTypeName(), resolutionTarget.method.holder.toSourceString());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
index 581554b..75f689f 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
@@ -46,12 +46,13 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList())
-                .addClassProgramData(Collections.singletonList(transformB()))
-                .build(),
-            Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(
+                buildClasses(CLASSES)
+                    .addClassProgramData(Collections.singletonList(transformB()))
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     Set<String> holders = new HashSet<>();
     resolutionResult
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
index 7ca9525..5772bdc 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
@@ -16,7 +16,6 @@
 import com.android.tools.r8.resolution.SingleTargetLookupTest;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.google.common.collect.ImmutableList;
-import java.util.Collections;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -44,9 +43,8 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList()).build(), Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(readClasses(CLASSES), Main.class).appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     assertEquals(L.class.getTypeName(), resolutionTarget.method.holder.toSourceString());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
index 1cbd668..50e0f8d 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
@@ -16,7 +16,6 @@
 import com.android.tools.r8.resolution.SingleTargetLookupTest;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.google.common.collect.ImmutableList;
-import java.util.Collections;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -44,9 +43,8 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList()).build(), Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(readClasses(CLASSES), Main.class).appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
     assertEquals(R.class.getTypeName(), resolutionTarget.method.holder.toSourceString());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
index 47d7d65..bb81c51 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
@@ -47,12 +47,13 @@
     // The resolution is runtime independent, so just run it on the default CF VM.
     assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
     AppInfoWithLiveness appInfo =
-        SingleTargetLookupTest.createAppInfoWithLiveness(
-            buildClasses(CLASSES, Collections.emptyList())
-                .addClassProgramData(Collections.singletonList(transformB()))
-                .build(),
-            Main.class);
-    DexMethod method = SingleTargetLookupTest.buildMethod(B.class, "f", appInfo);
+        computeAppViewWithLiveness(
+                buildClasses(CLASSES)
+                    .addClassProgramData(Collections.singletonList(transformB()))
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = SingleTargetLookupTest.buildNullaryVoidMethod(B.class, "f", appInfo);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
     Set<String> holders = new HashSet<>();
     resolutionResult
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
index 428f9bb..d0d40bb 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -6,6 +6,8 @@
 import static org.objectweb.asm.Opcodes.ASM7;
 
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
@@ -13,6 +15,7 @@
 import com.android.tools.r8.transformers.MethodTransformer.MethodContext;
 import com.android.tools.r8.utils.DescriptorUtils;
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -24,6 +27,8 @@
 
 public class ClassFileTransformer {
 
+  private static final int NEST_SUPPORTED_VERSION = 55;
+
   /**
    * Basic algorithm for transforming the content of a class file.
    *
@@ -161,6 +166,100 @@
         });
   }
 
+  public ClassFileTransformer setMinVersion(int minVersion) {
+    return addClassTransformer(
+        new ClassTransformer() {
+          @Override
+          public void visit(
+              int version,
+              int access,
+              String name,
+              String signature,
+              String superName,
+              String[] interfaces) {
+            super.visit(
+                Integer.max(version, minVersion), access, name, signature, superName, interfaces);
+          }
+        });
+  }
+
+  public ClassFileTransformer setNest(Class<?> host, Class<?>... members) {
+    assert !Arrays.asList(members).contains(host);
+    return setMinVersion(NEST_SUPPORTED_VERSION)
+        .addClassTransformer(
+            new ClassTransformer() {
+
+              final String hostName = DescriptorUtils.getBinaryNameFromJavaType(host.getTypeName());
+
+              final List<String> memberNames =
+                  Arrays.stream(members)
+                      .map(m -> DescriptorUtils.getBinaryNameFromJavaType(m.getTypeName()))
+                      .collect(Collectors.toList());
+
+              String className;
+
+              @Override
+              public void visit(
+                  int version,
+                  int access,
+                  String name,
+                  String signature,
+                  String superName,
+                  String[] interfaces) {
+                super.visit(version, access, name, signature, superName, interfaces);
+                className = name;
+              }
+
+              @Override
+              public void visitNestHost(String nestHost) {
+                // Ignore/remove existing nest information.
+              }
+
+              @Override
+              public void visitNestMember(String nestMember) {
+                // Ignore/remove existing nest information.
+              }
+
+              @Override
+              public void visitEnd() {
+                if (className.equals(hostName)) {
+                  for (String memberName : memberNames) {
+                    super.visitNestMember(memberName);
+                  }
+                } else {
+                  assert memberNames.contains(className);
+                  super.visitNestHost(hostName);
+                }
+                super.visitEnd();
+              }
+            });
+  }
+
+  public ClassFileTransformer setPrivate(Method method) {
+    return addClassTransformer(
+        new ClassTransformer() {
+          final MethodReference methodReference = Reference.methodFromMethod(method);
+
+          @Override
+          public MethodVisitor visitMethod(
+              int access, String name, String descriptor, String signature, String[] exceptions) {
+            boolean isConstructor =
+                name.equals(Constants.INSTANCE_INITIALIZER_NAME)
+                    || name.equals(Constants.CLASS_INITIALIZER_NAME);
+            MethodAccessFlags accessFlags =
+                MethodAccessFlags.fromCfAccessFlags(access, isConstructor);
+            if (name.equals(methodReference.getMethodName())
+                && descriptor.equals(methodReference.getMethodDescriptor())) {
+              accessFlags.unsetPublic();
+              accessFlags.unsetProtected();
+              accessFlags.setPrivate();
+            }
+            return super.visitMethod(
+                accessFlags.getAsCfAccessFlags(), name, descriptor, signature, exceptions);
+          }
+        });
+  }
+
   /** Abstraction of the MethodVisitor.visitMethodInsn method with its continuation. */
   @FunctionalInterface
   public interface MethodInsnTransform {
diff --git a/tests/d8_api_usage_sample.jar b/tests/d8_api_usage_sample.jar
index 168d828..30b00cb 100644
--- a/tests/d8_api_usage_sample.jar
+++ b/tests/d8_api_usage_sample.jar
Binary files differ
diff --git a/tests/r8_api_usage_sample.jar b/tests/r8_api_usage_sample.jar
index 168d828..4c4801c 100644
--- a/tests/r8_api_usage_sample.jar
+++ b/tests/r8_api_usage_sample.jar
Binary files differ
diff --git a/tools/r8_release.py b/tools/r8_release.py
index a848beb..e661dc6 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -68,6 +68,11 @@
             'is the same as exiting release (%s).' % old_version
           sys.exit(1)
 
+        if args.dev_pre_cherry_pick:
+          for pre_commit in args.dev_pre_cherry_pick:
+            subprocess.check_call([
+                'git', 'cherry-pick', '--no-edit', pre_commit])
+
         # Merge the desired commit from master on to the branch.
         subprocess.check_call([
           'git', 'merge', '--no-ff', '--no-edit', commithash])
@@ -478,6 +483,12 @@
   group.add_argument('--dev-release',
                       metavar=('<master hash>'),
                       help='The hash to use for the new dev version of R8')
+  result.add_argument('--dev-pre-cherry-pick',
+                      metavar=('<master hash(s)>'),
+                      default=[],
+                      action='append',
+                      help='List of commits to cherry pick before doing full '
+                           'merge, mostly used for reverting cherry picks')
   group.add_argument('--version',
                       metavar=('<version>'),
                       help='The new version of R8 (e.g., 1.4.51) to release to selected channels')
@@ -563,4 +574,3 @@
 
 if __name__ == '__main__':
   sys.exit(main())
-
diff --git a/tools/utils.py b/tools/utils.py
index 495f455..2ff2ec2 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -560,8 +560,9 @@
   cmd = [jdk.GetJavaExecutable(), '-cp', path, 'com.android.tools.r8.R8',
         '--version']
   output = subprocess.check_output(cmd, stderr = subprocess.STDOUT)
-  # output is on form 'R8 <version>' so we just strip of 'R8 '.
-  return output.splitlines()[0][3:]
+  # output is of the form 'R8 <version> (with additional info)'
+  # so we split on '('; clean up tailing spaces; and strip off 'R8 '.
+  return output.split('(')[0].strip()[3:]
 
 def desugar_configuration_version():
   with open(DESUGAR_CONFIGURATION, 'r') as f: