diff --git a/src/main/java/com/android/tools/r8/PrintUses.java b/src/main/java/com/android/tools/r8/PrintUses.java
index ef8708f..782094c 100644
--- a/src/main/java/com/android/tools/r8/PrintUses.java
+++ b/src/main/java/com/android/tools/r8/PrintUses.java
@@ -256,7 +256,7 @@
       if (superTarget != null) {
         addMethod(superTarget.getReference());
       }
-      for (DexType type : method.getDefinition().parameters().values) {
+      for (DexType type : method.getDefinition().getParameters()) {
         registerTypeReference(type);
       }
       for (DexAnnotation annotation : method.getDefinition().annotations().annotations) {
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 489d0b6..2d91d71 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -125,8 +125,7 @@
       this.callSiteOptimizationInfoPropagator = null;
     }
 
-    this.libraryMethodSideEffectModelCollection =
-        new LibraryMethodSideEffectModelCollection(dexItemFactory());
+    this.libraryMethodSideEffectModelCollection = new LibraryMethodSideEffectModelCollection(this);
     this.libraryMemberOptimizer = new LibraryMemberOptimizer(this);
 
     if (enableWholeProgramOptimizations() && options().protoShrinking().isProtoShrinkingEnabled()) {
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 fc56e08..8060cbe 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -394,12 +394,16 @@
     return method;
   }
 
-  public DexMethodSignature getSignature() {
-    return new DexMethodSignature(method);
+  public DexType getParameter(int index) {
+    return getReference().getParameter(index);
   }
 
-  public DexTypeList parameters() {
-    return method.proto.parameters;
+  public DexTypeList getParameters() {
+    return getReference().getParameters();
+  }
+
+  public DexMethodSignature getSignature() {
+    return new DexMethodSignature(method);
   }
 
   public DexType returnType() {
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index fd33483..e775ac6 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -293,11 +293,6 @@
       createString(Constants.TEMPORARY_INSTANCE_INITIALIZER_PREFIX);
 
   public final DexString thisName = createString("this");
-
-  // As much as possible, R8 should rely on the content of the static enum field, using
-  // enumMembers.isValuesFieldCandidate or checking the object state in the optimization info.
-  // The field name is unrealiable since the filed can be minified prior to this compilation.
-  // We keep enumValuesFieldName as a heuristic only.
   public final DexString enumValuesFieldName = createString("$VALUES");
 
   public final DexString enabledFieldName = createString("ENABLED");
@@ -440,6 +435,7 @@
       createStaticallyKnownType("Ljava/util/logging/Logger;");
   public final DexType javaUtilSetType = createStaticallyKnownType("Ljava/util/Set;");
 
+  public final DexType androidAppActivity = createStaticallyKnownType("Landroid/app/Activity;");
   public final DexType androidOsBuildType = createStaticallyKnownType("Landroid/os/Build;");
   public final DexType androidOsBuildVersionType =
       createStaticallyKnownType("Landroid/os/Build$VERSION;");
@@ -683,6 +679,17 @@
           createString("makeConcat")
       );
 
+  public Map<DexMethod, int[]> libraryMethodsNonNullParamOrThrow =
+      buildLibraryMethodsNonNullParamOrThrow();
+
+  private Map<DexMethod, int[]> buildLibraryMethodsNonNullParamOrThrow() {
+    ImmutableMap.Builder<DexMethod, int[]> builder = ImmutableMap.builder();
+    for (DexMethod requireNonNullMethod : objectsMethods.requireNonNullMethods()) {
+      builder.put(requireNonNullMethod, new int[] {0});
+    }
+    return builder.build();
+  }
+
   public Set<DexMethod> libraryMethodsReturningReceiver =
       ImmutableSet.<DexMethod>builder()
           .addAll(stringBufferMethods.appendMethods)
@@ -719,6 +726,7 @@
   public Set<DexType> libraryTypesAssumedToBePresent =
       ImmutableSet.<DexType>builder()
           .add(
+              androidAppActivity,
               callableType,
               enumType,
               npeType,
@@ -1390,17 +1398,21 @@
       return field == nameField || field == ordinalField;
     }
 
-    public boolean isEnumField(DexEncodedField staticField, DexType enumType) {
-      assert staticField.isStatic();
-      return staticField.getType() == enumType && staticField.isEnum() && staticField.isFinal();
+    public boolean isValuesMethod(DexMethod method, DexClass enumClass) {
+      assert enumClass.isEnum();
+      return method.holder == enumClass.type
+          && method.proto.returnType == enumClass.type.toArrayType(1, DexItemFactory.this)
+          && method.proto.parameters.size() == 0
+          && method.name == valuesMethodName;
     }
 
-    public boolean isValuesFieldCandidate(DexEncodedField staticField, DexType enumType) {
-      assert staticField.isStatic();
-      return staticField.getType().isArrayType()
-          && staticField.getType().toArrayElementType(DexItemFactory.this) == enumType
-          && staticField.isSynthetic()
-          && staticField.isFinal();
+    public boolean isValueOfMethod(DexMethod method, DexClass enumClass) {
+      assert enumClass.isEnum();
+      return method.holder == enumClass.type
+          && method.proto.returnType == enumClass.type
+          && method.proto.parameters.size() == 1
+          && method.proto.parameters.values[0] == stringType
+          && method.name == valueOfMethodName;
     }
   }
 
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 56f9a92..c488caf 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -19,7 +19,6 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.structural.CompareToVisitor;
 import com.android.tools.r8.utils.structural.HashingVisitor;
 import com.android.tools.r8.utils.structural.StructuralMapping;
@@ -44,6 +43,7 @@
           "$r8$twr$utility",
           "$-DC",
           "$$ServiceLoaderMethods",
+          "com.android.tools.r8.GeneratedOutlineSupport",
           "-$$Lambda$");
 
   public final DexString descriptor;
@@ -338,7 +338,6 @@
     // Any entry that is removed from here must be added to OLD_SYNTHESIZED_NAMES to ensure that
     // newer releases can be used to merge previous builds.
     return name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
-        || name.contains(OutlineOptions.CLASS_NAME) // Global singleton.
         || name.contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME); // Global singleton.
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index fc01602..281215f 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -12,6 +12,9 @@
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.DexValue.DexValueNull;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
@@ -23,7 +26,6 @@
 import com.android.tools.r8.ir.analysis.value.NullOrAbstractValue;
 import com.android.tools.r8.ir.analysis.value.ObjectState;
 import com.android.tools.r8.ir.analysis.value.SingleFieldValue;
-import com.android.tools.r8.ir.analysis.value.UnknownValue;
 import com.android.tools.r8.ir.code.ArrayPut;
 import com.android.tools.r8.ir.code.FieldInstruction;
 import com.android.tools.r8.ir.code.IRCode;
@@ -38,13 +40,10 @@
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoCollection;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.Timing;
-import java.util.IdentityHashMap;
-import java.util.Map;
 
 public class StaticFieldValueAnalysis extends FieldValueAnalysis {
 
   private final StaticFieldValues.Builder builder;
-  private final Map<Value, AbstractValue> computedValues = new IdentityHashMap<>();
 
   private StaticFieldValueAnalysis(
       AppView<AppInfoWithLiveness> appView, IRCode code, OptimizationFeedback feedback) {
@@ -64,7 +63,7 @@
     timing.begin("Analyze class initializer");
     StaticFieldValues result =
         new StaticFieldValueAnalysis(appView.withLiveness(), code, feedback)
-            .analyze(classInitializerDefaultsResult);
+            .analyze(classInitializerDefaultsResult, code.context().getHolderType());
     timing.end();
     return result;
   }
@@ -79,7 +78,8 @@
     return this;
   }
 
-  StaticFieldValues analyze(ClassInitializerDefaultsResult classInitializerDefaultsResult) {
+  StaticFieldValues analyze(
+      ClassInitializerDefaultsResult classInitializerDefaultsResult, DexType holderType) {
     computeFieldOptimizationInfo(classInitializerDefaultsResult);
     return builder.build();
   }
@@ -218,41 +218,16 @@
       return null;
     }
     assert !value.hasAliasedValue();
-    if (value.isPhi()) {
-      return null;
-    }
-    if (value.definition.isNewArrayEmpty()) {
+    if (isEnumValuesArray(value)) {
       return computeSingleEnumFieldValueForValuesArray(value);
     }
-    if (value.definition.isNewInstance()) {
-      return computeSingleEnumFieldValueForInstance(value);
-    }
-    return null;
+    return computeSingleEnumFieldValueForInstance(value);
   }
 
   private SingleFieldValue computeSingleEnumFieldValueForValuesArray(Value value) {
-    if (!value.definition.isNewArrayEmpty()) {
+    if (!value.isDefinedByInstructionSatisfying(Instruction::isNewArrayEmpty)) {
       return null;
     }
-    AbstractValue valuesValue = computedValues.get(value);
-    if (valuesValue != null) {
-      // This implicitely answers null if the value could not get computed.
-      if (valuesValue.isSingleFieldValue()) {
-        SingleFieldValue fieldValue = valuesValue.asSingleFieldValue();
-        if (fieldValue.getState().isEnumValuesObjectState()) {
-          return fieldValue;
-        }
-      }
-      return null;
-    }
-    SingleFieldValue singleFieldValue = internalComputeSingleEnumFieldValueForValuesArray(value);
-    computedValues.put(
-        value, singleFieldValue == null ? UnknownValue.getInstance() : singleFieldValue);
-    return singleFieldValue;
-  }
-
-  private SingleFieldValue internalComputeSingleEnumFieldValueForValuesArray(Value value) {
-    assert value.isDefinedByInstructionSatisfying(Instruction::isNewArrayEmpty);
 
     NewArrayEmpty newArrayEmpty = value.definition.asNewArrayEmpty();
     if (newArrayEmpty.type.toBaseType(appView.dexItemFactory()) != context.getHolder().type) {
@@ -292,9 +267,7 @@
             // We need the state of all fields for the analysis to be valuable.
             return null;
           }
-          if (!valuesArrayIndexMatchesOrdinal(index, objectState)) {
-            return null;
-          }
+          assert verifyValuesArrayIndexMatchesOrdinal(index, objectState);
           if (valuesState[index] != null) {
             return null;
           }
@@ -353,25 +326,24 @@
     return ObjectState.empty();
   }
 
-  private boolean valuesArrayIndexMatchesOrdinal(int ordinal, ObjectState objectState) {
+  private boolean verifyValuesArrayIndexMatchesOrdinal(int ordinal, ObjectState objectState) {
     DexEncodedField ordinalField =
         appView
             .appInfo()
             .resolveField(appView.dexItemFactory().enumMembers.ordinalField, context)
             .getResolvedField();
-    if (ordinalField == null) {
-      return false;
-    }
+    assert ordinalField != null;
     AbstractValue ordinalState = objectState.getAbstractFieldValue(ordinalField);
-    if (ordinalState == null || !ordinalState.isSingleNumberValue()) {
-      return false;
-    }
-    int intValue = ordinalState.asSingleNumberValue().getIntValue();
-    return intValue == ordinal;
+    assert ordinalState != null;
+    assert ordinalState.isSingleNumberValue();
+    assert ordinalState.asSingleNumberValue().getIntValue() == ordinal;
+    return true;
   }
 
   private SingleFieldValue computeSingleEnumFieldValueForInstance(Value value) {
-    assert value.isDefinedByInstructionSatisfying(Instruction::isNewInstance);
+    if (!value.isDefinedByInstructionSatisfying(Instruction::isNewInstance)) {
+      return null;
+    }
 
     NewInstance newInstance = value.definition.asNewInstance();
     // Some enums have direct subclasses, and the subclass is instantiated here.
@@ -487,7 +459,30 @@
   }
 
   private boolean isEnumValuesArray(Value value) {
-    SingleFieldValue singleFieldValue = computeSingleEnumFieldValueForValuesArray(value);
-    return singleFieldValue != null && singleFieldValue.getState().isEnumValuesObjectState();
+    assert context.getHolder().isEnum();
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    DexField valuesField =
+        dexItemFactory.createField(
+            context.getHolderType(),
+            context.getHolderType().toArrayType(1, dexItemFactory),
+            dexItemFactory.enumValuesFieldName);
+
+    Value root = value.getAliasedValue();
+    if (root.isPhi()) {
+      return false;
+    }
+
+    Instruction definition = root.definition;
+    if (definition.isNewArrayEmpty()) {
+      for (Instruction user : root.aliasedUsers()) {
+        if (user.isStaticPut() && user.asStaticPut().getField() == valuesField) {
+          return true;
+        }
+      }
+    } else if (definition.isStaticGet()) {
+      return definition.asStaticGet().getField() == valuesField;
+    }
+
+    return false;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java
index 65e1ea3..b2dcdcd 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java
@@ -37,10 +37,17 @@
   // All the abstract values stored here may match a pinned field, using them requires therefore
   // to check the field is not pinned or prove it is no longer pinned.
   public static class EnumStaticFieldValues extends StaticFieldValues {
-    private final ImmutableMap<DexField, ObjectState> enumAbstractValues;
+    private final ImmutableMap<DexField, AbstractValue> enumAbstractValues;
+    private final DexField valuesField;
+    private final AbstractValue valuesAbstractValue;
 
-    public EnumStaticFieldValues(ImmutableMap<DexField, ObjectState> enumAbstractValues) {
+    public EnumStaticFieldValues(
+        ImmutableMap<DexField, AbstractValue> enumAbstractValues,
+        DexField valuesField,
+        AbstractValue valuesAbstractValue) {
       this.enumAbstractValues = enumAbstractValues;
+      this.valuesField = valuesField;
+      this.valuesAbstractValue = valuesAbstractValue;
     }
 
     static StaticFieldValues.Builder builder() {
@@ -48,38 +55,33 @@
     }
 
     public static class Builder extends StaticFieldValues.Builder {
-      private final ImmutableMap.Builder<DexField, ObjectState> enumObjectStateBuilder =
+      private final ImmutableMap.Builder<DexField, AbstractValue> enumAbstractValuesBuilder =
           ImmutableMap.builder();
-      private AbstractValue valuesCandidateAbstractValue;
+      private DexField valuesFields;
+      private AbstractValue valuesAbstractValue;
 
       Builder() {}
 
       @Override
       public void recordStaticField(
           DexEncodedField staticField, AbstractValue value, DexItemFactory factory) {
-        if (factory.enumMembers.isValuesFieldCandidate(staticField, staticField.getHolderType())) {
-          if (value.isSingleFieldValue()
-              && value.asSingleFieldValue().getState().isEnumValuesObjectState()) {
-            assert valuesCandidateAbstractValue == null
-                || valuesCandidateAbstractValue.equals(value);
-            valuesCandidateAbstractValue = value;
-            enumObjectStateBuilder.put(staticField.field, value.asSingleFieldValue().getState());
-          }
-        } else if (factory.enumMembers.isEnumField(staticField, staticField.getHolderType())) {
-          if (value.isSingleFieldValue() && !value.asSingleFieldValue().getState().isEmpty()) {
-            enumObjectStateBuilder.put(staticField.field, value.asSingleFieldValue().getState());
-          }
+        // TODO(b/166532388): Stop relying on the values name.
+        if (staticField.getName() == factory.enumValuesFieldName) {
+          valuesFields = staticField.field;
+          valuesAbstractValue = value;
+        } else if (staticField.isEnum()) {
+          enumAbstractValuesBuilder.put(staticField.field, value);
         }
       }
 
       @Override
       public StaticFieldValues build() {
-        ImmutableMap<DexField, ObjectState> enumAbstractValues = enumObjectStateBuilder.build();
-        if (enumAbstractValues.isEmpty()) {
+        ImmutableMap<DexField, AbstractValue> enumAbstractValues =
+            enumAbstractValuesBuilder.build();
+        if (valuesAbstractValue == null && enumAbstractValues.isEmpty()) {
           return EmptyStaticValues.getInstance();
         }
-        assert enumAbstractValues.values().stream().noneMatch(ObjectState::isEmpty);
-        return new EnumStaticFieldValues(enumAbstractValues);
+        return new EnumStaticFieldValues(enumAbstractValues, valuesFields, valuesAbstractValue);
       }
     }
 
@@ -94,7 +96,20 @@
     }
 
     public ObjectState getObjectStateForPossiblyPinnedField(DexField field) {
-      return enumAbstractValues.get(field);
+      AbstractValue fieldValue = enumAbstractValues.get(field);
+      if (fieldValue == null || fieldValue.isZero()) {
+        return null;
+      }
+      if (fieldValue.isSingleFieldValue()) {
+        return fieldValue.asSingleFieldValue().getState();
+      }
+      assert fieldValue.isUnknown();
+      return ObjectState.empty();
+    }
+
+    public AbstractValue getValuesAbstractValueForPossiblyPinnedField(DexField field) {
+      assert valuesField == field || valuesAbstractValue == null;
+      return valuesAbstractValue;
     }
   }
 
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 0f0d6e9..85d90e6 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
@@ -328,6 +328,9 @@
   }
 
   public boolean onlyUsedInBlock(BasicBlock block) {
+    if (hasPhiUsers() || hasDebugUsers()) {
+      return false;
+    }
     for (Instruction user : uniqueUsers()) {
       if (user.getBlock() != block) {
         return false;
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 dd9bee9..11a9d00 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
@@ -20,7 +20,6 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexString;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.ProgramMethod;
@@ -101,7 +100,6 @@
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.InternalOptions.DesugarState;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
@@ -838,9 +836,8 @@
               outliner.identifyOutlineSites(code);
             },
             executorService);
-        DexProgramClass outlineClass = outliner.buildOutlinerClass(computeOutlineClassType());
-        appView.appInfo().addSynthesizedClass(outlineClass, true);
-        optimizeSynthesizedClass(outlineClass, executorService);
+        List<ProgramMethod> outlineMethods = outliner.buildOutlineMethods();
+        optimizeSynthesizedMethods(outlineMethods, executorService);
         forEachSelectedOutliningMethod(
             methodsSelectedForOutlining,
             code -> {
@@ -852,8 +849,7 @@
             executorService);
         feedback.updateVisibleOptimizationInfo();
         assert outliner.checkAllOutlineSitesFoundAgain();
-        builder.addSynthesizedClass(outlineClass);
-        clearDexMethodCompilationState(outlineClass);
+        outlineMethods.forEach(m -> m.getDefinition().markNotProcessed());
       }
       timing.end();
     }
@@ -1037,27 +1033,11 @@
     }
   }
 
-  // Find an unused name for the outlining class. When multiple runs produces additional
-  // outlining the default outlining class might already be present.
-  private DexType computeOutlineClassType() {
-    DexType result;
-    int count = 0;
-    String prefix = appView.options().synthesizedClassPrefix.replace('/', '.');
-    do {
-      String name =
-          prefix + OutlineOptions.CLASS_NAME + (count == 0 ? "" : Integer.toString(count));
-      count++;
-      result = appView.dexItemFactory().createType(DescriptorUtils.javaTypeToDescriptor(name));
-
-    } while (appView.appInfo().definitionForWithoutExistenceAssert(result) != null);
-    return result;
-  }
-
-  public void optimizeSynthesizedClass(
-      DexProgramClass clazz, ExecutorService executorService)
+  public void optimizeSynthesizedMethods(
+      List<ProgramMethod> programMethods, ExecutorService executorService)
       throws ExecutionException {
     // Process the generated class, but don't apply any outlining.
-    SortedProgramMethodSet methods = SortedProgramMethodSet.create(clazz::forEachProgramMethod);
+    SortedProgramMethodSet methods = SortedProgramMethodSet.create(programMethods::forEach);
     processMethodsConcurrently(methods, executorService);
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 994e2ba..09fd687 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -165,11 +165,9 @@
   public void processSynthesizedClasses(IRConverter converter, ExecutorService executor)
       throws ExecutionException {
     while (!synthesizedMethods.isEmpty()) {
-      List<ProgramMethod> methods = new ArrayList<>(synthesizedMethods);
+      ArrayList<ProgramMethod> methods = new ArrayList<>(synthesizedMethods);
       synthesizedMethods.clear();
-      for (ProgramMethod method : methods) {
-        converter.optimizeSynthesizedClass(method.getHolder(), executor);
-      }
+      converter.optimizeSynthesizedMethods(methods, executor);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
index 23342df..b176db1 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
@@ -165,7 +165,7 @@
     finalFieldPuts.forEach(
         (field, put) -> {
           DexType fieldType = field.field.type;
-          Value value = put.value();
+          Value value = put.value().getAliasedValue();
           if (unnecessaryStaticPuts.contains(put)) {
             if (fieldType == dexItemFactory.stringType) {
               fieldsWithStaticValues.put(field, getDexStringValue(value, context.getHolderType()));
@@ -404,7 +404,7 @@
             }
             DexField fieldReference = put.getField();
             DexEncodedField field = context.getHolder().lookupField(fieldReference);
-            Value value = put.value();
+            Value value = put.value().getAliasedValue();
             TypeElement valueType = value.getType();
             if (field != null) {
               if (isReadBefore.contains(field)) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index 11b4ddf..dbad5bd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -10,26 +10,16 @@
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
 import com.android.tools.r8.graph.ClasspathMethod;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DebugLocalInfo;
-import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexEncodedField;
 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.DexProgramClass;
-import com.android.tools.r8.graph.DexProgramClass.ChecksumSupplier;
 import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
-import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.MethodAccessFlags;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.analysis.type.ArrayTypeElement;
@@ -65,8 +55,8 @@
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.ListUtils;
@@ -76,7 +66,6 @@
 import com.android.tools.r8.utils.collections.ProgramMethodMultiset;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
@@ -102,9 +91,9 @@
  *       {@link OutlineOptions#threshold}). Each selected method is then converted back to IR and
  *       passed to {@link Outliner#identifyOutlineSites(IRCode)}, which then stores concrete
  *       outlining candidates in {@link Outliner#outlineSites}.
- *   <li>Third, {@link Outliner#buildOutlinerClass(DexType)} is called to construct the <em>outline
- *       support class</em> containing a static helper method for each outline candidate that occurs
- *       frequently enough. Each selected method is then converted to IR, passed to {@link
+ *   <li>Third, {@link Outliner#buildOutlineMethods()} is called to construct the <em>outline
+ *       support classes</em> containing a static helper method for each outline candidate that
+ *       occurs frequently enough. Each selected method is then converted to IR, passed to {@link
  *       Outliner#applyOutliningCandidate(IRCode)} to perform the outlining, and converted back to
  *       the output format (DEX or CF).
  * </ul>
@@ -116,7 +105,7 @@
       new ArrayList<>();
   /** Result of second step (see {@link Outliner#selectMethodsForOutlining()}. */
   private final Map<Outline, List<ProgramMethod>> outlineSites = new HashMap<>();
-  /** Result of third step (see {@link Outliner#buildOutlinerClass(DexType)}. */
+  /** Result of third step (see {@link Outliner#buildOutlineMethods()}. */
   private final Map<Outline, DexMethod> generatedOutlines = new HashMap<>();
 
   static final int MAX_IN_SIZE = 5;  // Avoid using ranged calls for outlined code.
@@ -581,11 +570,6 @@
       return proto;
     }
 
-    // Build the DexMethod for this outline.
-    DexMethod buildMethod(DexType clazz, DexString name) {
-      return appView.dexItemFactory().createMethod(clazz, buildProto(), name);
-    }
-
     @Override
     public boolean equals(Object other) {
       if (!(other instanceof Outline)) {
@@ -1355,67 +1339,40 @@
     return methodsSelectedForOutlining;
   }
 
-  public DexProgramClass buildOutlinerClass(DexType type) {
-    // Build the outlined methods.
-    // By now the candidates are the actual selected outlines. Name the generated methods in a
-    // consistent order, to provide deterministic output.
+  public List<ProgramMethod> buildOutlineMethods() {
+    List<ProgramMethod> outlineMethods = new ArrayList<>();
+    // By now the candidates are the actual selected outlines. Iterate the outlines in a
+    // consistent order, to provide deterministic naming of the internal-synthetics.
+    // The choice of 'representative' will ensure deterministic naming of the external names.
     List<Outline> outlines = selectOutlines();
     outlines.sort(Comparator.naturalOrder());
-    DexEncodedMethod[] direct = new DexEncodedMethod[outlines.size()];
-    int count = 0;
     for (Outline outline : outlines) {
-      MethodAccessFlags methodAccess =
-          MethodAccessFlags.fromSharedAccessFlags(
-              Constants.ACC_PUBLIC | Constants.ACC_STATIC, false);
-      DexString methodName =
-          appView.dexItemFactory().createString(OutlineOptions.METHOD_PREFIX + count);
-      DexMethod method = outline.buildMethod(type, methodName);
       List<ProgramMethod> sites = outlineSites.get(outline);
       assert !sites.isEmpty();
-      direct[count] =
-          new DexEncodedMethod(
-              method,
-              methodAccess,
-              MethodTypeSignature.noSignature(),
-              DexAnnotationSet.empty(),
-              ParameterAnnotationsList.empty(),
-              new OutlineCode(outline),
-              true);
-      if (appView.options().isGeneratingClassFiles()) {
-        direct[count].upgradeClassFileVersion(sites.get(0).getDefinition().getClassFileVersion());
-      }
-      generatedOutlines.put(outline, method);
-      count++;
+      ProgramMethod representative = findDeterministicRepresentative(sites);
+      ProgramMethod outlineMethod =
+          appView
+              .getSyntheticItems()
+              .createMethod(
+                  SyntheticKind.OUTLINE,
+                  representative,
+                  appView.dexItemFactory(),
+                  builder -> {
+                    builder
+                        .setAccessFlags(
+                            MethodAccessFlags.fromSharedAccessFlags(
+                                Constants.ACC_PUBLIC | Constants.ACC_STATIC, false))
+                        .setProto(outline.buildProto())
+                        .setCode(m -> new OutlineCode(outline));
+                    if (appView.options().isGeneratingClassFiles()) {
+                      builder.setClassFileVersion(
+                          representative.getDefinition().getClassFileVersion());
+                    }
+                  });
+      generatedOutlines.put(outline, outlineMethod.getReference());
+      outlineMethods.add(outlineMethod);
     }
-    // No need to sort the direct methods as they are generated in sorted order.
-
-    // Build the outliner class.
-    DexTypeList interfaces = DexTypeList.empty();
-    DexString sourceFile = appView.dexItemFactory().createString("outline");
-    ClassAccessFlags accessFlags = ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC);
-    assert !appView.options().encodeChecksums;
-    // The outliner is R8 only and checksum is not a supported part of R8 compilation.
-    ChecksumSupplier checksumSupplier = DexProgramClass::invalidChecksumRequest;
-    return new DexProgramClass(
-        type,
-        null,
-        new SynthesizedOrigin("outlining", getClass()),
-        accessFlags,
-        appView.dexItemFactory().objectType,
-        interfaces,
-        sourceFile,
-        null,
-        Collections.emptyList(),
-        null,
-        Collections.emptyList(),
-        ClassSignature.noSignature(),
-        DexAnnotationSet.empty(),
-        DexEncodedField.EMPTY_ARRAY, // Static fields.
-        DexEncodedField.EMPTY_ARRAY, // Instance fields.
-        direct,
-        DexEncodedMethod.EMPTY_ARRAY, // Virtual methods.
-        appView.dexItemFactory().getSkipNameValidationForTesting(),
-        checksumSupplier);
+    return outlineMethods;
   }
 
   private List<Outline> selectOutlines() {
@@ -1430,6 +1387,18 @@
     return result;
   }
 
+  private static ProgramMethod findDeterministicRepresentative(List<ProgramMethod> members) {
+    // Pick a deterministic member as representative.
+    ProgramMethod smallest = members.get(0);
+    for (int i = 1; i < members.size(); i++) {
+      ProgramMethod next = members.get(i);
+      if (next.getReference().compareTo(smallest.getReference()) < 0) {
+        smallest = next;
+      }
+    }
+    return smallest;
+  }
+
   public void applyOutliningCandidate(IRCode code) {
     assert !code.method().getCode().isOutlineCode();
     ListIterator<BasicBlock> blocksIterator = code.listIterator();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index cf0ecb5..166022e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -491,36 +491,34 @@
     // Step 1: We iterate over the field to find direct enum instance information and the values
     // fields.
     for (DexEncodedField staticField : enumClass.staticFields()) {
-      if (factory.enumMembers.isEnumField(staticField, enumClass.type)) {
+      if (EnumUnboxingCandidateAnalysis.isEnumField(staticField, enumClass.type)) {
         ObjectState enumState =
             enumStaticFieldValues.getObjectStateForPossiblyPinnedField(staticField.field);
-        if (enumState == null) {
-          if (!isFinalFieldInitialized(staticField, enumClass)) {
-            continue;
+        if (enumState != null) {
+          OptionalInt optionalOrdinal = getOrdinal(enumState);
+          if (!optionalOrdinal.isPresent()) {
+            return null;
           }
-          // Tracking the content of the field yielded either an empty object state, or something
-          // incoherent. We bail out.
+          int ordinal = optionalOrdinal.getAsInt();
+          unboxedValues.put(staticField.field, ordinalToUnboxedInt(ordinal));
+          ordinalToObjectState.put(ordinal, enumState);
+        }
+      } else if (EnumUnboxingCandidateAnalysis.matchesValuesField(
+          staticField, enumClass.type, factory)) {
+        AbstractValue valuesValue =
+            enumStaticFieldValues.getValuesAbstractValueForPossiblyPinnedField(staticField.field);
+        if (valuesValue == null || valuesValue.isZero()) {
+          // Unused field
+          continue;
+        }
+        if (valuesValue.isUnknown()) {
           return null;
         }
-        OptionalInt optionalOrdinal = getOrdinal(enumState);
-        if (!optionalOrdinal.isPresent()) {
+        assert valuesValue.isSingleFieldValue();
+        ObjectState valuesState = valuesValue.asSingleFieldValue().getState();
+        if (!valuesState.isEnumValuesObjectState()) {
           return null;
         }
-        int ordinal = optionalOrdinal.getAsInt();
-        unboxedValues.put(staticField.field, ordinalToUnboxedInt(ordinal));
-        ordinalToObjectState.put(ordinal, enumState);
-      } else if (factory.enumMembers.isValuesFieldCandidate(staticField, enumClass.type)) {
-        ObjectState valuesState =
-            enumStaticFieldValues.getObjectStateForPossiblyPinnedField(staticField.field);
-        if (valuesState == null) {
-          if (!isFinalFieldInitialized(staticField, enumClass)) {
-            continue;
-          }
-          // We could not track the content of that field, and the field could be a values field.
-          // We conservatively bail out.
-          return null;
-        }
-        assert valuesState.isEnumValuesObjectState();
         assert valuesContents == null
             || valuesContents.equals(valuesState.asEnumValuesObjectState());
         valuesContents = valuesState.asEnumValuesObjectState();
@@ -566,13 +564,6 @@
         valuesContents == null ? EnumData.INVALID_VALUES_SIZE : valuesContents.getEnumValuesSize());
   }
 
-  private boolean isFinalFieldInitialized(DexEncodedField staticField, DexProgramClass enumClass) {
-    assert staticField.isFinal();
-    return appView
-        .appInfo()
-        .isFieldOnlyWrittenInMethodIgnoringPinning(staticField, enumClass.getClassInitializer());
-  }
-
   private EnumInstanceFieldData computeEnumFieldData(
       DexField instanceField,
       DexProgramClass enumClass,
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
index 40b0c86..88845d9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
@@ -112,7 +112,7 @@
     // Browse annotation values types in search for enum.
     // Each annotation value is represented by a virtual method.
     for (DexEncodedMethod method : clazz.virtualMethods()) {
-      assert method.parameters().isEmpty()
+      assert method.getParameters().isEmpty()
           || appView.options().testing.allowInjectedAnnotationMethods;
       DexType valueType = method.returnType().toBaseType(appView.dexItemFactory());
       if (enumToUnboxCandidates.isCandidate(valueType)) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index 4c7581e..6c20c4f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -434,7 +434,7 @@
     return factory.createField(
         relocator.getNewMemberLocationFor(enumType),
         factory.intArrayType,
-        "$$values$$field$" + compatibleName(enumType));
+        factory.enumValuesFieldName + "$field$" + compatibleName(enumType));
   }
 
   private DexEncodedField computeValuesEncodedField(DexField field) {
@@ -451,7 +451,7 @@
     return factory.createMethod(
         relocator.getNewMemberLocationFor(enumType),
         factory.createProto(factory.intArrayType),
-        "$$values$$method$" + compatibleName(enumType));
+        factory.enumValuesFieldName + "$method$" + compatibleName(enumType));
   }
 
   private DexEncodedMethod computeValuesEncodedMethod(
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 33b7242..ded60a3 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
@@ -85,7 +85,7 @@
     }
     for (int i = 0; i < method.method.getArity(); i++) {
       staticTypes[i + argOffset] =
-          TypeElement.fromDexType(method.parameters().values[i], maybeNull(), appView);
+          TypeElement.fromDexType(method.getParameter(i), maybeNull(), appView);
     }
     return staticTypes;
   }
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 7f5d173..93a330e 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
@@ -52,6 +52,10 @@
 
   public abstract BitSet getNonNullParamOrThrow();
 
+  public final boolean hasNonNullParamOnNormalExits() {
+    return getNonNullParamOnNormalExits() != null;
+  }
+
   public abstract BitSet getNonNullParamOnNormalExits();
 
   public abstract boolean hasBeenInlinedIntoSingleCallSite();
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 9868a64..3aaba06 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
@@ -156,8 +156,8 @@
         definition, code, feedback, instanceFieldInitializationInfos, timing);
     computeMayHaveSideEffects(feedback, definition, code, timing);
     computeReturnValueOnlyDependsOnArguments(feedback, definition, code, timing);
-    computeNonNullParamOrThrow(feedback, definition, code, timing);
-    computeNonNullParamOnNormalExits(feedback, code, timing);
+    BitSet nonNullParamOrThrow = computeNonNullParamOrThrow(feedback, definition, code, timing);
+    computeNonNullParamOnNormalExits(feedback, code, nonNullParamOrThrow, timing);
   }
 
   private void identifyBridgeInfo(
@@ -1165,18 +1165,19 @@
     }
   }
 
-  private void computeNonNullParamOrThrow(
+  private BitSet computeNonNullParamOrThrow(
       OptimizationFeedback feedback, DexEncodedMethod method, IRCode code, Timing timing) {
     timing.begin("Compute non-null-param-or-throw");
-    computeNonNullParamOrThrow(feedback, method, code);
+    BitSet nonNullParamOrThrow = computeNonNullParamOrThrow(feedback, method, code);
     timing.end();
+    return nonNullParamOrThrow;
   }
 
   // Track usage of parameters and compute their nullability and possibility of NPE.
-  private void computeNonNullParamOrThrow(
+  private BitSet computeNonNullParamOrThrow(
       OptimizationFeedback feedback, DexEncodedMethod method, IRCode code) {
     if (method.getOptimizationInfo().getNonNullParamOrThrow() != null) {
-      return;
+      return null;
     }
     List<Value> arguments = code.collectArguments();
     BitSet paramsCheckedForNull = new BitSet();
@@ -1196,66 +1197,80 @@
         paramsCheckedForNull.set(index);
       }
     }
-    if (paramsCheckedForNull.length() > 0) {
+    if (!paramsCheckedForNull.isEmpty()) {
       feedback.setNonNullParamOrThrow(method, paramsCheckedForNull);
+      return paramsCheckedForNull;
     }
+    return null;
   }
 
   private void computeNonNullParamOnNormalExits(
-      OptimizationFeedback feedback, IRCode code, Timing timing) {
+      OptimizationFeedback feedback, IRCode code, BitSet nonNullParamOrThrow, Timing timing) {
     timing.begin("Compute non-null-param-on-normal-exits");
-    computeNonNullParamOnNormalExits(feedback, code);
+    computeNonNullParamOnNormalExits(feedback, code, nonNullParamOrThrow);
     timing.end();
   }
 
-  private void computeNonNullParamOnNormalExits(OptimizationFeedback feedback, IRCode code) {
+  private void computeNonNullParamOnNormalExits(
+      OptimizationFeedback feedback, IRCode code, BitSet nonNullParamOrThrow) {
     Set<BasicBlock> normalExits = Sets.newIdentityHashSet();
     normalExits.addAll(code.computeNormalExitBlocks());
     DominatorTree dominatorTree = new DominatorTree(code, MAY_HAVE_UNREACHABLE_BLOCKS);
     List<Value> arguments = code.collectArguments();
     BitSet facts = new BitSet();
-    Set<BasicBlock> nullCheckedBlocks = Sets.newIdentityHashSet();
+    if (nonNullParamOrThrow != null) {
+      facts.or(nonNullParamOrThrow);
+    }
     for (int index = 0; index < arguments.size(); index++) {
+      if (facts.get(index)) {
+        continue;
+      }
       Value argument = arguments.get(index);
-      // Consider reference-type parameter only.
-      if (!argument.getType().isReferenceType()) {
-        continue;
-      }
-      // The receiver is always non-null on normal exits.
-      if (argument.isThis()) {
+      if (argument.getType().isReferenceType()
+          && isNonNullOnNormalExit(code, argument, dominatorTree, normalExits)) {
         facts.set(index);
-        continue;
-      }
-      // Collect basic blocks that check nullability of the parameter.
-      nullCheckedBlocks.clear();
-      for (Instruction user : argument.uniqueUsers()) {
-        if (user.isAssumeWithNonNullAssumption()) {
-          nullCheckedBlocks.add(user.asAssume().getBlock());
-        }
-        if (user.isIf()
-            && user.asIf().isZeroTest()
-            && (user.asIf().getType() == If.Type.EQ || user.asIf().getType() == If.Type.NE)) {
-          nullCheckedBlocks.add(user.asIf().targetFromNonNullObject());
-        }
-      }
-      if (!nullCheckedBlocks.isEmpty()) {
-        boolean allExitsCovered = true;
-        for (BasicBlock normalExit : normalExits) {
-          if (!isNormalExitDominated(normalExit, code, dominatorTree, nullCheckedBlocks)) {
-            allExitsCovered = false;
-            break;
-          }
-        }
-        if (allExitsCovered) {
-          facts.set(index);
-        }
       }
     }
-    if (facts.length() > 0) {
+    if (!facts.isEmpty()) {
       feedback.setNonNullParamOnNormalExits(code.method(), facts);
     }
   }
 
+  private boolean isNonNullOnNormalExit(
+      IRCode code, Value value, DominatorTree dominatorTree, Set<BasicBlock> normalExits) {
+    assert value.getType().isReferenceType();
+
+    // The receiver is always non-null on normal exits.
+    if (value.isThis()) {
+      return true;
+    }
+
+    // Collect basic blocks that check nullability of the parameter.
+    Set<BasicBlock> nullCheckedBlocks = Sets.newIdentityHashSet();
+    for (Instruction user : value.aliasedUsers()) {
+      if (user.isAssumeWithNonNullAssumption()
+          || user.throwsNpeIfValueIsNull(value, appView, code.context())) {
+        nullCheckedBlocks.add(user.getBlock());
+      }
+      if (user.isIf()
+          && user.asIf().isZeroTest()
+          && (user.asIf().getType() == If.Type.EQ || user.asIf().getType() == If.Type.NE)) {
+        nullCheckedBlocks.add(user.asIf().targetFromNonNullObject());
+      }
+    }
+
+    if (nullCheckedBlocks.isEmpty()) {
+      return false;
+    }
+
+    for (BasicBlock normalExit : normalExits) {
+      if (!isNormalExitDominated(normalExit, code, dominatorTree, nullCheckedBlocks)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   private boolean isNormalExitDominated(
       BasicBlock normalExit,
       IRCode code,
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java
index ae91ac8..3703148 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java
@@ -4,11 +4,13 @@
 
 package com.android.tools.r8.ir.optimize.library;
 
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.LibraryMethod;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.optimize.library.sideeffects.JavaLangObjectsSideEffectCollection;
 import com.android.tools.r8.utils.BiPredicateUtils;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -25,23 +27,31 @@
 
   private final Set<DexMethod> nonFinalMethodsWithoutSideEffects;
 
-  public LibraryMethodSideEffectModelCollection(DexItemFactory dexItemFactory) {
-    finalMethodsWithoutSideEffects = buildFinalMethodsWithoutSideEffects(dexItemFactory);
+  public LibraryMethodSideEffectModelCollection(AppView<?> appView) {
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    finalMethodsWithoutSideEffects = buildFinalMethodsWithoutSideEffects(appView, dexItemFactory);
     unconditionalFinalMethodsWithoutSideEffects =
         buildUnconditionalFinalMethodsWithoutSideEffects(dexItemFactory);
     nonFinalMethodsWithoutSideEffects = buildNonFinalMethodsWithoutSideEffects(dexItemFactory);
   }
 
   private static Map<DexMethod, BiPredicate<DexMethod, List<Value>>>
-      buildFinalMethodsWithoutSideEffects(DexItemFactory dexItemFactory) {
+      buildFinalMethodsWithoutSideEffects(AppView<?> appView, DexItemFactory dexItemFactory) {
     ImmutableMap.Builder<DexMethod, BiPredicate<DexMethod, List<Value>>> builder =
         ImmutableMap.<DexMethod, BiPredicate<DexMethod, List<Value>>>builder()
             .put(
+                dexItemFactory.objectsMethods.toStringWithObject,
+                (method, arguments) ->
+                    !JavaLangObjectsSideEffectCollection.toStringMayHaveSideEffects(
+                        appView, arguments))
+            .put(
                 dexItemFactory.stringMembers.constructor,
                 (method, arguments) -> arguments.get(1).isNeverNull())
             .put(
                 dexItemFactory.stringMembers.valueOf,
-                (method, arguments) -> arguments.get(0).isNeverNull());
+                (method, arguments) ->
+                    !JavaLangObjectsSideEffectCollection.toStringMayHaveSideEffects(
+                        appView, arguments));
     putAll(
         builder,
         dexItemFactory.stringBufferMethods.constructorMethods,
@@ -71,8 +81,11 @@
         .add(dexItemFactory.shortMembers.toString)
         .add(dexItemFactory.stringBufferMethods.toString)
         .add(dexItemFactory.stringBuilderMethods.toString)
+        .add(dexItemFactory.stringMembers.length)
         .add(dexItemFactory.stringMembers.hashCode)
+        .add(dexItemFactory.stringMembers.isEmpty)
         .add(dexItemFactory.stringMembers.toString)
+        .add(dexItemFactory.stringMembers.trim)
         .addAll(dexItemFactory.classMethods.getNames)
         .addAll(dexItemFactory.boxedValueOfMethods())
         .build();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java
index ecbb3e4..1141303 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java
@@ -45,6 +45,7 @@
   void run(Set<DexEncodedField> finalLibraryFields) {
     modelInstanceInitializers();
     modelStaticFinalLibraryFields(finalLibraryFields);
+    modelLibraryMethodsNonNullParamOrThrow();
     modelLibraryMethodsReturningNonNull();
     modelLibraryMethodsReturningReceiver();
     modelLibraryMethodsWithoutSideEffects();
@@ -87,6 +88,30 @@
     }
   }
 
+  private void modelLibraryMethodsNonNullParamOrThrow() {
+    dexItemFactory.libraryMethodsNonNullParamOrThrow.forEach(
+        (method, nonNullParamOrThrow) -> {
+          DexEncodedMethod definition = lookupMethod(method);
+          if (definition != null) {
+            assert nonNullParamOrThrow.length > 0;
+            int size = nonNullParamOrThrow[nonNullParamOrThrow.length - 1] + 1;
+            BitSet bitSet = new BitSet(size);
+            for (int argumentIndex : nonNullParamOrThrow) {
+              assert argumentIndex < size;
+              bitSet.set(argumentIndex);
+            }
+            feedback.setNonNullParamOrThrow(definition, bitSet);
+
+            // Also set non-null-param-on-normal-exits info.
+            if (definition.getOptimizationInfo().hasNonNullParamOnNormalExits()) {
+              definition.getOptimizationInfo().getNonNullParamOnNormalExits().or(bitSet);
+            } else {
+              feedback.setNonNullParamOnNormalExits(definition, (BitSet) bitSet.clone());
+            }
+          }
+        });
+  }
+
   private void modelLibraryMethodsReturningNonNull() {
     for (DexMethod method : dexItemFactory.libraryMethodsReturningNonNull) {
       DexEncodedMethod definition = lookupMethod(method);
@@ -131,14 +156,6 @@
       DexEncodedMethod definition = lookupMethod(requireNonNullMethod);
       if (definition != null) {
         feedback.methodReturnsArgument(definition, 0);
-
-        BitSet nonNullParamOrThrow = new BitSet();
-        nonNullParamOrThrow.set(0);
-        feedback.setNonNullParamOrThrow(definition, nonNullParamOrThrow);
-
-        BitSet nonNullParamOnNormalExits = new BitSet();
-        nonNullParamOnNormalExits.set(0);
-        feedback.setNonNullParamOnNormalExits(definition, nonNullParamOnNormalExits);
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java
index a303082..831236b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java
@@ -5,19 +5,15 @@
 package com.android.tools.r8.ir.optimize.library;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexItemFactory.ObjectsMethods;
-import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.Set;
 
 public class ObjectsMethodOptimizer extends StatelessLibraryMethodModelCollection {
@@ -90,44 +86,6 @@
         invoke.outValue().replaceUsers(object);
       }
       instructionIterator.removeOrReplaceByDebugLocalRead();
-      return;
-    }
-
-    // Remove Objects.toString() if it is unused and does not have side effects.
-    if (!invoke.hasOutValue() || !invoke.outValue().hasNonDebugUsers()) {
-      // Calling toString() on an array does not call toString() on the array elements.
-      if (type.isArrayType()) {
-        instructionIterator.removeOrReplaceByDebugLocalRead();
-        return;
-      }
-
-      assert type.isClassType();
-
-      // Check if this is a library class with a toString() method that does not have side effects.
-      DexType classType = type.asClassType().getClassType();
-      DexMethod toStringMethodReference =
-          dexItemFactory.objectMembers.toString.withHolder(classType, dexItemFactory);
-      if (appView
-          .getLibraryMethodSideEffectModelCollection()
-          .isSideEffectFreeFinalMethod(toStringMethodReference, invoke.arguments())) {
-        instructionIterator.removeOrReplaceByDebugLocalRead();
-        return;
-      }
-
-      // Check if this is a program class with a toString() method that does not have side effects.
-      AppInfoWithLiveness appInfo = appView.appInfo().withLiveness();
-      if (appInfo != null) {
-        DexClass clazz = appInfo.definitionFor(classType, code.context());
-        if (clazz != null && clazz.isEffectivelyFinal(appView)) {
-          SingleResolutionResult resolutionResult =
-              appInfo.resolveMethodOn(clazz, toStringMethodReference).asSingleResolution();
-          if (resolutionResult != null
-              && !resolutionResult.getResolvedMethod().getOptimizationInfo().mayHaveSideEffects()) {
-            instructionIterator.removeOrReplaceByDebugLocalRead();
-            return;
-          }
-        }
-      }
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java
index a8fabe3..8c62340 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.DexItemBasedConstString;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
@@ -19,7 +20,6 @@
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.utils.ValueUtils;
 import java.util.Set;
 
 public class StringMethodOptimizer extends StatelessLibraryMethodModelCollection {
@@ -48,7 +48,7 @@
     if (singleTargetReference == dexItemFactory.stringMembers.equals) {
       optimizeEquals(code, instructionIterator, invoke.asInvokeVirtual());
     } else if (singleTargetReference == dexItemFactory.stringMembers.valueOf) {
-      optimizeValueOf(instructionIterator, invoke.asInvokeStatic());
+      optimizeValueOf(code, instructionIterator, invoke.asInvokeStatic(), affectedValues);
     }
   }
 
@@ -65,12 +65,30 @@
     }
   }
 
-  private void optimizeValueOf(InstructionListIterator instructionIterator, InvokeStatic invoke) {
-    // Optimize String.valueOf(stringBuilder) if unused.
-    if (ValueUtils.isNonNullStringBuilder(invoke.getFirstArgument(), dexItemFactory)) {
-      if (!invoke.hasOutValue() || !invoke.outValue().hasNonDebugUsers()) {
-        instructionIterator.removeOrReplaceByDebugLocalRead();
+  private void optimizeValueOf(
+      IRCode code,
+      InstructionListIterator instructionIterator,
+      InvokeStatic invoke,
+      Set<Value> affectedValues) {
+    Value object = invoke.getFirstArgument();
+    TypeElement type = object.getType();
+
+    // Optimize String.valueOf(null) into "null".
+    if (type.isDefinitelyNull()) {
+      instructionIterator.replaceCurrentInstructionWithConstString(appView, code, "null");
+      if (invoke.hasOutValue()) {
+        affectedValues.addAll(invoke.outValue().affectedValues());
       }
+      return;
+    }
+
+    // Optimize String.valueOf(nonNullString) into nonNullString.
+    if (type.isDefinitelyNotNull() && type.isStringType(dexItemFactory)) {
+      if (invoke.hasOutValue()) {
+        affectedValues.addAll(invoke.outValue().affectedValues());
+        invoke.outValue().replaceUsers(object);
+      }
+      instructionIterator.removeOrReplaceByDebugLocalRead();
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/sideeffects/JavaLangObjectsSideEffectCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/library/sideeffects/JavaLangObjectsSideEffectCollection.java
new file mode 100644
index 0000000..5f74465
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/sideeffects/JavaLangObjectsSideEffectCollection.java
@@ -0,0 +1,62 @@
+// Copyright (c) 2021, 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.library.sideeffects;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+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.SingleResolutionResult;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.List;
+
+public class JavaLangObjectsSideEffectCollection {
+
+  public static boolean toStringMayHaveSideEffects(AppView<?> appView, List<Value> arguments) {
+    // Calling toString() on an array does not call toString() on the array elements.
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    TypeElement type = arguments.get(0).getType();
+    if (type.isArrayType() || type.isNullType()) {
+      return false;
+    }
+
+    assert type.isClassType();
+
+    // Check if this is a library class with a toString() method that does not have side effects.
+    DexType classType = type.asClassType().getClassType();
+    DexMethod toStringMethodReference =
+        dexItemFactory.objectMembers.toString.withHolder(classType, dexItemFactory);
+    if (appView
+        .getLibraryMethodSideEffectModelCollection()
+        .isSideEffectFreeFinalMethod(toStringMethodReference, arguments)) {
+      return false;
+    }
+
+    if (appView.appInfo().hasLiveness()) {
+      AppInfoWithLiveness appInfo = appView.appInfo().withLiveness();
+
+      // Check if there is an -assumenosideeffects rule for the toString() method.
+      if (appInfo.isAssumeNoSideEffectsMethod(toStringMethodReference)) {
+        return false;
+      }
+
+      // Check if this is a program class with a toString() method that does not have side effects.
+      DexClass clazz = appInfo.definitionFor(classType);
+      if (clazz != null && clazz.isEffectivelyFinal(appView)) {
+        SingleResolutionResult resolutionResult =
+            appInfo.resolveMethodOn(clazz, toStringMethodReference).asSingleResolution();
+        if (resolutionResult != null
+            && !resolutionResult.getResolvedMethod().getOptimizationInfo().mayHaveSideEffects()) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
index af2dee2..3c6c003 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
@@ -299,10 +299,6 @@
 
   // Find Class#get*Name() with a constant-class and replace it with a const-string if possible.
   public void rewriteClassGetName(AppView<?> appView, IRCode code) {
-    // Conflict with {@link CodeRewriter#collectClassInitializerDefaults}.
-    if (code.method().isClassInitializer()) {
-      return;
-    }
     Set<Value> affectedValues = Sets.newIdentityHashSet();
     InstructionListIterator it = code.instructionListIterator();
     while (it.hasNext()) {
@@ -363,11 +359,16 @@
       // while its name is used to compute hash code, which won't be optimized, it's better not to
       // compute the name.
       if (!appView.options().testing.forceNameReflectionOptimization) {
-        EscapeAnalysis escapeAnalysis =
-            new EscapeAnalysis(appView, StringOptimizerEscapeAnalysisConfiguration.getInstance());
-        if (mayBeRenamed || escapeAnalysis.isEscaping(code, out)) {
+        if (mayBeRenamed) {
           continue;
         }
+        if (invokedMethod != factory.classMethods.getSimpleName) {
+          EscapeAnalysis escapeAnalysis =
+              new EscapeAnalysis(appView, StringOptimizerEscapeAnalysisConfiguration.getInstance());
+          if (escapeAnalysis.isEscaping(code, out)) {
+            continue;
+          }
+        }
       }
 
       String descriptor = baseType.toDescriptorString();
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index f7ac800..bc50542 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -109,7 +109,6 @@
 import com.android.tools.r8.utils.Action;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.InternalOptions.DesugarState;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.IteratorUtils;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
@@ -1724,8 +1723,6 @@
             || !options.testing.checkForNotExpandingMainDexTracingResult
             || previousMainDexTracingResult.isRoot(clazz)
             || clazz.toSourceString().contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)
-            // TODO(b/177847090): Consider not outlining anything in main dex.
-            || clazz.toSourceString().contains(OutlineOptions.CLASS_NAME)
         : "Class " + clazz.toSourceString() + " was not a main dex root in the first round";
 
     // Mark types in inner-class attributes referenced.
@@ -3042,6 +3039,10 @@
       ImmutableSet<ProguardKeepRuleBase> keepAllSet =
           ImmutableSet.of(appView.options().getProguardConfiguration().getKeepAllRule());
       for (DexProgramClass clazz : appView.appInfo().classes()) {
+        if (appView.getSyntheticItems().isNonLegacySynthetic(clazz)) {
+          // Don't treat compiler synthesized classes as kept roots.
+          continue;
+        }
         enqueueRootClass(clazz, keepAllSet);
         clazz.forEachProgramMethod(method -> enqueueRootMethod(method, keepAllSet));
         clazz.forEachProgramField(field -> enqueueRootField(field, keepAllSet));
@@ -4050,7 +4051,7 @@
   }
 
   private void markParameterAndReturnTypesAsLive(ProgramMethod method) {
-    for (DexType parameterType : method.getDefinition().parameters().values) {
+    for (DexType parameterType : method.getDefinition().getParameters()) {
       markTypeAsLive(parameterType, method);
     }
     markTypeAsLive(method.getDefinition().returnType(), method);
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index a802761..bf9106a 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -134,6 +134,7 @@
       assert !syntheticMethodsMap.containsKey(from);
       syntheticMethodsMap.put(from, to);
       methodMap.put(from, to);
+      typeMap.put(from.getHolderType(), to.getHolderType());
     }
 
     void move(DexType from, DexType to) {
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index 657db43..d526570 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -201,6 +201,10 @@
     return pending.legacyClasses.containsKey(type);
   }
 
+  public boolean isNonLegacySynthetic(DexProgramClass clazz) {
+    return isCommittedSynthetic(clazz.type) || isPendingSynthetic(clazz.type);
+  }
+
   public boolean isSyntheticClass(DexType type) {
     return isCommittedSynthetic(type)
         || isPendingSynthetic(type)
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
index b33e260..fc5b278 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -32,7 +32,8 @@
     THROW_ICCE("ThrowICCE", true),
     THROW_NSME("ThrowNSME", true),
     TWR_CLOSE_RESOURCE("TwrCloseResource", true),
-    SERVICE_LOADER("ServiceLoad", true);
+    SERVICE_LOADER("ServiceLoad", true),
+    OUTLINE("Outline", true);
 
     public final String descriptor;
     public final boolean isSingleSyntheticMethod;
diff --git a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
index 895f31e..286c83d 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
@@ -467,7 +467,7 @@
       if (superTarget != null) {
         addMethod(superTarget.getReference());
       }
-      for (DexType type : method.getDefinition().parameters().values) {
+      for (DexType type : method.getDefinition().getParameters()) {
         registerTypeReference(type);
       }
       for (DexAnnotation annotation : method.getDefinition().annotations().annotations) {
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 a8bec4a..a9f55ee 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1067,10 +1067,6 @@
   }
 
   public static class OutlineOptions {
-
-    public static final String CLASS_NAME = "com.android.tools.r8.GeneratedOutlineSupport";
-    public static final String METHOD_PREFIX = "outline";
-
     public boolean enabled = true;
     public int minSize = 3;
     public int maxSize = 99;
diff --git a/src/test/java/com/android/tools/r8/R8TestRunResult.java b/src/test/java/com/android/tools/r8/R8TestRunResult.java
index bbd5836..028ed02 100644
--- a/src/test/java/com/android/tools/r8/R8TestRunResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestRunResult.java
@@ -38,6 +38,11 @@
   }
 
   @Override
+  public boolean isR8TestRunResult() {
+    return true;
+  }
+
+  @Override
   protected R8TestRunResult self() {
     return this;
   }
diff --git a/src/test/java/com/android/tools/r8/SingleTestRunResult.java b/src/test/java/com/android/tools/r8/SingleTestRunResult.java
index 875e50d..d532547 100644
--- a/src/test/java/com/android/tools/r8/SingleTestRunResult.java
+++ b/src/test/java/com/android/tools/r8/SingleTestRunResult.java
@@ -34,6 +34,10 @@
     this.result = result;
   }
 
+  public boolean isR8TestRunResult() {
+    return false;
+  }
+
   public AndroidApp app() {
     return app;
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
index b21cbd0..89395ef 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
@@ -97,6 +97,13 @@
     return testForR8(Backend.CF)
         .addProgramClasses(ToStringLib.class, ToStringLib.LibEnum.class)
         .addKeepRules(enumKeepRules.getKeepRules())
+        // TODO(b/160535629): Work-around on some optimizations relying on $VALUES name.
+        .addKeepRules(
+            "-keep enum "
+                + ToStringLib.LibEnum.class.getName()
+                + " { static "
+                + ToStringLib.LibEnum.class.getName()
+                + "[] $VALUES; }")
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
         .addKeepMethodRules(
             Reference.methodFromMethod(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/NoOutliningForClassFileBuildsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/NoOutliningForClassFileBuildsTest.java
index 4af2593..2a837bc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/NoOutliningForClassFileBuildsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/NoOutliningForClassFileBuildsTest.java
@@ -9,7 +9,7 @@
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -72,8 +72,9 @@
     assertThat(classSubject.uniqueMethodWithName("foo"), isPresent());
     assertThat(classSubject.uniqueMethodWithName("bar"), isPresent());
     boolean hasOutlineClass =
-        inspector.allClasses().stream()
-            .anyMatch(c -> c.getFinalName().equals(OutlineOptions.CLASS_NAME));
+        inspector
+            .clazz(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0))
+            .isPresent();
     assertEquals(forceOutline || parameters.isDexRuntime(), hasOutlineClass);
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
index 59602da..6b7bc4a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
@@ -12,7 +12,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -93,9 +93,10 @@
   }
 
   private void validateOutlining(CodeInspector inspector, Class<?> main) {
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
-    assertThat(outlineClass, isPresent());
-    MethodSubject outlineMethod = outlineClass.uniqueMethodWithName("outline0");
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(main, 0));
+    MethodSubject outlineMethod =
+        outlineClass.uniqueMethodWithName(SyntheticItemsTestUtils.syntheticMethodName());
     assertThat(outlineMethod, isPresent());
 
     ClassSubject argClass = inspector.clazz(TestArg.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
index 099afa8..440b036 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
@@ -11,7 +11,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -37,11 +37,12 @@
   }
 
   private void validateOutlining(CodeInspector inspector) {
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0));
     MethodSubject outline0Method =
         outlineClass.method(
             "void",
-            "outline0",
+            SyntheticItemsTestUtils.syntheticMethodName(),
             ImmutableList.of(
                 TestClass.class.getTypeName() + "[]", TestClass.class.getTypeName() + "[]"));
     assertThat(outline0Method, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
index fb4417f9..062516c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
@@ -11,8 +11,8 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -44,12 +44,15 @@
   private void validateOutlining(CodeInspector inspector) {
     // No outlining when arrays of interfaces are involved, see b/132420510 - unless the testing
     // option is set.
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0));
     if (allowOutlinerInterfaceArrayArguments && parameters.isCfRuntime()) {
       assertThat(outlineClass, isPresent());
       MethodSubject outline0Method =
           outlineClass.method(
-              "void", "outline0", ImmutableList.of("java.lang.Object[]", "java.lang.Object[]"));
+              "void",
+              SyntheticItemsTestUtils.syntheticMethodName(),
+              ImmutableList.of("java.lang.Object[]", "java.lang.Object[]"));
       assertThat(outline0Method, isPresent());
       ClassSubject classSubject = inspector.clazz(TestClass.class);
       assertThat(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
index 7a69926..36d9ad5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
@@ -11,7 +11,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -37,9 +37,13 @@
   }
 
   private void validateOutlining(CodeInspector inspector) {
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0));
     MethodSubject outline0Method =
-        outlineClass.method("void", "outline0", ImmutableList.of("int[]", "int[]"));
+        outlineClass.method(
+            "void",
+            SyntheticItemsTestUtils.syntheticMethodName(),
+            ImmutableList.of("int[]", "int[]"));
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b112247415/B112247415.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b112247415/B112247415.java
index 9fcc6b7..b4dd6b7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b112247415/B112247415.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b112247415/B112247415.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
@@ -98,11 +99,14 @@
         .inspector();
 
     for (FoundClassSubject clazz : inspector.allClasses()) {
-      clazz.forAllMethods(method -> {
-        if (method.hasCode() && !method.getFinalName().startsWith("outline")) {
-          verifyAbsenceOfStringBuilderAppend(method.streamInstructions());
-        }
-      });
+      if (!SyntheticItemsTestUtils.isExternalOutlineClass(clazz.getFinalReference())) {
+        clazz.forAllMethods(
+            method -> {
+              if (method.hasCode()) {
+                verifyAbsenceOfStringBuilderAppend(method.streamInstructions());
+              }
+            });
+      }
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
index 66c42e8..031fd9d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
@@ -15,7 +15,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ir.optimize.outliner.b133215941.B133215941.TestClass.ClassWithStaticMethod;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -41,11 +41,12 @@
   }
 
   private void validateOutlining(CodeInspector inspector) {
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0));
     MethodSubject outline0Method =
         outlineClass.method(
             "void",
-            "outline0",
+            SyntheticItemsTestUtils.syntheticMethodName(),
             ImmutableList.of(TestClass.class.getTypeName(), TestClass.class.getTypeName()));
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
index 438aa81..dd6dace 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.ir.optimize.outliner.b149971007;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertFalse;
@@ -15,7 +16,7 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.dexsplitter.SplitterTestBase;
 import com.android.tools.r8.naming.ClassNameMapper;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -24,6 +25,8 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -64,10 +67,17 @@
   }
 
   private void checkOutlineFromFeature(CodeInspector inspector) {
-    ClassSubject clazz = inspector.clazz(OutlineOptions.CLASS_NAME);
-    assertThat(clazz, isPresent());
-    assertEquals(2, clazz.allMethods().size());
-    assertTrue(clazz.allMethods().stream().anyMatch(this::referenceFeatureClass));
+    // There are two expected outlines, each is currently in its own class.
+    List<FoundMethodSubject> allMethods = new ArrayList<>();
+    for (int i = 0; i < 2; i++) {
+      ClassSubject clazz =
+          inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(FeatureClass.class, i));
+      assertThat(clazz, isPresent());
+      assertEquals(1, clazz.allMethods().size());
+      allMethods.addAll(clazz.allMethods());
+    }
+    // One of the methods is StringBuilder the other references the feature.
+    assertTrue(allMethods.stream().anyMatch(this::referenceFeatureClass));
   }
 
   @Test
@@ -85,24 +95,44 @@
     // Check that parts of method1, ..., method4 in FeatureClass was outlined.
     ClassSubject featureClass = compileResult.inspector().clazz(FeatureClass.class);
     assertThat(featureClass, isPresent());
-    String outlineClassName =
+
+    // Find the final names of the two outline classes.
+    String outlineClassName0 =
         ClassNameMapper.mapperFromString(compileResult.getProguardMap())
             .getObfuscatedToOriginalMapping()
             .inverse
-            .get(OutlineOptions.CLASS_NAME);
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
+            .get(
+                SyntheticItemsTestUtils.syntheticOutlineClass(FeatureClass.class, 0).getTypeName());
+    String outlineClassName1 =
+        ClassNameMapper.mapperFromString(compileResult.getProguardMap())
+            .getObfuscatedToOriginalMapping()
+            .inverse
+            .get(
+                SyntheticItemsTestUtils.syntheticOutlineClass(FeatureClass.class, 1).getTypeName());
+
+    // Verify they are called from the feature methods.
+    // Note: should the choice of synthetic grouping change these expectations will too.
+    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName0));
+    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName0));
+    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName1));
+    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName1));
 
     compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("123456");
   }
 
   private void checkNoOutlineFromFeature(CodeInspector inspector) {
-    ClassSubject clazz = inspector.clazz(OutlineOptions.CLASS_NAME);
-    assertThat(clazz, isPresent());
-    assertEquals(1, clazz.allMethods().size());
-    assertTrue(clazz.allMethods().stream().noneMatch(this::referenceFeatureClass));
+    // The features do not give rise to an outline.
+    ClassSubject featureOutlineClass =
+        inspector.clazz(
+            SyntheticItemsTestUtils.syntheticOutlineClass(FeatureClass.class, 0).getTypeName());
+    assertThat(featureOutlineClass, isAbsent());
+    // The main TestClass entry does.
+    ClassSubject mainOutlineClazz =
+        inspector.clazz(
+            SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0).getTypeName());
+    assertThat(mainOutlineClazz, isPresent());
+    assertEquals(1, mainOutlineClazz.allMethods().size());
+    assertTrue(mainOutlineClazz.allMethods().stream().noneMatch(this::referenceFeatureClass));
   }
 
   @Test
@@ -124,12 +154,16 @@
     // Check that parts of method1, ..., method4 in FeatureClass was not outlined.
     CodeInspector featureInspector = new CodeInspector(featureCode);
     ClassSubject featureClass = featureInspector.clazz(FeatureClass.class);
+
+    // Note, this code does not really check a valid property now as the name of the outline is not
+    // known.
     assertThat(featureClass, isPresent());
     String outlineClassName =
         ClassNameMapper.mapperFromString(compileResult.getProguardMap())
             .getObfuscatedToOriginalMapping()
             .inverse
-            .get(OutlineOptions.CLASS_NAME);
+            .get(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0).getTypeName());
+
     assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
     assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
     assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
index eab6811..39c95f1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
@@ -11,7 +11,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -37,11 +37,12 @@
   }
 
   private void validateOutlining(CodeInspector inspector) {
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0));
     MethodSubject outline0Method =
         outlineClass.method(
             "void",
-            "outline0",
+            SyntheticItemsTestUtils.syntheticMethodName(),
             ImmutableList.of(
                 StringBuilder.class.getTypeName(),
                 String.class.getTypeName(),
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
index db3ef77..4b81714 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
@@ -12,7 +12,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -38,10 +38,13 @@
   }
 
   private void validateOutlining(CodeInspector inspector, Class<?> testClass, String argumentType) {
-    ClassSubject outlineClass = inspector.clazz(OutlineOptions.CLASS_NAME);
+    ClassSubject outlineClass =
+        inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(testClass, 0));
     MethodSubject outline0Method =
         outlineClass.method(
-            "java.lang.String", "outline0", ImmutableList.of(argumentType, argumentType));
+            "java.lang.String",
+            SyntheticItemsTestUtils.syntheticMethodName(),
+            ImmutableList.of(argumentType, argumentType));
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(testClass);
     assertThat(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
index 5852266..b96ee7f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.optimize.string;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -22,7 +23,6 @@
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import com.google.common.collect.Streams;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -93,17 +93,17 @@
   }
 
   private long countStringLength(MethodSubject method) {
-    return Streams.stream(method.iterateInstructions(instructionSubject -> {
-      if (instructionSubject.isInvoke()) {
-        return isStringLength(instructionSubject.getMethod());
-      }
-      return false;
-    })).count();
+    return method
+        .streamInstructions()
+        .filter(
+            instructionSubject ->
+                instructionSubject.isInvoke() && isStringLength(instructionSubject.getMethod()))
+        .count();
   }
 
   private long countNonZeroConstNumber(MethodSubject method) {
-    return Streams.stream(method.iterateInstructions(InstructionSubject::isConstNumber)).count()
-        - Streams.stream(method.iterateInstructions(instr -> instr.isConstNumber(0))).count();
+    return method.streamInstructions().filter(InstructionSubject::isConstNumber).count()
+        - method.streamInstructions().filter(instr -> instr.isConstNumber(0)).count();
   }
 
   private void test(
@@ -117,9 +117,13 @@
     ClassSubject mainClass = codeInspector.clazz(MAIN);
 
     MethodSubject clinit = mainClass.clinit();
-    assertThat(clinit, isPresent());
-    assertEquals(expectedStringLengthCountInClinit, countStringLength(clinit));
-    assertEquals(expectedConstNumberCountInClinit, countNonZeroConstNumber(clinit));
+    if (result.isR8TestRunResult()) {
+      assertThat(clinit, isAbsent());
+    } else {
+      assertThat(clinit, isPresent());
+      assertEquals(expectedStringLengthCountInClinit, countStringLength(clinit));
+      assertEquals(expectedConstNumberCountInClinit, countNonZeroConstNumber(clinit));
+    }
 
     MethodSubject m = mainClass.uniqueMethodWithName("instanceMethod");
     assertThat(m, isPresent());
@@ -154,7 +158,7 @@
             .run(parameters.getRuntime(), MAIN)
             .assertSuccessWithOutput(JAVA_OUTPUT);
     // TODO(b/125303292): NAME_LENGTH is still not computed at compile time.
-    test(result, 1, 0, 0, 1);
+    test(result, 0, 0, 0, 1);
   }
 
   @Test
@@ -171,7 +175,6 @@
             .assertSuccessWithOutput(JAVA_OUTPUT);
     // No canonicalization in CF.
     int expectedConstNumber = parameters.isCfRuntime() ? 2 : 1;
-    // TODO(b/125303292): NAME_LENGTH is still not computed at compile time.
-    test(result, 1, 0, 0, expectedConstNumber);
+    test(result, 0, 0, 0, expectedConstNumber);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionMappingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionMappingTest.java
index 30f5c93..d8a7d6b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionMappingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionMappingTest.java
@@ -78,8 +78,8 @@
       if (method.getFinalName().equals("main")) {
         continue;
       }
-      foundZeroArgumentMethod |= method.getMethod().parameters().size() == 0;
-      foundOneArgumentMethod |= method.getMethod().parameters().size() == 1;
+      foundZeroArgumentMethod |= method.getMethod().getParameters().size() == 0;
+      foundOneArgumentMethod |= method.getMethod().getParameters().size() == 1;
     }
     assertTrue(foundZeroArgumentMethod);
     assertTrue(foundOneArgumentMethod);
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
index 94392e6..8f88d08 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
@@ -80,7 +80,6 @@
             .enableInliningAnnotations()
             .enableNoHorizontalClassMergingAnnotations()
             .enableNoStaticClassMergingAnnotations()
-            .noMinification()
             .setMinApi(parameters.getApiLevel())
             .compile();
 
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
new file mode 100644
index 0000000..867b1ec
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
@@ -0,0 +1,155 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.junit.BeforeClass;
+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 MainDexListFromGenerateMainHorizontalMergingTest extends TestBase {
+
+  private static List<ClassReference> mainDexList;
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
+  }
+
+  @BeforeClass
+  public static void setup() throws Exception {
+    mainDexList =
+        testForMainDexListGenerator(getStaticTemp())
+            .addInnerClasses(MainDexListFromGenerateMainHorizontalMergingTest.class)
+            .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+            .addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " { public static void foo(); }")
+            .run()
+            .getMainDexList();
+  }
+
+  public MainDexListFromGenerateMainHorizontalMergingTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    assertEquals(3, mainDexList.size());
+    Set<String> mainDexReferences =
+        mainDexList.stream().map(TypeReference::getTypeName).collect(Collectors.toSet());
+    assertTrue(mainDexReferences.contains(A.class.getTypeName()));
+    assertTrue(mainDexReferences.contains(B.class.getTypeName()));
+    assertTrue(mainDexReferences.contains(Main.class.getTypeName()));
+
+    R8TestCompileResult compileResult =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(getClass())
+            .addInliningAnnotations()
+            .addKeepClassAndMembersRules(Main.class, Outside.class)
+            .addMainDexListClassReferences(mainDexList)
+            .collectMainDexClasses()
+            .enableInliningAnnotations()
+            .enableNeverClassInliningAnnotations()
+            .setMinApi(parameters.getApiLevel())
+            .addHorizontallyMergedClassesInspector(
+                horizontallyMergedClassesInspector -> {
+                  horizontallyMergedClassesInspector.assertMergedInto(B.class, A.class);
+                })
+            .compile();
+
+    CodeInspector inspector = compileResult.inspector();
+    ClassSubject mainClassSubject = inspector.clazz(Main.class);
+    assertThat(mainClassSubject, isPresent());
+
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooMethodSubject, isPresent());
+
+    ClassSubject aClassSubject = inspector.clazz(A.class);
+    assertThat(aClassSubject, isPresent());
+
+    // TODO(b/178460068): Should be present, but was merged with A.
+    ClassSubject bClassSubject = inspector.clazz(B.class);
+    assertThat(bClassSubject, isAbsent());
+
+    MethodSubject fooASubject = aClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooASubject, isPresent());
+
+    assertThat(fooMethodSubject, invokesMethod(fooASubject));
+
+    compileResult.inspectMainDexClasses(
+        mainDexClasses -> {
+          assertEquals(
+              ImmutableSet.of(mainClassSubject.getFinalName(), aClassSubject.getFinalName()),
+              mainDexClasses);
+        });
+
+    compileResult
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputThatMatches(containsString(Outside.class.getTypeName()));
+  }
+
+  static class Main {
+
+    // public static B b;
+
+    public static void main(String[] args) {
+      B.print();
+    }
+
+    public static void foo() {
+      A.foo();
+    }
+  }
+
+  public static class Outside {}
+
+  public static class A {
+
+    @NeverInline
+    public static void foo() {
+      System.out.println("A::foo");
+    }
+  }
+
+  @NeverClassInline
+  public static class B {
+
+    @NeverInline
+    public static void print() {
+      System.out.println(Outside.class);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
new file mode 100644
index 0000000..e3d49f5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
@@ -0,0 +1,159 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.junit.BeforeClass;
+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 MainDexListFromGenerateMainVerticalMergingTest extends TestBase {
+
+  private static List<ClassReference> mainDexList;
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
+  }
+
+  @BeforeClass
+  public static void setup() throws Exception {
+    mainDexList =
+        testForMainDexListGenerator(getStaticTemp())
+            .addInnerClasses(MainDexListFromGenerateMainVerticalMergingTest.class)
+            .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+            .addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " { public static void foo(); }")
+            .run()
+            .getMainDexList();
+  }
+
+  public MainDexListFromGenerateMainVerticalMergingTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    assertEquals(3, mainDexList.size());
+    Set<String> mainDexReferences =
+        mainDexList.stream().map(TypeReference::getTypeName).collect(Collectors.toSet());
+    assertTrue(mainDexReferences.contains(A.class.getTypeName()));
+    assertTrue(mainDexReferences.contains(B.class.getTypeName()));
+    assertTrue(mainDexReferences.contains(Main.class.getTypeName()));
+
+    R8TestCompileResult compileResult =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(getClass())
+            .addInliningAnnotations()
+            .addKeepClassAndMembersRules(Main.class, Outside.class)
+            .addMainDexListClassReferences(mainDexList)
+            .collectMainDexClasses()
+            .enableInliningAnnotations()
+            .enableNeverClassInliningAnnotations()
+            .setMinApi(parameters.getApiLevel())
+            .compile();
+
+    CodeInspector inspector = compileResult.inspector();
+    ClassSubject mainClassSubject = inspector.clazz(Main.class);
+    assertThat(mainClassSubject, isPresent());
+
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooMethodSubject, isPresent());
+
+    ClassSubject aClassSubject = inspector.clazz(A.class);
+    // TODO(b/178460068): Should be present, but was merged with B.
+    assertThat(aClassSubject, isAbsent());
+
+    ClassSubject bClassSubject = inspector.clazz(B.class);
+    assertThat(bClassSubject, isPresent());
+
+    FieldSubject outsideFieldSubject = bClassSubject.uniqueFieldWithName("outsideField");
+    assertThat(outsideFieldSubject, isPresent());
+
+    MethodSubject fooBMethodSubject = bClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooBMethodSubject, isPresent());
+
+    assertThat(fooMethodSubject, invokesMethod(fooBMethodSubject));
+
+    // TODO(b/178460068): B should not be in main dex.
+    compileResult.inspectMainDexClasses(
+        mainDexClasses -> {
+          assertEquals(
+              ImmutableSet.of(mainClassSubject.getFinalName(), bClassSubject.getFinalName()),
+              mainDexClasses);
+        });
+
+    compileResult.run(parameters.getRuntime(), Main.class).assertSuccessWithOutputLines("B::print");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      new B().print();
+    }
+
+    public static void foo() {
+      A.foo();
+    }
+  }
+
+  public static class Outside {}
+
+  public static class A {
+
+    @NeverInline
+    public static void foo() {
+      System.out.println("A::foo");
+    }
+  }
+
+  @NeverClassInline
+  public static class B extends A {
+
+    public static Outside outsideField;
+
+    {
+      outsideField = System.currentTimeMillis() > 0 ? null : new Outside();
+    }
+
+    @NeverInline
+    public void print() {
+      if (outsideField == null) {
+        System.out.println("B::print");
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/smali/OutlineTest.java b/src/test/java/com/android/tools/r8/smali/OutlineTest.java
index 04ac085..efe3826 100644
--- a/src/test/java/com/android/tools/r8/smali/OutlineTest.java
+++ b/src/test/java/com/android/tools/r8/smali/OutlineTest.java
@@ -30,14 +30,18 @@
 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.DexType;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.smali.SmaliBuilder.MethodSignature;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -50,6 +54,10 @@
 
 public class OutlineTest extends SmaliTestBase {
 
+  private static ClassReference OUTLINE_CLASS =
+      SyntheticItemsTestUtils.syntheticOutlineClass(
+          Reference.classFromTypeName(DEFAULT_CLASS_NAME), 0);
+
   private static final String stringBuilderAppendSignature =
       "Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;";
   private static final String stringBuilderAppendDoubleSignature =
@@ -85,12 +93,13 @@
   }
 
   private String firstOutlineMethodName() {
-    return OutlineOptions.CLASS_NAME + '.' + OutlineOptions.METHOD_PREFIX + "0";
+    return OUTLINE_CLASS.getTypeName() + '.' + SyntheticItemsTestUtils.syntheticMethodName();
   }
 
-  private boolean isOutlineMethodName(String qualifiedName) {
-    String qualifiedPrefix = OutlineOptions.CLASS_NAME + '.' + OutlineOptions.METHOD_PREFIX;
-    return qualifiedName.indexOf(qualifiedPrefix) == 0;
+  private static boolean isOutlineMethodName(DexMethod method) {
+    return SyntheticItemsTestUtils.isExternalOutlineClass(
+            Reference.classFromDescriptor(method.holder.toDescriptorString()))
+        && method.name.toString().equals(SyntheticItemsTestUtils.syntheticMethodName());
   }
 
   @Test
@@ -142,7 +151,6 @@
 
       AndroidApp originalApplication = buildApplication(builder);
       AndroidApp processedApplication = processApplication(originalApplication, options);
-      assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
       // Return the processed method for inspection.
       DexEncodedMethod method = getMethod(processedApplication, signature);
@@ -151,7 +159,7 @@
       assertTrue(code.instructions[0] instanceof ConstString);
       assertTrue(code.instructions[1] instanceof InvokeStatic);
       InvokeStatic invoke = (InvokeStatic) code.instructions[1];
-      assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+      assertTrue(isOutlineMethodName(invoke.getMethod()));
 
       // Run code and check result.
       String result = runArt(processedApplication);
@@ -211,7 +219,6 @@
 
       AndroidApp originalApplication = buildApplication(builder);
       AndroidApp processedApplication = processApplication(originalApplication, options);
-      assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
       // Return the processed method for inspection.
       DexEncodedMethod method = getMethod(processedApplication, signature);
@@ -225,7 +232,7 @@
       }
       assertTrue(code.instructions[firstOutlineInvoke] instanceof InvokeStatic);
       InvokeStatic invoke = (InvokeStatic) code.instructions[firstOutlineInvoke];
-      assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+      assertTrue(isOutlineMethodName(invoke.getMethod()));
 
       // Run code and check result.
       String result = runArt(processedApplication);
@@ -273,7 +280,6 @@
     Consumer<InternalOptions> options = configureOutlineOptions(outline -> outline.threshold = 1);
     AndroidApp originalApplication = buildApplication(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
     // Return the processed method for inspection.
     DexEncodedMethod method = getMethod(processedApplication, signature);
@@ -282,7 +288,7 @@
     assertTrue(code.instructions[0] instanceof ConstString);
     assertTrue(code.instructions[1] instanceof InvokeStatic);
     InvokeStatic invoke = (InvokeStatic) code.instructions[1];
-    assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke.getMethod()));
 
     // Run code and check result.
     String result = runArt(processedApplication);
@@ -336,7 +342,6 @@
     Consumer<InternalOptions> options = configureOutlineOptions(outline -> outline.threshold = 1);
     AndroidApp originalApplication = buildApplication(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
     // Return the processed method for inspection.
     DexEncodedMethod method = getMethod(processedApplication, signature);
@@ -346,7 +351,7 @@
     assertTrue(code.instructions[1] instanceof ConstString);
     assertTrue(code.instructions[2] instanceof InvokeStatic);
     InvokeStatic invoke = (InvokeStatic) code.instructions[2];
-    assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke.getMethod()));
 
     // Run code and check result.
     String result = runArt(processedApplication);
@@ -402,7 +407,6 @@
 
       AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
       AndroidApp processedApplication = processApplication(originalApplication, options);
-      assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
       // Return the processed method for inspection.
       DexEncodedMethod method = getMethod(processedApplication, signature);
@@ -412,13 +416,13 @@
       if (i < 3) {
         assertTrue(code.instructions[1] instanceof InvokeStatic);
         InvokeStatic invoke = (InvokeStatic) code.instructions[1];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       } else {
         assertTrue(code.instructions[1] instanceof InvokeVirtual);
         assertTrue(code.instructions[2] instanceof InvokeVirtual);
         assertTrue(code.instructions[3] instanceof InvokeStatic);
         InvokeStatic invoke = (InvokeStatic) code.instructions[3];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       }
 
       // Run code and check result.
@@ -480,7 +484,6 @@
 
       AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
       AndroidApp processedApplication = processApplication(originalApplication, options);
-      assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
       // Return the processed method for inspection.
       DexEncodedMethod method = getMethod(processedApplication, signature);
@@ -490,13 +493,13 @@
       if (i < 3) {
         assertTrue(code.instructions[1] instanceof InvokeStatic);
         InvokeStatic invoke = (InvokeStatic) code.instructions[1];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       } else {
         assertTrue(code.instructions[1] instanceof InvokeVirtual);
         assertTrue(code.instructions[2] instanceof InvokeVirtual);
         assertTrue(code.instructions[3] instanceof InvokeStatic);
         InvokeStatic invoke = (InvokeStatic) code.instructions[3];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       }
 
       // Run code and check result.
@@ -553,7 +556,6 @@
 
       AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
       AndroidApp processedApplication = processApplication(originalApplication, options);
-      assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
       // Return the processed main method for inspection.
       DexEncodedMethod mainMethod = getMethod(processedApplication, mainSignature);
@@ -569,14 +571,14 @@
       }
       if (i == 2) {
         InvokeStatic invoke = (InvokeStatic) mainCode.instructions[4];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       } else if (i == 3) {
         InvokeStatic invoke = (InvokeStatic) mainCode.instructions[1];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       } else {
         assert i == 4 || i == 5;
         InvokeStatic invoke = (InvokeStatic) mainCode.instructions[2];
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       }
 
       // Run code and check result.
@@ -653,19 +655,19 @@
 
     AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
+    assertEquals(3, getNumberOfProgramClasses(processedApplication));
 
     DexCode code1 = getMethod(processedApplication, signature1).getCode().asDexCode();
     assertEquals(4, code1.instructions.length);
     assertTrue(code1.instructions[1] instanceof InvokeStatic);
     InvokeStatic invoke1 = (InvokeStatic) code1.instructions[1];
-    assertTrue(isOutlineMethodName(invoke1.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke1.getMethod()));
 
     DexCode code2 = getMethod(processedApplication, signature2).getCode().asDexCode();
     assertEquals(5, code2.instructions.length);
     assertTrue(code2.instructions[2] instanceof InvokeStatic);
     InvokeStatic invoke2 = (InvokeStatic) code2.instructions[2];
-    assertTrue(isOutlineMethodName(invoke1.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke1.getMethod()));
 
     // Run code and check result.
     String result = runArt(processedApplication);
@@ -721,7 +723,6 @@
 
       AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
       AndroidApp processedApplication = processApplication(originalApplication, options);
-      assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
       DexCode code = getMethod(processedApplication, signature).getCode().asDexCode();
       int outlineInstructionIndex;
@@ -739,10 +740,10 @@
       Instruction instruction = code.instructions[outlineInstructionIndex];
       if (instruction instanceof InvokeStatic) {
         InvokeStatic invoke = (InvokeStatic) instruction;
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       } else {
         InvokeStaticRange invoke = (InvokeStaticRange) instruction;
-        assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+        assertTrue(isOutlineMethodName(invoke.getMethod()));
       }
 
       // Run code and check result.
@@ -791,7 +792,7 @@
     InvokeStatic invoke;
     assertTrue(code.instructions[0] instanceof InvokeStatic);
     invoke = (InvokeStatic) code.instructions[0];
-    assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke.getMethod()));
 
     // Run code and check result.
     String result = runArt(processedApplication);
@@ -859,16 +860,15 @@
 
     AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
+    assertEquals(4, getNumberOfProgramClasses(processedApplication));
 
     // Check that three outlining methods was created.
     CodeInspector inspector = new CodeInspector(processedApplication);
-    ClassSubject clazz = inspector.clazz(OutlineOptions.CLASS_NAME);
-    assertTrue(clazz.isPresent());
-    assertEquals(3, clazz.getDexProgramClass().getMethodCollection().numberOfDirectMethods());
+    List<DexEncodedMethod> outlineMethods = getOutlineMethods(inspector);
+    assertEquals(3, outlineMethods.size());
     // Collect the return types of the outlines for the body of method1 and method2.
     List<DexType> r = new ArrayList<>();
-    for (DexEncodedMethod directMethod : clazz.getDexProgramClass().directMethods()) {
+    for (DexEncodedMethod directMethod : outlineMethods) {
       if (directMethod.getCode().asDexCode().instructions[0] instanceof InvokeVirtual) {
         r.add(directMethod.method.proto.returnType);
       }
@@ -885,6 +885,16 @@
     assertEquals("TestTestTestTestTest", result);
   }
 
+  private static List<DexEncodedMethod> getOutlineMethods(CodeInspector inspector) {
+    List<DexEncodedMethod> outlineMethods = new ArrayList<>();
+    for (FoundClassSubject clazz : inspector.allClasses()) {
+      if (SyntheticItemsTestUtils.isExternalOutlineClass(clazz.getFinalReference())) {
+        clazz.forAllMethods(m -> outlineMethods.add(m.getMethod()));
+      }
+    }
+    return outlineMethods;
+  }
+
   @Test
   public void outlineMultipleTimes() throws Exception {
     SmaliBuilder builder = new SmaliBuilder(DEFAULT_CLASS_NAME);
@@ -931,15 +941,18 @@
 
     AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
+    assertEquals(3, getNumberOfProgramClasses(processedApplication));
 
     final int count = 10;
-    // Process the application several times. Each time will outline the previous outline.
-    for (int i = 0; i < count; i++) {
+    // Process the application several times. Each time will outline the previous outlines.
+    for (int i = 1; i < count; i++) {
       // Build a new application with the Outliner class.
       originalApplication = processedApplication;
-      processedApplication = processApplication(originalApplication, options);
-      assertEquals(i + 3, getNumberOfProgramClasses(processedApplication));
+      processedApplication =
+          processApplication(
+              originalApplication,
+              options.andThen(o -> o.testing.allowConflictingSyntheticTypes = true));
+      assertEquals((i + 1) * 3, getNumberOfProgramClasses(processedApplication));
     }
 
     // Process the application several times. No more outlining as threshold has been raised.
@@ -954,7 +967,7 @@
       // Build a new application with the Outliner class.
       originalApplication = processedApplication;
       processedApplication = processApplication(originalApplication, options);
-      assertEquals(count - 1 + 3, getNumberOfProgramClasses(processedApplication));
+      assertEquals(count * 3, getNumberOfProgramClasses(processedApplication));
     }
 
     // Run the application with several levels of outlining.
@@ -1195,7 +1208,6 @@
 
     AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
     // Return the processed method for inspection.
     DexEncodedMethod method1 = getMethod(processedApplication, signature1);
@@ -1205,7 +1217,7 @@
     assertTrue(code1.instructions[1] instanceof MoveResult);
     assertTrue(code1.instructions[2] instanceof Return);
     InvokeStatic invoke1 = (InvokeStatic) code1.instructions[0];
-    assertTrue(isOutlineMethodName(invoke1.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke1.getMethod()));
 
     DexEncodedMethod method2 = getMethod(processedApplication, signature2);
     DexCode code2 = method2.getCode().asDexCode();
@@ -1287,7 +1299,7 @@
     assertTrue(code.instructions[5] instanceof Const4);
     assertTrue(code.instructions[6] instanceof Return);
     InvokeStatic invoke = (InvokeStatic) code.instructions[1];
-    assertTrue(isOutlineMethodName(invoke.getMethod().qualifiedName()));
+    assertTrue(isOutlineMethodName(invoke.getMethod()));
 
     // Run code and check result.
     String result = runArt(processedApplication);
@@ -1614,15 +1626,13 @@
 
     AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
     AndroidApp processedApplication = processApplication(originalApplication, options);
-    assertEquals(2, getNumberOfProgramClasses(processedApplication));
 
     // Verify the code.
     runDex2Oat(processedApplication);
   }
 
   private static boolean isOutlineInvoke(Instruction instruction) {
-    return instruction instanceof InvokeStatic
-        && instruction.getMethod().holder.toSourceString().equals(OutlineOptions.CLASS_NAME);
+    return instruction instanceof InvokeStatic && isOutlineMethodName(instruction.getMethod());
   }
 
   private void assertHasOutlineInvoke(DexEncodedMethod method) {
@@ -1699,10 +1709,10 @@
     assertHasOutlineInvoke(getMethod(processedApplication, signature2));
     assertThat(
         new CodeInspector(processedApplication)
-            .clazz(OutlineOptions.CLASS_NAME)
+            .clazz(OUTLINE_CLASS)
             .method(
                 "boolean",
-                "outline0",
+                SyntheticItemsTestUtils.syntheticMethodName(),
                 ImmutableList.of("java.io.PrintStream", "java.util.ArrayList")),
         isPresent());
 
@@ -1774,8 +1784,11 @@
     assertHasOutlineInvoke(getMethod(processedApplication, signature2));
     assertThat(
         new CodeInspector(processedApplication)
-            .clazz(OutlineOptions.CLASS_NAME)
-            .method("boolean", "outline0", ImmutableList.of("java.util.List")),
+            .clazz(OUTLINE_CLASS)
+            .method(
+                "boolean",
+                SyntheticItemsTestUtils.syntheticMethodName(),
+                ImmutableList.of("java.util.List")),
         isPresent());
 
     // Run code and check result.
@@ -1848,8 +1861,11 @@
     assertHasOutlineInvoke(getMethod(processedApplication, signature2));
     assertThat(
         new CodeInspector(processedApplication)
-            .clazz(OutlineOptions.CLASS_NAME)
-            .method("boolean", "outline0", ImmutableList.of("java.util.ArrayList")),
+            .clazz(OUTLINE_CLASS)
+            .method(
+                "boolean",
+                SyntheticItemsTestUtils.syntheticMethodName(),
+                ImmutableList.of("java.util.ArrayList")),
         isPresent());
 
     // Run code and check result.
@@ -1922,8 +1938,11 @@
     assertHasOutlineInvoke(getMethod(processedApplication, signature2));
     assertThat(
         new CodeInspector(processedApplication)
-            .clazz(OutlineOptions.CLASS_NAME)
-            .method("boolean", "outline0", ImmutableList.of("java.util.ArrayList")),
+            .clazz(OUTLINE_CLASS)
+            .method(
+                "boolean",
+                SyntheticItemsTestUtils.syntheticMethodName(),
+                ImmutableList.of("java.util.ArrayList")),
         isPresent());
 
     // Run code and check result.
diff --git a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
index 438d3f9..3f9c6af 100644
--- a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
+++ b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
@@ -16,6 +16,10 @@
 
 public class SyntheticItemsTestUtils {
 
+  public static String syntheticMethodName() {
+    return SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX;
+  }
+
   public static ClassReference syntheticCompanionClass(Class<?> clazz) {
     return Reference.classFromDescriptor(
         InterfaceMethodRewriter.getCompanionClassDescriptor(
@@ -23,8 +27,11 @@
   }
 
   private static ClassReference syntheticClass(Class<?> clazz, SyntheticKind kind, int id) {
-    return SyntheticNaming.makeSyntheticReferenceForTest(
-        Reference.classFromClass(clazz), kind, "" + id);
+    return syntheticClass(Reference.classFromClass(clazz), kind, id);
+  }
+
+  private static ClassReference syntheticClass(ClassReference clazz, SyntheticKind kind, int id) {
+    return SyntheticNaming.makeSyntheticReferenceForTest(clazz, kind, "" + id);
   }
 
   public static MethodReference syntheticBackportMethod(Class<?> clazz, int id, Method method) {
@@ -33,10 +40,18 @@
     MethodReference originalMethod = Reference.methodFromMethod(method);
     return Reference.methodFromDescriptor(
         syntheticHolder.getDescriptor(),
-        SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX,
+        syntheticMethodName(),
         originalMethod.getMethodDescriptor());
   }
 
+  public static ClassReference syntheticOutlineClass(Class<?> clazz, int id) {
+    return syntheticClass(clazz, SyntheticKind.OUTLINE, id);
+  }
+
+  public static ClassReference syntheticOutlineClass(ClassReference clazz, int id) {
+    return syntheticClass(clazz, SyntheticKind.OUTLINE, id);
+  }
+
   public static ClassReference syntheticLambdaClass(Class<?> clazz, int id) {
     return syntheticClass(clazz, SyntheticNaming.SyntheticKind.LAMBDA, id);
   }
@@ -67,6 +82,10 @@
     return SyntheticNaming.isSynthetic(reference, Phase.EXTERNAL, SyntheticKind.TWR_CLOSE_RESOURCE);
   }
 
+  public static boolean isExternalOutlineClass(ClassReference reference) {
+    return SyntheticNaming.isSynthetic(reference, Phase.EXTERNAL, SyntheticKind.OUTLINE);
+  }
+
   public static Matcher<String> containsInternalSyntheticReference() {
     return containsString(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
   }
diff --git a/tools/r8_release.py b/tools/r8_release.py
index 179a50f..783b30d 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -9,7 +9,7 @@
 import re
 import subprocess
 import sys
-import urllib
+import urllib.request
 import xml.etree.ElementTree
 import zipfile
 
@@ -70,7 +70,7 @@
 
         # Verify that the merge point from master is not empty.
         merge_diff_output = subprocess.check_output([
-          'git', 'diff', 'HEAD..%s' % commithash])
+          'git', 'diff', 'HEAD..%s' % commithash]).decode('utf-8')
         other_diff = version_change_diff(
             merge_diff_output, old_version, "master")
         if not other_diff:
@@ -94,14 +94,14 @@
           'git', 'commit', '-a', '-m', 'Version %s' % version])
 
         version_diff_output = subprocess.check_output([
-          'git', 'diff', '%s..HEAD' % commithash])
+          'git', 'diff', '%s..HEAD' % commithash]).decode('utf-8')
 
         validate_version_change_diff(version_diff_output, "master", version)
 
         # Double check that we want to push the release.
         if not args.dry_run:
-          input = raw_input('Publish dev release version %s [y/N]:' % version)
-          if input != 'y':
+          answer = input('Publish dev release version %s [y/N]:' % version)
+          if answer != 'y':
             print('Aborting dev release for %s' % version)
             sys.exit(1)
 
@@ -144,10 +144,10 @@
     print(version_diff_output)
     print("=" * 80)
     accept_string = 'THE DIFF IS OK!'
-    input = raw_input(
+    answer = input(
       "Accept the additonal diff as part of the release? "
       "Type '%s' to accept: " % accept_string)
-    if input != accept_string:
+    if answer != accept_string:
       print("You did not type '%s'" % accept_string)
       print('Aborting dev release for %s' % version)
       sys.exit(1)
@@ -233,9 +233,9 @@
         release_id, "com.android.tools:r8:%s" % args.version, "r8lib.jar")
 
     print
-    input = raw_input("Continue with publishing [y/N]:")
+    answer = input("Continue with publishing [y/N]:")
 
-    if input != 'y':
+    if answer != 'y':
       print('Aborting release to Google maven')
       sys.exit(1)
 
@@ -305,7 +305,7 @@
 def g4_change(version):
   return subprocess.check_output(
       'g4 change --desc "Update R8 to version %s\n"' % (version),
-      shell=True)
+      shell=True).decode('utf-8')
 
 def get_cl_id(c4_change_output):
   startIndex = c4_change_output.find('Change ') + len('Change ')
@@ -323,7 +323,7 @@
 
 
 def download_file(version, file, dst):
-  urllib.urlretrieve(
+  urllib.request.urlretrieve(
       ('https://storage.googleapis.com/r8-releases/raw/%s/%s' % (version, file)),
       dst)
 
@@ -332,13 +332,13 @@
     print('Unexpected gfile prefix for %s' % gfile)
     sys.exit(1)
 
-  urllib.urlretrieve(
+  urllib.request.urlretrieve(
       'https://storage.googleapis.com/%s' % gfile[len('/bigstore/'):],
       dst)
 
 def blaze_run(target):
   return subprocess.check_output(
-      'blaze run %s' % target, shell=True, stderr=subprocess.STDOUT)
+      'blaze run %s' % target, shell=True, stderr=subprocess.STDOUT).decode('utf-8')
 
 
 def prepare_google3(args):
@@ -353,7 +353,7 @@
       return 'DryRun: omitting g3 release for %s' % options.version
 
     google3_base = subprocess.check_output(
-        ['p4', 'g4d', '-f', args.p4_client]).rstrip()
+        ['p4', 'g4d', '-f', args.p4_client]).decode('utf-8').rstrip()
     third_party_r8 = os.path.join(google3_base, 'third_party', 'java', 'r8')
     today = datetime.date.today()
     with utils.ChangedWorkingDirectory(third_party_r8):
@@ -504,9 +504,9 @@
             library_jar)
 
         print("")
-        input = raw_input("Continue with publishing [y/N]:")
+        answer = input("Continue with publishing [y/N]:")
 
-        if input != 'y':
+        if answer != 'y':
           print('Aborting release to Google maven')
           sys.exit(1)
 
@@ -542,11 +542,11 @@
 
 def check_no_google3_client(args, client_name):
   if not args.use_existing_work_branch:
-    clients = subprocess.check_output('g4 myclients', shell=True)
+    clients = subprocess.check_output('g4 myclients', shell=True).decode('utf-8')
     if ':%s:' % client_name in clients:
-      print("Remove the existing '%s' client before continuing " +
+      print(("Remove the existing '%s' client before continuing " +
              "(force delete: 'g4 citc -d -f %s'), " +
-             "or use option --use-existing-work-branch.") % (client_name, client_name)
+             "or use option --use-existing-work-branch.") % (client_name, client_name))
       sys.exit(1)
 
 
@@ -701,8 +701,8 @@
 
         # Double check that we want to create a new release branch.
         if not options.dry_run:
-          input = raw_input('Create new branch for %s [y/N]:' % branch_version)
-          if input != 'y':
+          answer = input('Create new branch for %s [y/N]:' % branch_version)
+          if answer != 'y':
             print('Aborting new branch for %s' % branch_version)
             sys.exit(1)