diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 73f58af..cae27a3 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -265,9 +265,6 @@
         if (result != null) {
           appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
           appView.pruneItems(result.prunedItems);
-          if (result.lens != null) {
-            appView.setGraphLens(result.lens);
-          }
         }
         new CfApplicationWriter(
                 appView,
@@ -312,9 +309,6 @@
         if (result != null) {
           appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
           appView.pruneItems(result.prunedItems);
-          if (result.lens != null) {
-            appView.setGraphLens(result.lens);
-          }
         }
 
         new ApplicationWriter(
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index 3e4e809..40f48d2 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -132,9 +132,6 @@
       if (result != null) {
         appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
         appView.pruneItems(result.prunedItems);
-        if (result.lens != null) {
-          appView.setGraphLens(result.lens);
-        }
       }
 
       NamingLens namingLens = PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView);
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 67bd8bd..1dc771e 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -837,21 +837,12 @@
           appView.getSyntheticItems().computeFinalSynthetics(appView);
       if (result != null) {
         if (appView.appInfo().hasLiveness()) {
-          if (result.lens == null) {
-            appViewWithLiveness.setAppInfo(
-                appViewWithLiveness.appInfo().rebuildWithLiveness(result.commit));
-          } else {
-            appViewWithLiveness.rewriteWithLensAndApplication(
-                result.lens, result.commit.getApplication().asDirect());
-          }
-          appViewWithLiveness.pruneItems(result.prunedItems);
+          appViewWithLiveness.setAppInfo(
+              appViewWithLiveness.appInfo().rebuildWithLiveness(result.commit));
         } else {
           appView.setAppInfo(appView.appInfo().rebuildWithClassHierarchy(result.commit));
-          appView.pruneItems(result.prunedItems);
-          if (result.lens != null) {
-            appView.setGraphLens(result.lens);
-          }
         }
+        appViewWithLiveness.pruneItems(result.prunedItems);
       }
 
       // Perform minification.
diff --git a/src/main/java/com/android/tools/r8/code/Instruction.java b/src/main/java/com/android/tools/r8/code/Instruction.java
index ccfd713..977dafd 100644
--- a/src/main/java/com/android/tools/r8/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/code/Instruction.java
@@ -332,9 +332,6 @@
   @Override
   public final void acceptHashing(HashingVisitor visitor) {
     // Rather than traverse the full instruction, the compare ID will likely give a reasonable hash.
-    // TODO(b/158159959): This will likely lead to a lot of distinct synthetics hashing to the same
-    //  hash as many have the same instruction pattern such as an invoke of the impl method or a
-    //  field access.
     visitor.visitInt(getCompareToId());
   }
 
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index bbe4a90..ef6b7cd 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -55,7 +55,7 @@
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.position.MethodPosition;
-import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.DexVersion;
 import com.android.tools.r8.utils.InternalOptions;
@@ -323,7 +323,7 @@
     for (DexType type : mapping.getTypes()) {
       if (type.isClassType()) {
         assert DexString.isValidSimpleName(apiLevel, type.getName());
-        assert SyntheticNaming.verifyNotInternalSynthetic(type);
+        assert SyntheticItems.verifyNotInternalSynthetic(type);
       }
     }
 
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index 8fbdd8e..bce34ff 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -28,7 +28,7 @@
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
@@ -666,7 +666,7 @@
 
     @Override
     public boolean addType(DexType type) {
-      assert SyntheticNaming.verifyNotInternalSynthetic(type);
+      assert SyntheticItems.verifyNotInternalSynthetic(type);
       return types.add(type);
     }
 
@@ -789,7 +789,7 @@
 
     @Override
     public boolean addType(DexType type) {
-      assert SyntheticNaming.verifyNotInternalSynthetic(type);
+      assert SyntheticItems.verifyNotInternalSynthetic(type);
       return maybeInsert(type, types, base.types);
     }
 
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index 302dff4..cfacdbb 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -123,6 +123,11 @@
     }
   }
 
+  public Collection<DexProgramClass> synthesizedClasses() {
+    assert checkIfObsolete();
+    return syntheticItems.getPendingSyntheticClasses();
+  }
+
   public Collection<DexProgramClass> classes() {
     assert checkIfObsolete();
     return app.classes();
diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index 4d45d55..eb83898 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -247,9 +247,6 @@
   public void acceptHashing(HashingVisitor visitor) {
     // Rather than hash the entire content, hash the sizes and each instruction "type" which
     // should provide a fast yet reasonably distinct key.
-    // TODO(b/158159959): This will likely lead to a lot of distinct synthetics hashing to the same
-    //  hash as many have the same instruction pattern such as an invoke of the impl method or a
-    //  field access.
     visitor.visitInt(instructions.size());
     visitor.visitInt(tryCatchRanges.size());
     visitor.visitInt(localVariables.size());
diff --git a/src/main/java/com/android/tools/r8/graph/DexAnnotation.java b/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
index 3483fbb..bcb7974 100644
--- a/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
+++ b/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
@@ -14,8 +14,6 @@
 import com.android.tools.r8.graph.DexValue.DexValueString;
 import com.android.tools.r8.graph.DexValue.DexValueType;
 import com.android.tools.r8.ir.desugar.CovariantReturnTypeAnnotationTransformer;
-import com.android.tools.r8.synthesis.SyntheticNaming;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Pair;
 import com.android.tools.r8.utils.structural.StructuralItem;
@@ -401,18 +399,13 @@
   }
 
   public static DexAnnotation createAnnotationSynthesizedClass(
-      SyntheticKind kind, DexType synthesizingContext, DexItemFactory dexItemFactory) {
-    DexAnnotationElement kindElement =
-        new DexAnnotationElement(
-            dexItemFactory.kindString,
-            new DexValueString(dexItemFactory.createString(kind.descriptor)));
-    DexAnnotationElement typeElement =
-        new DexAnnotationElement(dexItemFactory.valueString, new DexValueType(synthesizingContext));
+      DexType synthesizingContext, DexItemFactory dexItemFactory) {
+    DexValueType value = new DexValueType(synthesizingContext);
+    DexAnnotationElement element = new DexAnnotationElement(dexItemFactory.valueString, value);
     return new DexAnnotation(
         VISIBILITY_BUILD,
         new DexEncodedAnnotation(
-            dexItemFactory.annotationSynthesizedClass,
-            new DexAnnotationElement[] {kindElement, typeElement}));
+            dexItemFactory.annotationSynthesizedClass, new DexAnnotationElement[] {element}));
   }
 
   public static boolean hasSynthesizedClassAnnotation(
@@ -420,7 +413,7 @@
     return getSynthesizedClassAnnotationContextType(annotations, factory) != null;
   }
 
-  public static Pair<SyntheticKind, DexType> getSynthesizedClassAnnotationContextType(
+  public static DexType getSynthesizedClassAnnotationContextType(
       DexAnnotationSet annotations, DexItemFactory factory) {
     if (annotations.size() != 1) {
       return null;
@@ -429,31 +422,17 @@
     if (annotation.annotation.type != factory.annotationSynthesizedClass) {
       return null;
     }
-    if (annotation.annotation.elements.length != 2) {
+    if (annotation.annotation.elements.length != 1) {
       return null;
     }
-    assert factory.kindString.isLessThan(factory.valueString);
-    DexAnnotationElement kindElement = annotation.annotation.elements[0];
-    if (kindElement.name != factory.kindString) {
+    DexAnnotationElement element = annotation.annotation.elements[0];
+    if (element.name != factory.valueString) {
       return null;
     }
-    if (!kindElement.value.isDexValueString()) {
+    if (!element.value.isDexValueType()) {
       return null;
     }
-    SyntheticKind kind =
-        SyntheticNaming.SyntheticKind.fromDescriptor(
-            kindElement.value.asDexValueString().getValue().toString());
-    if (kind == null) {
-      return null;
-    }
-    DexAnnotationElement valueElement = annotation.annotation.elements[1];
-    if (valueElement.name != factory.valueString) {
-      return null;
-    }
-    if (!valueElement.value.isDexValueType()) {
-      return null;
-    }
-    return new Pair<>(kind, valueElement.value.asDexValueType().getValue());
+    return element.value.asDexValueType().getValue();
   }
 
   public static DexAnnotation createAnnotationSynthesizedClassMap(
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 84ca4fc..4acd029 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -76,12 +76,14 @@
 import com.android.tools.r8.utils.OptionalBool;
 import com.android.tools.r8.utils.Pair;
 import com.android.tools.r8.utils.structural.CompareToVisitor;
+import com.android.tools.r8.utils.structural.CompareToVisitorWithTypeEquivalence;
 import com.android.tools.r8.utils.structural.HashingVisitor;
+import com.android.tools.r8.utils.structural.HashingVisitorWithTypeEquivalence;
 import com.android.tools.r8.utils.structural.Ordered;
-import com.android.tools.r8.utils.structural.StructuralItem;
-import com.android.tools.r8.utils.structural.StructuralMapping;
+import com.android.tools.r8.utils.structural.RepresentativeMap;
 import com.android.tools.r8.utils.structural.StructuralSpecification;
 import com.google.common.collect.ImmutableList;
+import com.google.common.hash.Hasher;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
 import java.util.ArrayList;
@@ -93,8 +95,7 @@
 import java.util.function.IntPredicate;
 import org.objectweb.asm.Opcodes;
 
-public class DexEncodedMethod extends DexEncodedMember<DexEncodedMethod, DexMethod>
-    implements StructuralItem<DexEncodedMethod> {
+public class DexEncodedMethod extends DexEncodedMember<DexEncodedMethod, DexMethod> {
 
   public static final String CONFIGURATION_DEBUGGING_PREFIX = "Shaking error: Missing method in ";
 
@@ -333,16 +334,6 @@
     return deprecated;
   }
 
-  @Override
-  public DexEncodedMethod self() {
-    return this;
-  }
-
-  @Override
-  public StructuralMapping<DexEncodedMethod> getStructuralMapping() {
-    return DexEncodedMethod::syntheticSpecify;
-  }
-
   // Visitor specifying the structure of the method with respect to its "synthetic" content.
   // TODO(b/171867022): Generalize this so that it determines any method in full.
   private static void syntheticSpecify(StructuralSpecification<DexEncodedMethod, ?> spec) {
@@ -361,12 +352,28 @@
             DexEncodedMethod::hashCodeObject);
   }
 
+  public void hashSyntheticContent(Hasher hasher, RepresentativeMap map) {
+    HashingVisitorWithTypeEquivalence.run(this, hasher, map, DexEncodedMethod::syntheticSpecify);
+  }
+
+  public boolean isSyntheticContentEqual(DexEncodedMethod other) {
+    return syntheticCompareTo(other) == 0;
+  }
+
+  public int syntheticCompareTo(DexEncodedMethod other) {
+    // Consider the holder types to be equivalent, using the holder of this method as the
+    // representative.
+    RepresentativeMap map = t -> t == other.getHolderType() ? getHolderType() : t;
+    return CompareToVisitorWithTypeEquivalence.run(
+        this, other, map, DexEncodedMethod::syntheticSpecify);
+  }
+
   private static int compareCodeObject(Code code1, Code code2, CompareToVisitor visitor) {
     if (code1.isCfCode() && code2.isCfCode()) {
       return code1.asCfCode().acceptCompareTo(code2.asCfCode(), visitor);
     }
     if (code1.isDexCode() && code2.isDexCode()) {
-      return code1.asDexCode().acceptCompareTo(code2.asDexCode(), visitor);
+      return visitor.visit(code1.asDexCode(), code2.asDexCode(), DexCode::compareTo);
     }
     throw new Unreachable(
         "Unexpected attempt to compare incompatible synthetic objects: " + code1 + " and " + code2);
@@ -376,7 +383,9 @@
     if (code.isCfCode()) {
       code.asCfCode().acceptHashing(visitor);
     } else {
-      code.asDexCode().acceptHashing(visitor);
+      // TODO(b/158159959): Implement a more precise hashing on code objects.
+      assert code.isDexCode();
+      visitor.visitInt(code.hashCode());
     }
   }
 
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 687e1bc..a93000e 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -300,7 +300,6 @@
   public final DexString throwableArrayDescriptor = createString("[Ljava/lang/Throwable;");
 
   public final DexString valueString = createString("value");
-  public final DexString kindString = createString("kind");
 
   public final DexType booleanType = createStaticallyKnownType(booleanDescriptor);
   public final DexType byteType = createStaticallyKnownType(byteDescriptor);
diff --git a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
index 59db5e5..1547891 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -21,9 +21,6 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.TraversalContinuation;
 import com.android.tools.r8.utils.structural.Ordered;
-import com.android.tools.r8.utils.structural.StructuralItem;
-import com.android.tools.r8.utils.structural.StructuralMapping;
-import com.android.tools.r8.utils.structural.StructuralSpecification;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import java.util.ArrayList;
@@ -40,7 +37,7 @@
 import java.util.function.Supplier;
 
 public class DexProgramClass extends DexClass
-    implements ProgramDefinition, Supplier<DexProgramClass>, StructuralItem<DexProgramClass> {
+    implements ProgramDefinition, Supplier<DexProgramClass> {
 
   @FunctionalInterface
   public interface ChecksumSupplier {
@@ -147,36 +144,6 @@
     synthesizedDirectlyFrom.forEach(this::addSynthesizedFrom);
   }
 
-  @Override
-  public DexProgramClass self() {
-    return this;
-  }
-
-  @Override
-  public StructuralMapping<DexProgramClass> getStructuralMapping() {
-    return DexProgramClass::specify;
-  }
-
-  private static void specify(StructuralSpecification<DexProgramClass, ?> spec) {
-    spec.withItem(c -> c.type)
-        .withItem(c -> c.superType)
-        .withItem(c -> c.interfaces)
-        .withItem(c -> c.accessFlags)
-        .withNullableItem(c -> c.sourceFile)
-        .withNullableItem(c -> c.initialClassFileVersion)
-        .withBool(c -> c.deprecated)
-        .withNullableItem(DexClass::getNestHostClassAttribute)
-        .withItemCollection(DexClass::getNestMembersClassAttributes)
-        .withItem(DexDefinition::annotations)
-        // TODO(b/158159959): Make signatures structural.
-        .withAssert(c -> c.classSignature == ClassSignature.noSignature())
-        .withItemArray(c -> c.staticFields)
-        .withItemArray(c -> c.instanceFields)
-        .withItemCollection(DexClass::allMethodsSorted)
-        // TODO(b/168584485): Synthesized-from is being removed (empty for new synthetics).
-        .withAssert(c -> c.synthesizedFrom.isEmpty());
-  }
-
   public void forEachProgramField(Consumer<? super ProgramField> consumer) {
     forEachField(field -> consumer.accept(new ProgramField(this, field)));
   }
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 44f6c1a..249439c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -9,6 +9,7 @@
 import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
 import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.DISPATCH_CLASS_NAME_SUFFIX;
 import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.EMULATE_LIBRARY_CLASS_NAME_SUFFIX;
+import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
 import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_GROUP_CLASS_NAME_PREFIX;
 import static com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator.ENUM_UNBOXING_UTILITY_CLASS_SUFFIX;
 
@@ -20,7 +21,7 @@
 import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
 import com.android.tools.r8.ir.optimize.ServiceLoaderRewriter;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.structural.CompareToVisitor;
@@ -41,7 +42,7 @@
   // Bundletool is merging classes that may originate from a build with an old version of R8.
   // Allow merging of classes that use names from older versions of R8.
   private static List<String> OLD_SYNTHESIZED_NAMES =
-      ImmutableList.of("$r8$backportedMethods$utility", "$r8$java8methods$utility", "-$$Lambda$");
+      ImmutableList.of("$r8$backportedMethods$utility", "$r8$java8methods$utility");
 
   public final DexString descriptor;
   private String toStringCache = null;
@@ -299,15 +300,22 @@
   }
 
   // TODO(b/158159959): Remove usage of name-based identification.
+  public boolean isD8R8SynthesizedLambdaClassType() {
+    String name = toSourceString();
+    return name.contains(LAMBDA_CLASS_NAME_PREFIX);
+  }
+
+  // TODO(b/158159959): Remove usage of name-based identification.
   public boolean isD8R8SynthesizedClassType() {
     String name = toSourceString();
     // The synthesized classes listed here must always be unique to a program context and thus
     // never duplicated for distinct inputs.
-    return false
-        // Hygienic suffix.
-        || name.contains(COMPANION_CLASS_NAME_SUFFIX)
+    return
+    // Hygienic suffix.
+    name.contains(COMPANION_CLASS_NAME_SUFFIX)
         // New and hygienic synthesis infrastructure.
-        || SyntheticNaming.isSyntheticName(name)
+        || name.contains(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
+        || name.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
         // Only generated in core lib.
         || name.contains(EMULATE_LIBRARY_CLASS_NAME_SUFFIX)
         || name.contains(TYPE_WRAPPER_SUFFIX)
@@ -327,6 +335,7 @@
     // newer releases can be used to merge previous builds.
     return name.contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX) // Shared among enums.
         || name.contains(SyntheticArgumentClass.SYNTHETIC_CLASS_SUFFIX)
+        || name.contains(LAMBDA_CLASS_NAME_PREFIX) // Could collide.
         || name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
         || name.contains(DISPATCH_CLASS_NAME_SUFFIX) // Shared on reference.
         || name.contains(OutlineOptions.CLASS_NAME) // Global singleton.
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLens.java b/src/main/java/com/android/tools/r8/graph/GraphLens.java
index 2328408..0e3d784 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLens.java
@@ -5,6 +5,7 @@
 
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 import static com.android.tools.r8.horizontalclassmerging.ClassMerger.CLASS_ID_FIELD_NAME;
+import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
 import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_INSTANCE_FIELD_NAME;
 
 import com.android.tools.r8.errors.Unreachable;
@@ -619,7 +620,7 @@
         // that they can be mapped back to the original program.
         DexField originalField = getOriginalFieldSignature(field.getReference());
         assert originalFields.contains(originalField)
-                || isD8R8SynthesizedField(originalField, appView)
+                || isD8R8SynthesizedField(originalField, dexItemFactory)
             : "Unable to map field `"
                 + field.getReference().toSourceString()
                 + "` back to original program";
@@ -637,16 +638,16 @@
     return true;
   }
 
-  private boolean isD8R8SynthesizedField(DexField field, AppView<?> appView) {
+  private boolean isD8R8SynthesizedField(DexField field, DexItemFactory dexItemFactory) {
     // TODO(b/167947782): Should be a general check to see if the field is D8/R8 synthesized
     //  instead of relying on field names.
-    if (field.match(appView.dexItemFactory().objectMembers.clinitField)) {
+    if (field.match(dexItemFactory.objectMembers.clinitField)) {
       return true;
     }
     if (field.getName().toSourceString().equals(CLASS_ID_FIELD_NAME)) {
       return true;
     }
-    if (appView.getSyntheticItems().isSyntheticClass(field.getHolderType())
+    if (field.getHolderType().toSourceString().contains(LAMBDA_CLASS_NAME_PREFIX)
         && field.getName().toSourceString().equals(LAMBDA_INSTANCE_FIELD_NAME)) {
       return true;
     }
diff --git a/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java b/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
index c9969a6..e007f4e 100644
--- a/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
@@ -5,19 +5,12 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.naming.NamingLens;
-import com.android.tools.r8.utils.structural.StructuralItem;
-import com.android.tools.r8.utils.structural.StructuralMapping;
-import com.android.tools.r8.utils.structural.StructuralSpecification;
 import org.objectweb.asm.ClassWriter;
 
-public class NestHostClassAttribute implements StructuralItem<NestHostClassAttribute> {
+public class NestHostClassAttribute {
 
   private final DexType nestHost;
 
-  private static void specify(StructuralSpecification<NestHostClassAttribute, ?> spec) {
-    spec.withItem(a -> a.nestHost);
-  }
-
   public NestHostClassAttribute(DexType nestHost) {
     this.nestHost = nestHost;
   }
@@ -34,14 +27,4 @@
     assert nestHost != null;
     writer.visitNestHost(lens.lookupInternalName(nestHost));
   }
-
-  @Override
-  public NestHostClassAttribute self() {
-    return this;
-  }
-
-  @Override
-  public StructuralMapping<NestHostClassAttribute> getStructuralMapping() {
-    return NestHostClassAttribute::specify;
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java b/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
index 0d7c19d..f9d1a35 100644
--- a/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
@@ -5,21 +5,14 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.naming.NamingLens;
-import com.android.tools.r8.utils.structural.StructuralItem;
-import com.android.tools.r8.utils.structural.StructuralMapping;
-import com.android.tools.r8.utils.structural.StructuralSpecification;
 import java.util.Collections;
 import java.util.List;
 import org.objectweb.asm.ClassWriter;
 
-public class NestMemberClassAttribute implements StructuralItem<NestMemberClassAttribute> {
+public class NestMemberClassAttribute {
 
   private final DexType nestMember;
 
-  private static void specify(StructuralSpecification<NestMemberClassAttribute, ?> spec) {
-    spec.withItem(a -> a.nestMember);
-  }
-
   public NestMemberClassAttribute(DexType nestMember) {
     this.nestMember = nestMember;
   }
@@ -36,14 +29,4 @@
     assert nestMember != null;
     writer.visitNestMember(lens.lookupInternalName(nestMember));
   }
-
-  @Override
-  public NestMemberClassAttribute self() {
-    return this;
-  }
-
-  @Override
-  public StructuralMapping<NestMemberClassAttribute> getStructuralMapping() {
-    return NestMemberClassAttribute::specify;
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java b/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java
index c1d5981..a10db7147 100644
--- a/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java
+++ b/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java
@@ -15,7 +15,7 @@
   private final AppView<?> appView;
   private final DexItemFactory dexItemFactory;
 
-  private final Map<DexType, DexProgramClass> programClassCache = new IdentityHashMap<>();
+  private Map<DexType, DexProgramClass> newProgramClasses = null;
   private final Map<DexType, DexProgramClass> synthesizedFromClasses = new IdentityHashMap<>();
   private final Map<DexProto, DexProto> protoFixupCache = new IdentityHashMap<>();
 
@@ -53,13 +53,13 @@
   }
 
   /** Fixup a collection of classes. */
-  public List<DexProgramClass> fixupClasses(Collection<DexProgramClass> classes) {
-    List<DexProgramClass> newProgramClasses = new ArrayList<>();
+  public Collection<DexProgramClass> fixupClasses(Collection<DexProgramClass> classes) {
+    assert newProgramClasses == null;
+    newProgramClasses = new IdentityHashMap<>();
     for (DexProgramClass clazz : classes) {
-      newProgramClasses.add(
-          programClassCache.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz)));
+      newProgramClasses.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz));
     }
-    return newProgramClasses;
+    return newProgramClasses.values();
   }
 
   // Should remain private as the correctness of the fixup requires the lazy 'newProgramClasses'.
@@ -70,7 +70,7 @@
             clazz.getOriginKind(),
             clazz.getOrigin(),
             clazz.getAccessFlags(),
-            clazz.superType == null ? null : fixupType(clazz.superType),
+            fixupType(clazz.superType),
             fixupTypeList(clazz.interfaces),
             clazz.getSourceFile(),
             fixupNestHost(clazz.getNestHostClassAttribute()),
@@ -250,6 +250,7 @@
   // Should remain private as its correctness relies on the setup of 'newProgramClasses'.
   private Collection<DexProgramClass> fixupSynthesizedFrom(
       Collection<DexProgramClass> synthesizedFrom) {
+    assert newProgramClasses != null;
     if (synthesizedFrom.isEmpty()) {
       return synthesizedFrom;
     }
@@ -260,7 +261,7 @@
       //  is no longer in the application?
       Map<DexType, DexProgramClass> classes =
           appView.appInfo().definitionForWithoutExistenceAssert(clazz.getType()) != null
-              ? programClassCache
+              ? newProgramClasses
               : synthesizedFromClasses;
       DexProgramClass newClass =
           classes.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz));
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 bc20e17..e2b0e47 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
@@ -409,10 +409,11 @@
     }
   }
 
-  private void synthesizeLambdaClasses(ExecutorService executorService) throws ExecutionException {
+  private void synthesizeLambdaClasses(Builder<?> builder, ExecutorService executorService)
+      throws ExecutionException {
     if (lambdaRewriter != null) {
       assert !appView.enableWholeProgramOptimizations();
-      lambdaRewriter.finalizeLambdaDesugaringForD8(this, executorService);
+      lambdaRewriter.finalizeLambdaDesugaringForD8(builder, this, executorService);
     }
   }
 
@@ -434,7 +435,6 @@
       Flavor includeAllResources,
       ExecutorService executorService)
       throws ExecutionException {
-    assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
     if (interfaceMethodRewriter != null) {
       interfaceMethodRewriter.desugarInterfaceMethods(
           builder, includeAllResources, executorService);
@@ -522,19 +522,7 @@
     builder.setHighestSortingString(highestSortingString);
 
     desugarNestBasedAccess(builder, executor);
-
-    // Synthesize lambda classes and commit to the app in full.
-    synthesizeLambdaClasses(executor);
-    if (appView.getSyntheticItems().hasPendingSyntheticClasses()) {
-      appView.setAppInfo(
-          new AppInfo(
-              appView.appInfo().getSyntheticItems().commit(builder.build()),
-              appView.appInfo().getMainDexClasses()));
-      application = appView.appInfo().app();
-      builder = application.builder();
-      builder.setHighestSortingString(highestSortingString);
-    }
-
+    synthesizeLambdaClasses(builder, executor);
     desugarInterfaceMethods(builder, ExcludeDexResources, executor);
     synthesizeTwrCloseResourceUtilityClass(builder, executor);
     processSynthesizedJava8UtilityClasses(executor);
@@ -545,10 +533,10 @@
 
     timing.end();
 
-    application = builder.build();
+    DexApplication app = builder.build();
     appView.setAppInfo(
         new AppInfo(
-            appView.appInfo().getSyntheticItems().commit(application),
+            appView.appInfo().getSyntheticItems().commit(app),
             appView.appInfo().getMainDexClasses()));
   }
 
@@ -806,14 +794,6 @@
       appView.clearCodeRewritings();
     }
 
-    // Commit synthetics before creating a builder (otherwise the builder will not include the
-    // synthetics.)
-    if (appView.getSyntheticItems().hasPendingSyntheticClasses()) {
-      appView.setAppInfo(
-          appView
-              .appInfo()
-              .rebuildWithLiveness(appView.getSyntheticItems().commit(appView.appInfo().app())));
-    }
     // Build a new application with jumbo string info.
     Builder<?> builder = appView.appInfo().app().builder();
     builder.setHighestSortingString(highestSortingString);
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 736ff58..d6adc3c 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
@@ -33,7 +33,6 @@
 import com.android.tools.r8.ir.desugar.backports.NumericMethodRewrites;
 import com.android.tools.r8.ir.desugar.backports.ObjectsMethodRewrites;
 import com.android.tools.r8.ir.desugar.backports.OptionalMethodRewrites;
-import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
@@ -1402,7 +1401,6 @@
       return appInfo
           .getSyntheticItems()
           .createMethod(
-              SyntheticNaming.SyntheticKind.BACKPORT,
               context,
               appInfo.dexItemFactory(),
               builder ->
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index ddc6a55..bff68b1 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -48,7 +48,6 @@
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.position.MethodPosition;
 import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.IterableUtils;
@@ -301,7 +300,6 @@
                     appView
                         .getSyntheticItems()
                         .createMethod(
-                            SyntheticNaming.SyntheticKind.STATIC_INTERFACE_CALL,
                             context.getHolder(),
                             factory,
                             syntheticMethodBuilder -> {
@@ -1109,7 +1107,6 @@
       Builder<?> builder, Flavor flavour, Consumer<ProgramMethod> newSynthesizedMethodConsumer) {
     ClassProcessor processor = new ClassProcessor(appView, this, newSynthesizedMethodConsumer);
     // First we compute all desugaring *without* introducing forwarding methods.
-    assert appView.getSyntheticItems().verifyNonLegacySyntheticsAreCommitted();
     for (DexProgramClass clazz : builder.getProgramClasses()) {
       if (shouldProcess(clazz, flavour, false)) {
         if (appView.isAlreadyLibraryDesugared(clazz)) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index 4ef5436..a50581e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.errors.Unimplemented;
 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.DexAnnotationSet;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -19,8 +20,10 @@
 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.DexValue.DexValueNull;
 import com.android.tools.r8.graph.FieldAccessFlags;
+import com.android.tools.r8.graph.GenericSignature.ClassSignature;
 import com.android.tools.r8.graph.GenericSignature.FieldTypeSignature;
 import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
 import com.android.tools.r8.graph.MethodAccessFlags;
@@ -34,11 +37,18 @@
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
 import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
-import com.android.tools.r8.synthesis.SyntheticClassBuilder;
+import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.utils.OptionalBool;
+import com.google.common.base.Suppliers;
+import com.google.common.primitives.Longs;
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+import java.util.zip.CRC32;
 
 /**
  * Represents lambda class generated for a lambda descriptor in context of lambda instantiation
@@ -67,27 +77,31 @@
   final DexMethod classConstructor;
   public final DexField lambdaField;
   public final Target target;
-
-  // Considered final but is set after due to circularity in allocation.
-  private DexProgramClass clazz = null;
+  public final AtomicBoolean addToMainDexList = new AtomicBoolean(false);
+  private final Collection<DexProgramClass> synthesizedFrom = new ArrayList<>(1);
+  private final Supplier<DexProgramClass> lazyDexClass =
+      Suppliers.memoize(this::synthesizeLambdaClass); // NOTE: thread-safe.
 
   LambdaClass(
-      SyntheticClassBuilder builder,
       AppView<?> appView,
       LambdaRewriter rewriter,
       ProgramMethod accessedFrom,
+      DexType lambdaClassType,
       LambdaDescriptor descriptor) {
     assert rewriter != null;
+    assert lambdaClassType != null;
     assert descriptor != null;
-    this.type = builder.getType();
+
     this.appView = appView;
     this.rewriter = rewriter;
+    this.type = lambdaClassType;
     this.descriptor = descriptor;
 
-    DexItemFactory factory = builder.getFactory();
+    DexItemFactory factory = appView.dexItemFactory();
     DexProto constructorProto = factory.createProto(
         factory.voidType, descriptor.captures.values);
-    this.constructor = factory.createMethod(type, constructorProto, factory.constructorMethodName);
+    this.constructor =
+        factory.createMethod(lambdaClassType, constructorProto, factory.constructorMethodName);
 
     this.target = createTarget(accessedFrom);
 
@@ -95,32 +109,98 @@
     this.classConstructor =
         !stateless
             ? null
-            : factory.createMethod(type, constructorProto, factory.classConstructorMethodName);
+            : factory.createMethod(
+                lambdaClassType, constructorProto, factory.classConstructorMethodName);
     this.lambdaField =
-        !stateless ? null : factory.createField(type, type, rewriter.instanceFieldName);
-
-    // Synthesize the program class one all fields are set.
-    synthesizeLambdaClass(builder);
+        !stateless
+            ? null
+            : factory.createField(lambdaClassType, lambdaClassType, rewriter.instanceFieldName);
   }
 
-  public final DexProgramClass getLambdaProgramClass() {
-    assert clazz != null;
+  // Generate unique lambda class type for lambda descriptor and instantiation point context.
+  public static DexType createLambdaClassType(
+      AppView<?> appView, ProgramMethod accessedFrom, LambdaDescriptor match) {
+    StringBuilder lambdaClassDescriptor = new StringBuilder("L");
+
+    // We always create lambda class in the same package where it is referenced.
+    String packageDescriptor = accessedFrom.getHolderType().getPackageDescriptor();
+    if (!packageDescriptor.isEmpty()) {
+      lambdaClassDescriptor.append(packageDescriptor).append('/');
+    }
+
+    // Lambda class name prefix
+    lambdaClassDescriptor.append(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX);
+
+    // If the lambda class should match 1:1 the class it is accessed from, we
+    // just add the name of this type to make lambda class name unique.
+    // It also helps link the class lambda originated from in some cases.
+    if (match.delegatesToLambdaImplMethod() || match.needsAccessor(accessedFrom)) {
+      lambdaClassDescriptor.append(accessedFrom.getHolderType().getName()).append('$');
+    }
+
+    // Add unique lambda descriptor id
+    lambdaClassDescriptor.append(match.uniqueId).append(';');
+    return appView.dexItemFactory().createType(lambdaClassDescriptor.toString());
+  }
+
+  public final DexProgramClass getOrCreateLambdaClass() {
+    return lazyDexClass.get();
+  }
+
+  private DexProgramClass synthesizeLambdaClass() {
+    DexMethod mainMethod =
+        appView.dexItemFactory().createMethod(type, descriptor.erasedProto, descriptor.name);
+
+    DexProgramClass clazz =
+        new DexProgramClass(
+            type,
+            null,
+            new SynthesizedOrigin("lambda desugaring", getClass()),
+            // Make the synthesized class public, as it might end up being accessed from a different
+            // classloader (package private access is not allowed across classloaders, b/72538146).
+            ClassAccessFlags.fromDexAccessFlags(
+                Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
+            appView.dexItemFactory().objectType,
+            buildInterfaces(),
+            appView.dexItemFactory().createString("lambda"),
+            null,
+            Collections.emptyList(),
+            null,
+            Collections.emptyList(),
+            ClassSignature.noSignature(),
+            DexAnnotationSet.empty(),
+            synthesizeStaticFields(),
+            synthesizeInstanceFields(),
+            synthesizeDirectMethods(),
+            synthesizeVirtualMethods(mainMethod),
+            appView.dexItemFactory().getSkipNameValidationForTesting(),
+            LambdaClass::computeChecksumForSynthesizedClass);
+    appView.appInfo().addSynthesizedClass(clazz, false);
+
+    // The method addSynthesizedFrom() may be called concurrently. To avoid a Concurrent-
+    // ModificationException we must use synchronization.
+    synchronized (synthesizedFrom) {
+      synthesizedFrom.forEach(clazz::addSynthesizedFrom);
+    }
     return clazz;
   }
 
-  void setClass(DexProgramClass clazz) {
-    assert this.clazz == null;
-    assert clazz != null;
-    assert type == clazz.type;
-    this.clazz = clazz;
-  }
+  private static long computeChecksumForSynthesizedClass(DexProgramClass clazz) {
+    // Checksum of synthesized classes are compute based off the depending input. This might
+    // create false positives (ie: unchanged lambda class detected as changed even thought only
+    // an unrelated part from a synthesizedFrom class is changed).
 
-  private void synthesizeLambdaClass(SyntheticClassBuilder builder) {
-    builder.setInterfaces(descriptor.interfaces);
-    synthesizeStaticFields(builder);
-    synthesizeInstanceFields(builder);
-    synthesizeDirectMethods(builder);
-    synthesizeVirtualMethods(builder);
+    // Ideally, we should use some hashcode of the dex program class that is deterministic across
+    // compiles.
+    Collection<DexProgramClass> synthesizedFrom = clazz.getSynthesizedFrom();
+    ByteBuffer buffer = ByteBuffer.allocate(synthesizedFrom.size() * Longs.BYTES);
+    for (DexProgramClass from : synthesizedFrom) {
+      buffer.putLong(from.getChecksum());
+    }
+    CRC32 crc = new CRC32();
+    byte[] array = buffer.array();
+    crc.update(array, 0, array.length);
+    return crc.getValue();
   }
 
   final DexField getCaptureField(int index) {
@@ -136,15 +216,24 @@
     return descriptor.isStateless();
   }
 
-  // Synthesize virtual methods.
-  private void synthesizeVirtualMethods(SyntheticClassBuilder builder) {
-    DexMethod mainMethod =
-        appView.dexItemFactory().createMethod(type, descriptor.erasedProto, descriptor.name);
+  void addSynthesizedFrom(DexProgramClass clazz) {
+    assert clazz != null;
+    synchronized (synthesizedFrom) {
+      if (synthesizedFrom.add(clazz)) {
+        // The lambda class may already have been synthesized, and we therefore need to update the
+        // synthesized lambda class as well.
+        getOrCreateLambdaClass().addSynthesizedFrom(clazz);
+      }
+    }
+  }
 
-    List<DexEncodedMethod> methods = new ArrayList<>(1 + descriptor.bridges.size());
+  // Synthesize virtual methods.
+  private DexEncodedMethod[] synthesizeVirtualMethods(DexMethod mainMethod) {
+    DexEncodedMethod[] methods = new DexEncodedMethod[1 + descriptor.bridges.size()];
+    int index = 0;
 
     // Synthesize main method.
-    methods.add(
+    methods[index++] =
         new DexEncodedMethod(
             mainMethod,
             MethodAccessFlags.fromSharedAccessFlags(
@@ -153,13 +242,13 @@
             DexAnnotationSet.empty(),
             ParameterAnnotationsList.empty(),
             LambdaMainMethodSourceCode.build(this, mainMethod),
-            true));
+            true);
 
     // Synthesize bridge methods.
     for (DexProto bridgeProto : descriptor.bridges) {
       DexMethod bridgeMethod =
           appView.dexItemFactory().createMethod(type, bridgeProto, descriptor.name);
-      methods.add(
+      methods[index++] =
           new DexEncodedMethod(
               bridgeMethod,
               MethodAccessFlags.fromSharedAccessFlags(
@@ -172,18 +261,18 @@
               DexAnnotationSet.empty(),
               ParameterAnnotationsList.empty(),
               LambdaBridgeMethodSourceCode.build(this, bridgeMethod, mainMethod),
-              true));
+              true);
     }
-    builder.setVirtualMethods(methods);
+    return methods;
   }
 
   // Synthesize direct methods.
-  private void synthesizeDirectMethods(SyntheticClassBuilder builder) {
+  private DexEncodedMethod[] synthesizeDirectMethods() {
     boolean stateless = isStateless();
-    List<DexEncodedMethod> methods = new ArrayList<>(stateless ? 2 : 1);
+    DexEncodedMethod[] methods = new DexEncodedMethod[stateless ? 2 : 1];
 
     // Constructor.
-    methods.add(
+    methods[0] =
         new DexEncodedMethod(
             constructor,
             MethodAccessFlags.fromSharedAccessFlags(
@@ -194,11 +283,11 @@
             DexAnnotationSet.empty(),
             ParameterAnnotationsList.empty(),
             LambdaConstructorSourceCode.build(this),
-            true));
+            true);
 
     // Class constructor for stateless lambda classes.
     if (stateless) {
-      methods.add(
+      methods[1] =
           new DexEncodedMethod(
               classConstructor,
               MethodAccessFlags.fromSharedAccessFlags(
@@ -207,50 +296,61 @@
               DexAnnotationSet.empty(),
               ParameterAnnotationsList.empty(),
               LambdaClassConstructorSourceCode.build(this),
-              true));
-      feedback.classInitializerMayBePostponed(methods.get(1));
+              true);
+      feedback.classInitializerMayBePostponed(methods[1]);
     }
-    builder.setDirectMethods(methods);
+    return methods;
   }
 
   // Synthesize instance fields to represent captured values.
-  private void synthesizeInstanceFields(SyntheticClassBuilder builder) {
+  private DexEncodedField[] synthesizeInstanceFields() {
     DexType[] fieldTypes = descriptor.captures.values;
     int fieldCount = fieldTypes.length;
-    List<DexEncodedField> fields = new ArrayList<>(fieldCount);
+    DexEncodedField[] fields = new DexEncodedField[fieldCount];
     for (int i = 0; i < fieldCount; i++) {
       FieldAccessFlags accessFlags =
           FieldAccessFlags.fromSharedAccessFlags(
               Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC);
-      fields.add(
+      fields[i] =
           new DexEncodedField(
               getCaptureField(i),
               accessFlags,
               FieldTypeSignature.noSignature(),
               DexAnnotationSet.empty(),
-              null));
+              null);
     }
-    builder.setInstanceFields(fields);
+    return fields;
   }
 
   // Synthesize static fields to represent singleton instance.
-  private void synthesizeStaticFields(SyntheticClassBuilder builder) {
-    if (isStateless()) {
-      // Create instance field for stateless lambda.
-      assert this.lambdaField != null;
-      builder.setStaticFields(
-          Collections.singletonList(
-              new DexEncodedField(
-                  this.lambdaField,
-                  FieldAccessFlags.fromSharedAccessFlags(
-                      Constants.ACC_PUBLIC
-                          | Constants.ACC_FINAL
-                          | Constants.ACC_SYNTHETIC
-                          | Constants.ACC_STATIC),
-                  FieldTypeSignature.noSignature(),
-                  DexAnnotationSet.empty(),
-                  DexValueNull.NULL)));
+  private DexEncodedField[] synthesizeStaticFields() {
+    if (!isStateless()) {
+      return DexEncodedField.EMPTY_ARRAY;
     }
+
+    // Create instance field for stateless lambda.
+    assert this.lambdaField != null;
+    DexEncodedField[] fields = new DexEncodedField[1];
+    fields[0] =
+        new DexEncodedField(
+            this.lambdaField,
+            FieldAccessFlags.fromSharedAccessFlags(
+                Constants.ACC_PUBLIC
+                    | Constants.ACC_FINAL
+                    | Constants.ACC_SYNTHETIC
+                    | Constants.ACC_STATIC),
+            FieldTypeSignature.noSignature(),
+            DexAnnotationSet.empty(),
+            DexValueNull.NULL);
+    return fields;
+  }
+
+  // Build a list of implemented interfaces.
+  private DexTypeList buildInterfaces() {
+    List<DexType> interfaces = descriptor.interfaces;
+    return interfaces.isEmpty()
+        ? DexTypeList.empty()
+        : new DexTypeList(interfaces.toArray(DexType.EMPTY_ARRAY));
   }
 
   // Creates a delegation target for this particular lambda class. Note that we
@@ -543,15 +643,11 @@
                         newMethod.getCode(), callTarget.getArity(), appView);
                     return newMethod;
                   });
-      if (replacement != null) {
-        return new ProgramMethod(implMethodHolder, replacement);
-      }
-      // The method might already have been moved by another invoke-dynamic targeting it.
-      // If so, it must be defined on the holder.
-      ProgramMethod modified = implMethodHolder.lookupProgramMethod(callTarget);
-      assert modified != null;
-      assert modified.getDefinition().isNonPrivateVirtualMethod();
-      return modified;
+
+      assert replacement != null
+          : "Unexpected failure to find direct lambda target for: " + implMethod.qualifiedName();
+
+      return new ProgramMethod(implMethodHolder, replacement);
     }
   }
 
@@ -617,15 +713,7 @@
                     rewriter.forcefullyMoveMethod(encodedMethod.method, callTarget);
                     return newMethod;
                   });
-      if (replacement != null) {
-        return new ProgramMethod(implMethodHolder, replacement);
-      }
-      // The method might already have been moved by another invoke-dynamic targeting it.
-      // If so, it must be defined on the holder.
-      ProgramMethod modified = implMethodHolder.lookupProgramMethod(callTarget);
-      assert modified != null;
-      assert modified.getDefinition().isNonPrivateVirtualMethod();
-      return modified;
+      return new ProgramMethod(implMethodHolder, replacement);
     }
 
     private ProgramMethod createSyntheticAccessor(
@@ -691,12 +779,11 @@
               AccessorMethodSourceCode.build(LambdaClass.this, callTarget),
               true);
 
-      ProgramMethod existing = accessorClass.lookupProgramMethod(callTarget);
-      // Another lambda call sites may already have created an accessor.
-      if (existing != null) {
-        return existing;
+      // We may arrive here concurrently so we need must update the methods of the class atomically.
+      synchronized (accessorClass) {
+        accessorClass.addDirectMethod(accessorEncodedMethod);
       }
-      accessorClass.addDirectMethod(accessorEncodedMethod);
+
       return new ProgramMethod(accessorClass, accessorEncodedMethod);
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index ee459b4..f464fdd 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.DexApplication.Builder;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -27,10 +28,19 @@
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.type.Nullability;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.InvokeCustom;
+import com.android.tools.r8.ir.code.InvokeDirect;
+import com.android.tools.r8.ir.code.NewInstance;
+import com.android.tools.r8.ir.code.StaticGet;
+import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.synthesis.SyntheticNaming;
-import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
 import com.android.tools.r8.utils.collections.BidirectionalOneToOneMap;
 import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
@@ -39,8 +49,9 @@
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
+import java.util.IdentityHashMap;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
@@ -58,6 +69,7 @@
 public class LambdaRewriter {
 
   // Public for testing.
+  public static final String LAMBDA_CLASS_NAME_PREFIX = "-$$Lambda$";
   public static final String LAMBDA_GROUP_CLASS_NAME_PREFIX = "-$$LambdaGroup$";
   static final String EXPECTED_LAMBDA_METHOD_PREFIX = "lambda$";
   public static final String LAMBDA_INSTANCE_FIELD_NAME = "INSTANCE";
@@ -69,10 +81,16 @@
   private final LambdaRewriterLens.Builder lensBuilder = LambdaRewriterLens.builder();
   private final Set<DexMethod> forcefullyMovedMethods = Sets.newIdentityHashSet();
 
+  // Maps call sites seen so far to inferred lambda descriptor. It is intended
+  // to help avoid re-matching call sites we already seen. Note that same call
+  // site may match one or several lambda classes.
+  //
+  // NOTE: synchronize concurrent access on `knownCallSites`.
+  private final Map<DexCallSite, LambdaDescriptor> knownCallSites = new IdentityHashMap<>();
   // Maps lambda class type into lambda class representation. Since lambda class
   // type uniquely defines lambda class, effectively canonicalizes lambda classes.
   // NOTE: synchronize concurrent access on `knownLambdaClasses`.
-  private final List<LambdaClass> knownLambdaClasses = new ArrayList<>();
+  private final Map<DexType, LambdaClass> knownLambdaClasses = new IdentityHashMap<>();
 
   public LambdaRewriter(AppView<?> appView) {
     this.appView = appView;
@@ -120,7 +138,7 @@
           if (descriptor == null) {
             return null;
           }
-          return createLambdaClass(descriptor, method);
+          return getOrCreateLambdaClass(descriptor, method);
         });
   }
 
@@ -191,10 +209,16 @@
   }
 
   /** Generates lambda classes and adds them to the builder. */
-  public void finalizeLambdaDesugaringForD8(IRConverter converter, ExecutorService executorService)
+  public void finalizeLambdaDesugaringForD8(
+      Builder<?> builder, IRConverter converter, ExecutorService executorService)
       throws ExecutionException {
     synthesizeAccessibilityBridgesForLambdaClassesD8(
-        knownLambdaClasses, converter, executorService);
+        knownLambdaClasses.values(), converter, executorService);
+    for (LambdaClass lambdaClass : knownLambdaClasses.values()) {
+      DexProgramClass synthesizedClass = lambdaClass.getOrCreateLambdaClass();
+      appView.appInfo().addSynthesizedClass(synthesizedClass, lambdaClass.addToMainDexList.get());
+      builder.addSynthesizedClass(synthesizedClass);
+    }
     fixup();
     optimizeSynthesizedClasses(converter, executorService);
   }
@@ -202,35 +226,183 @@
   private void optimizeSynthesizedClasses(IRConverter converter, ExecutorService executorService)
       throws ExecutionException {
     converter.optimizeSynthesizedClasses(
-        knownLambdaClasses.stream()
-            .map(LambdaClass::getLambdaProgramClass)
+        knownLambdaClasses.values().stream()
+            .map(LambdaClass::getOrCreateLambdaClass)
             .collect(ImmutableSet.toImmutableSet()),
         executorService);
   }
 
-  // Creates a lambda class corresponding to the lambda descriptor and context.
-  public LambdaClass createLambdaClass(LambdaDescriptor descriptor, ProgramMethod accessedFrom) {
-    Box<LambdaClass> box = new Box<>();
-    DexProgramClass clazz =
-        appView
-            .getSyntheticItems()
-            .createClass(
-                SyntheticNaming.SyntheticKind.LAMBDA,
-                accessedFrom.getHolder(),
-                appView.dexItemFactory(),
-                builder ->
-                    box.set(new LambdaClass(builder, appView, this, accessedFrom, descriptor)));
-    // Immediately set the actual program class on the lambda.
-    LambdaClass lambdaClass = box.get();
-    lambdaClass.setClass(clazz);
-    synchronized (knownLambdaClasses) {
-      knownLambdaClasses.add(lambdaClass);
+  // Matches invoke-custom instruction operands to infer lambda descriptor
+  // corresponding to this lambda invocation point.
+  //
+  // Returns the lambda descriptor or `MATCH_FAILED`.
+  private LambdaDescriptor inferLambdaDescriptor(DexCallSite callSite, ProgramMethod context) {
+    // We check the map before and after inferring lambda descriptor to minimize time
+    // spent in synchronized block. As a result we may throw away calculated descriptor
+    // in rare case when another thread has same call site processed concurrently,
+    // but this is a low price to pay comparing to making whole method synchronous.
+    LambdaDescriptor descriptor = getKnown(knownCallSites, callSite);
+    return descriptor != null
+        ? descriptor
+        : putIfAbsent(
+            knownCallSites,
+            callSite,
+            LambdaDescriptor.infer(callSite, appView.appInfoForDesugaring(), context));
+  }
+
+  // Returns a lambda class corresponding to the lambda descriptor and context,
+  // creates the class if it does not yet exist.
+  public LambdaClass getOrCreateLambdaClass(
+      LambdaDescriptor descriptor, ProgramMethod accessedFrom) {
+    DexType lambdaClassType = LambdaClass.createLambdaClassType(appView, accessedFrom, descriptor);
+    // We check the map twice to to minimize time spent in synchronized block.
+    LambdaClass lambdaClass = getKnown(knownLambdaClasses, lambdaClassType);
+    if (lambdaClass == null) {
+      lambdaClass =
+          putIfAbsent(
+              knownLambdaClasses,
+              lambdaClassType,
+              new LambdaClass(appView, this, accessedFrom, lambdaClassType, descriptor));
+      if (appView.options().isDesugaredLibraryCompilation()) {
+        DexType rewrittenType =
+            appView.rewritePrefix.rewrittenType(accessedFrom.getHolderType(), appView);
+        if (rewrittenType == null) {
+          rewrittenType =
+              appView
+                  .options()
+                  .desugaredLibraryConfiguration
+                  .getEmulateLibraryInterface()
+                  .get(accessedFrom.getHolderType());
+        }
+        if (rewrittenType != null) {
+          addRewritingPrefix(accessedFrom, rewrittenType, lambdaClassType);
+        }
+      }
+    }
+    lambdaClass.addSynthesizedFrom(accessedFrom.getHolder());
+    if (appView.appInfo().getMainDexClasses().contains(accessedFrom.getHolder())) {
+      lambdaClass.addToMainDexList.set(true);
     }
     return lambdaClass;
   }
 
-  public Collection<LambdaClass> getKnownLambdaClasses() {
-    return Collections.unmodifiableList(knownLambdaClasses);
+  private LambdaClass getKnownLambdaClass(LambdaDescriptor descriptor, ProgramMethod accessedFrom) {
+    DexType lambdaClassType = LambdaClass.createLambdaClassType(appView, accessedFrom, descriptor);
+    return getKnown(knownLambdaClasses, lambdaClassType);
+  }
+
+  private void addRewritingPrefix(
+      ProgramMethod context, DexType rewritten, DexType lambdaClassType) {
+    String javaName = lambdaClassType.toString();
+    String typeString = context.getHolderType().toString();
+    String actualPrefix = typeString.substring(0, typeString.lastIndexOf('.'));
+    String rewrittenString = rewritten.toString();
+    String actualRewrittenPrefix = rewrittenString.substring(0, rewrittenString.lastIndexOf('.'));
+    assert javaName.startsWith(actualPrefix);
+    appView.rewritePrefix.rewriteType(
+        lambdaClassType,
+        appView
+            .dexItemFactory()
+            .createType(
+                DescriptorUtils.javaTypeToDescriptor(
+                    actualRewrittenPrefix + javaName.substring(actualPrefix.length()))));
+  }
+
+  private static <K, V> V getKnown(Map<K, V> map, K key) {
+    synchronized (map) {
+      return map.get(key);
+    }
+  }
+
+  private static <K, V> V putIfAbsent(Map<K, V> map, K key, V value) {
+    synchronized (map) {
+      V known = map.get(key);
+      if (known != null) {
+        return known;
+      }
+      map.put(key, value);
+      return value;
+    }
+  }
+
+  // Patches invoke-custom instruction to create or get an instance
+  // of the generated lambda class.
+  private void patchInstruction(
+      InvokeCustom invoke,
+      LambdaClass lambdaClass,
+      IRCode code,
+      ListIterator<BasicBlock> blocks,
+      InstructionListIterator instructions,
+      Set<Value> affectedValues) {
+    assert lambdaClass != null;
+    assert instructions != null;
+
+    // The value representing new lambda instance: we reuse the
+    // value from the original invoke-custom instruction, and thus
+    // all its usages.
+    Value lambdaInstanceValue = invoke.outValue();
+    if (lambdaInstanceValue == null) {
+      // The out value might be empty in case it was optimized out.
+      lambdaInstanceValue =
+          code.createValue(
+              TypeElement.fromDexType(lambdaClass.type, Nullability.maybeNull(), appView));
+    } else {
+      affectedValues.add(lambdaInstanceValue);
+    }
+
+    // For stateless lambdas we replace InvokeCustom instruction with StaticGet
+    // reading the value of INSTANCE field created for singleton lambda class.
+    if (lambdaClass.isStateless()) {
+      instructions.replaceCurrentInstruction(
+          new StaticGet(lambdaInstanceValue, lambdaClass.lambdaField));
+      // Note that since we replace one throwing operation with another we don't need
+      // to have any special handling for catch handlers.
+      return;
+    }
+
+    // For stateful lambdas we always create a new instance since we need to pass
+    // captured values to the constructor.
+    //
+    // We replace InvokeCustom instruction with a new NewInstance instruction
+    // instantiating lambda followed by InvokeDirect instruction calling a
+    // constructor on it.
+    //
+    //    original:
+    //      Invoke-Custom rResult <- { rArg0, rArg1, ... }; call site: ...
+    //
+    //    result:
+    //      NewInstance   rResult <-  LambdaClass
+    //      Invoke-Direct { rResult, rArg0, rArg1, ... }; method: void LambdaClass.<init>(...)
+    lambdaInstanceValue.setType(
+        lambdaInstanceValue.getType().asReferenceType().asDefinitelyNotNull());
+    NewInstance newInstance = new NewInstance(lambdaClass.type, lambdaInstanceValue);
+    instructions.replaceCurrentInstruction(newInstance);
+
+    List<Value> arguments = new ArrayList<>();
+    arguments.add(lambdaInstanceValue);
+    arguments.addAll(invoke.arguments()); // Optional captures.
+    InvokeDirect constructorCall =
+        new InvokeDirect(lambdaClass.constructor, null /* no return value */, arguments);
+    instructions.add(constructorCall);
+    constructorCall.setPosition(newInstance.getPosition());
+
+    // If we don't have catch handlers we are done.
+    if (!constructorCall.getBlock().hasCatchHandlers()) {
+      return;
+    }
+
+    // Move the iterator back to position it between the two instructions, split
+    // the block between the two instructions, and copy the catch handlers.
+    instructions.previous();
+    assert instructions.peekNext().isInvokeDirect();
+    BasicBlock currentBlock = newInstance.getBlock();
+    BasicBlock nextBlock = instructions.split(code, blocks);
+    assert !instructions.hasNext();
+    nextBlock.copyCatchHandlers(code, blocks, currentBlock, appView.options());
+  }
+
+  public Map<DexType, LambdaClass> getKnownLambdaClasses() {
+    return knownLambdaClasses;
   }
 
   public NestedGraphLens fixup() {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java b/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java
index a972b39..1b55f13 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java
@@ -15,7 +15,6 @@
 import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.optimize.templates.CfUtilityMethodsForCodeOptimizations;
 import com.android.tools.r8.synthesis.SyntheticItems;
-import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.utils.InternalOptions;
 
 public class UtilityMethodsForCodeOptimizations {
@@ -32,7 +31,6 @@
     SyntheticItems syntheticItems = appView.getSyntheticItems();
     ProgramMethod syntheticMethod =
         syntheticItems.createMethod(
-            SyntheticNaming.SyntheticKind.TO_STRING_IF_NOT_NULL,
             context,
             dexItemFactory,
             builder ->
@@ -62,7 +60,6 @@
     SyntheticItems syntheticItems = appView.getSyntheticItems();
     ProgramMethod syntheticMethod =
         syntheticItems.createMethod(
-            SyntheticNaming.SyntheticKind.THROW_CCE_IF_NOT_NULL,
             context,
             dexItemFactory,
             builder ->
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..b5dfee6 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
@@ -1090,18 +1090,10 @@
       } else if (classInitializerSideEffect.canBePostponed()) {
         feedback.classInitializerMayBePostponed(method);
       } else {
-        assert options.debug
-                || appView
-                    .getSyntheticItems()
-                    .verifySyntheticLambdaProperty(
-                        context.getHolder(),
-                        lambdaClass ->
-                            appView.appInfo().hasPinnedInstanceInitializer(lambdaClass.getType())
-                                || appView
-                                    .options()
-                                    .horizontalClassMergerOptions()
-                                    .isJavaLambdaMergingEnabled(),
-                        nonLambdaClass -> true)
+        assert !context.getHolderType().isD8R8SynthesizedLambdaClassType()
+                || options.debug
+                || appView.appInfo().hasPinnedInstanceInitializer(context.getHolderType())
+                || appView.options().horizontalClassMergerOptions().isJavaLambdaMergingEnabled()
             : "Unexpected observable side effects from lambda `" + context.toSourceString() + "`";
       }
       return;
diff --git a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
index 2ed2706..25688ce 100644
--- a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
@@ -41,7 +41,7 @@
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.naming.ProguardMapSupplier;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.AsmUtils;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions;
@@ -125,7 +125,7 @@
         marker.isRelocator() ? Optional.empty() : Optional.of(marker.toString());
     LensCodeRewriterUtils rewriter = new LensCodeRewriterUtils(appView);
     for (DexProgramClass clazz : application.classes()) {
-      assert SyntheticNaming.verifyNotInternalSynthetic(clazz.getType());
+      assert SyntheticItems.verifyNotInternalSynthetic(clazz.getType());
       if (clazz.getSynthesizedFrom().isEmpty()
           || options.isDesugaredLibraryCompilation()
           || options.cfToCfDesugar) {
@@ -201,7 +201,6 @@
     for (int i = 0; i < clazz.interfaces.values.length; i++) {
       interfaces[i] = namingLens.lookupInternalName(clazz.interfaces.values[i]);
     }
-    SyntheticNaming.verifyNotInternalSynthetic(name);
     writer.visit(version.raw(), access, name, signature, superName, interfaces);
     writeAnnotations(writer::visitAnnotation, clazz.annotations().annotations);
     ImmutableMap<DexString, DexValue> defaults = getAnnotationDefaults(clazz.annotations());
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index 49cff50..e12ec89 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -268,7 +268,7 @@
     this.switchMaps = switchMaps;
     this.lockCandidates = lockCandidates;
     this.initClassReferences = initClassReferences;
-    assert verify();
+    verify();
   }
 
   private AppInfoWithLiveness(AppInfoWithLiveness previous, CommittedItems committedItems) {
@@ -365,11 +365,10 @@
         previous.initClassReferences);
   }
 
-  private boolean verify() {
+  private void verify() {
     assert keepInfo.verifyPinnedTypesAreLive(liveTypes);
     assert objectAllocationInfoCollection.verifyAllocatedTypesAreLive(
         liveTypes, getMissingClasses(), this);
-    return true;
   }
 
   private static KeepInfoCollection extendPinnedItems(
@@ -454,7 +453,7 @@
     this.lockCandidates = previous.lockCandidates;
     this.initClassReferences = previous.initClassReferences;
     previous.markObsolete();
-    assert verify();
+    verify();
   }
 
   public static AppInfoWithLivenessModifier modifier() {
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 42211d0..72d5af2 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -921,7 +921,7 @@
       assert contextMethod.getCode().isCfCode() : "Unexpected input type with lambdas";
       CfCode code = contextMethod.getCode().asCfCode();
       if (code != null) {
-        LambdaClass lambdaClass = lambdaRewriter.createLambdaClass(descriptor, context);
+        LambdaClass lambdaClass = lambdaRewriter.getOrCreateLambdaClass(descriptor, context);
         lambdaClasses.put(lambdaClass.type, new Pair<>(lambdaClass, context));
         lambdaCallSites
             .computeIfAbsent(context, k -> new IdentityHashMap<>())
@@ -3037,9 +3037,13 @@
       return empty;
     }
 
-    void addInstantiatedClass(DexProgramClass clazz, ProgramMethod context) {
+    void addInstantiatedClass(
+        DexProgramClass clazz, ProgramMethod context, boolean isMainDexClass) {
       assert !syntheticInstantiations.containsKey(clazz.type);
       syntheticInstantiations.put(clazz.type, new Pair<>(clazz, context));
+      if (isMainDexClass) {
+        mainDexTypes.add(clazz);
+      }
     }
 
     void addClasspathClass(DexClasspathClass clazz) {
@@ -3061,6 +3065,10 @@
 
     void amendApplication(Builder appBuilder) {
       assert !isEmpty();
+      for (Pair<DexProgramClass, ProgramMethod> clazzAndContext :
+          syntheticInstantiations.values()) {
+        appBuilder.addProgramClass(clazzAndContext.getFirst());
+      }
       appBuilder.addClasspathClasses(syntheticClasspathClasses.values());
     }
 
@@ -3184,8 +3192,8 @@
       // Add all desugared classes to the application, main-dex list, and mark them instantiated.
       LambdaClass lambdaClass = lambdaClassAndContext.getFirst();
       ProgramMethod context = lambdaClassAndContext.getSecond();
-      DexProgramClass programClass = lambdaClass.getLambdaProgramClass();
-      additions.addInstantiatedClass(programClass, context);
+      DexProgramClass programClass = lambdaClass.getOrCreateLambdaClass();
+      additions.addInstantiatedClass(programClass, context, lambdaClass.addToMainDexList.get());
       // Mark the instance constructor targeted and live.
       DexEncodedMethod constructor = programClass.lookupDirectMethod(lambdaClass.constructor);
       KeepReason reason = KeepReason.instantiatedIn(context);
@@ -3340,9 +3348,10 @@
     lambdaRewriter
         .getKnownLambdaClasses()
         .forEach(
-            lambda -> {
-              DexProgramClass synthesizedClass = lambda.getLambdaProgramClass();
+            (type, lambda) -> {
+              DexProgramClass synthesizedClass = lambda.getOrCreateLambdaClass();
               assert synthesizedClass != null;
+              assert synthesizedClass == appInfo().definitionForWithoutExistenceAssert(type);
               assert liveTypes.contains(synthesizedClass);
               if (synthesizedClass == null) {
                 return;
diff --git a/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
index e60dfa3..424fd8d 100644
--- a/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
@@ -7,6 +7,8 @@
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexType;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import java.util.Collection;
 import java.util.function.Function;
 
@@ -26,19 +28,23 @@
   // Immutable package accessible fields to allow SyntheticItems creation.
   final DexApplication application;
   final int nextSyntheticId;
-  final CommittedSyntheticsCollection committed;
+  final ImmutableSet<DexType> legacySyntheticTypes;
+  final ImmutableMap<DexType, SyntheticReference> syntheticItems;
   final ImmutableList<DexType> committedTypes;
 
   CommittedItems(
       int nextSyntheticId,
       DexApplication application,
-      CommittedSyntheticsCollection committed,
+      ImmutableSet<DexType> legacySyntheticTypes,
+      ImmutableMap<DexType, SyntheticReference> syntheticItems,
       ImmutableList<DexType> committedTypes) {
+    assert verifyTypesAreInApp(application, legacySyntheticTypes);
+    assert verifyTypesAreInApp(application, syntheticItems.keySet());
     this.nextSyntheticId = nextSyntheticId;
     this.application = application;
-    this.committed = committed;
+    this.legacySyntheticTypes = legacySyntheticTypes;
+    this.syntheticItems = syntheticItems;
     this.committedTypes = committedTypes;
-    committed.verifyTypesAreInApp(application);
   }
 
   // Conversion to a mutable synthetic items collection. Should only be used in AppInfo creation.
@@ -56,7 +62,7 @@
 
   @Deprecated
   public Collection<DexType> getLegacySyntheticTypes() {
-    return committed.getLegacyTypes();
+    return legacySyntheticTypes;
   }
 
   @Override
@@ -64,4 +70,11 @@
     // All synthetic types are committed to the application so lookup is just the base lookup.
     return baseDefinitionFor.apply(type);
   }
+
+  private static boolean verifyTypesAreInApp(DexApplication app, Collection<DexType> types) {
+    for (DexType type : types) {
+      assert app.programDefinitionFor(type) != null : "Missing synthetic: " + type;
+    }
+    return true;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java b/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
deleted file mode 100644
index 582a39a..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
+++ /dev/null
@@ -1,243 +0,0 @@
-// Copyright (c) 2020, 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.synthesis;
-
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
-import com.android.tools.r8.graph.PrunedItems;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.Consumer;
-
-/**
- * Immutable collection of committed items.
- *
- * <p>This structure is to make it easier to pass the items from SyntheticItems to CommittedItems
- * and back while also providing a builder for updating the committed synthetics.
- */
-class CommittedSyntheticsCollection {
-
-  static class Builder {
-    private final CommittedSyntheticsCollection parent;
-    private ImmutableMap.Builder<DexType, SyntheticClassReference> newNonLegacyClasses = null;
-    private ImmutableMap.Builder<DexType, SyntheticMethodReference> newNonLegacyMethods = null;
-    private ImmutableSet.Builder<DexType> newLegacyClasses = null;
-
-    public Builder(CommittedSyntheticsCollection parent) {
-      this.parent = parent;
-    }
-
-    public Builder addItem(SyntheticDefinition<?, ?> definition) {
-      definition.toReference().apply(this::addNonLegacyMethod, this::addNonLegacyClass);
-      return this;
-    }
-
-    public Builder addNonLegacyClass(SyntheticClassDefinition definition) {
-      return addNonLegacyClass(definition.toReference());
-    }
-
-    public Builder addNonLegacyClass(SyntheticClassReference reference) {
-      if (newNonLegacyClasses == null) {
-        newNonLegacyClasses = ImmutableMap.builder();
-      }
-      newNonLegacyClasses.put(reference.getHolder(), reference);
-      return this;
-    }
-
-    public Builder addNonLegacyMethod(SyntheticMethodDefinition definition) {
-      return addNonLegacyMethod(definition.toReference());
-    }
-
-    public Builder addNonLegacyMethod(SyntheticMethodReference reference) {
-      if (newNonLegacyMethods == null) {
-        newNonLegacyMethods = ImmutableMap.builder();
-      }
-      newNonLegacyMethods.put(reference.getHolder(), reference);
-      return this;
-    }
-
-    public Builder addLegacyClasses(Collection<DexProgramClass> classes) {
-      if (newLegacyClasses == null) {
-        newLegacyClasses = ImmutableSet.builder();
-      }
-      classes.forEach(c -> newLegacyClasses.add(c.getType()));
-      return this;
-    }
-
-    public Builder addLegacyClass(DexType type) {
-      if (newLegacyClasses == null) {
-        newLegacyClasses = ImmutableSet.builder();
-      }
-      newLegacyClasses.add(type);
-      return this;
-    }
-
-    public CommittedSyntheticsCollection build() {
-      if (newNonLegacyClasses == null && newNonLegacyMethods == null && newLegacyClasses == null) {
-        return parent;
-      }
-      ImmutableMap<DexType, SyntheticClassReference> allNonLegacyClasses =
-          newNonLegacyClasses == null
-              ? parent.nonLegacyClasses
-              : newNonLegacyClasses.putAll(parent.nonLegacyClasses).build();
-      ImmutableMap<DexType, SyntheticMethodReference> allNonLegacyMethods =
-          newNonLegacyMethods == null
-              ? parent.nonLegacyMethods
-              : newNonLegacyMethods.putAll(parent.nonLegacyMethods).build();
-      ImmutableSet<DexType> allLegacyClasses =
-          newLegacyClasses == null
-              ? parent.legacyTypes
-              : newLegacyClasses.addAll(parent.legacyTypes).build();
-      return new CommittedSyntheticsCollection(
-          allLegacyClasses, allNonLegacyMethods, allNonLegacyClasses);
-    }
-  }
-
-  private static final CommittedSyntheticsCollection EMPTY =
-      new CommittedSyntheticsCollection(ImmutableSet.of(), ImmutableMap.of(), ImmutableMap.of());
-
-  /**
-   * Immutable set of synthetic types in the application (eg, committed).
-   *
-   * <p>TODO(b/158159959): Remove legacy support.
-   */
-  private final ImmutableSet<DexType> legacyTypes;
-
-  /** Mapping from synthetic type to its synthetic method item description. */
-  private final ImmutableMap<DexType, SyntheticMethodReference> nonLegacyMethods;
-
-  /** Mapping from synthetic type to its synthetic class item description. */
-  private final ImmutableMap<DexType, SyntheticClassReference> nonLegacyClasses;
-
-  public CommittedSyntheticsCollection(
-      ImmutableSet<DexType> legacyTypes,
-      ImmutableMap<DexType, SyntheticMethodReference> nonLegacyMethods,
-      ImmutableMap<DexType, SyntheticClassReference> nonLegacyClasses) {
-    this.legacyTypes = legacyTypes;
-    this.nonLegacyMethods = nonLegacyMethods;
-    this.nonLegacyClasses = nonLegacyClasses;
-    assert legacyTypes.size() + nonLegacyMethods.size() + nonLegacyClasses.size()
-        == Sets.union(Sets.union(nonLegacyMethods.keySet(), nonLegacyClasses.keySet()), legacyTypes)
-            .size();
-  }
-
-  public static CommittedSyntheticsCollection empty() {
-    return EMPTY;
-  }
-
-  Builder builder() {
-    return new Builder(this);
-  }
-
-  boolean isEmpty() {
-    return legacyTypes.isEmpty() && nonLegacyMethods.isEmpty() && nonLegacyClasses.isEmpty();
-  }
-
-  boolean containsType(DexType type) {
-    return containsLegacyType(type) || containsNonLegacyType(type);
-  }
-
-  public boolean containsLegacyType(DexType type) {
-    return legacyTypes.contains(type);
-  }
-
-  public boolean containsNonLegacyType(DexType type) {
-    return nonLegacyMethods.containsKey(type) || nonLegacyClasses.containsKey(type);
-  }
-
-  public ImmutableSet<DexType> getLegacyTypes() {
-    return legacyTypes;
-  }
-
-  public ImmutableMap<DexType, SyntheticMethodReference> getNonLegacyMethods() {
-    return nonLegacyMethods;
-  }
-
-  public ImmutableMap<DexType, SyntheticClassReference> getNonLegacyClasses() {
-    return nonLegacyClasses;
-  }
-
-  public SyntheticReference<?, ?> getNonLegacyItem(DexType type) {
-    SyntheticMethodReference reference = nonLegacyMethods.get(type);
-    if (reference != null) {
-      return reference;
-    }
-    return nonLegacyClasses.get(type);
-  }
-
-  public void forEachNonLegacyItem(Consumer<SyntheticReference<?, ?>> fn) {
-    nonLegacyMethods.forEach((t, r) -> fn.accept(r));
-    nonLegacyClasses.forEach((t, r) -> fn.accept(r));
-  }
-
-  CommittedSyntheticsCollection pruneItems(PrunedItems prunedItems) {
-    Set<DexType> removed = prunedItems.getNoLongerSyntheticItems();
-    if (removed.isEmpty()) {
-      return this;
-    }
-    Builder builder = CommittedSyntheticsCollection.empty().builder();
-    boolean changed = false;
-    for (DexType type : legacyTypes) {
-      if (removed.contains(type)) {
-        changed = true;
-      } else {
-        builder.addLegacyClass(type);
-      }
-    }
-    for (SyntheticMethodReference reference : nonLegacyMethods.values()) {
-      if (removed.contains(reference.getHolder())) {
-        changed = true;
-      } else {
-        builder.addNonLegacyMethod(reference);
-      }
-    }
-    for (SyntheticClassReference reference : nonLegacyClasses.values()) {
-      if (removed.contains(reference.getHolder())) {
-        changed = true;
-      } else {
-        builder.addNonLegacyClass(reference);
-      }
-    }
-    return changed ? builder.build() : this;
-  }
-
-  CommittedSyntheticsCollection rewriteWithLens(NonIdentityGraphLens lens) {
-    return new CommittedSyntheticsCollection(
-        lens.rewriteTypes(legacyTypes),
-        rewriteItems(nonLegacyMethods, lens),
-        rewriteItems(nonLegacyClasses, lens));
-  }
-
-  private static <R extends SyntheticReference<R, ?>> ImmutableMap<DexType, R> rewriteItems(
-      Map<DexType, R> items, NonIdentityGraphLens lens) {
-    ImmutableMap.Builder<DexType, R> rewrittenItems = ImmutableMap.builder();
-    for (R reference : items.values()) {
-      R rewritten = reference.rewrite(lens);
-      if (rewritten != null) {
-        rewrittenItems.put(rewritten.getHolder(), rewritten);
-      }
-    }
-    return rewrittenItems.build();
-  }
-
-  boolean verifyTypesAreInApp(DexApplication application) {
-    assert verifyTypesAreInApp(application, legacyTypes);
-    assert verifyTypesAreInApp(application, nonLegacyMethods.keySet());
-    assert verifyTypesAreInApp(application, nonLegacyClasses.keySet());
-    return true;
-  }
-
-  private static boolean verifyTypesAreInApp(DexApplication app, Collection<DexType> types) {
-    for (DexType type : types) {
-      assert app.programDefinitionFor(type) != null : "Missing synthetic: " + type;
-    }
-    return true;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
index f34bf8e..f5d4b66 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -7,6 +7,7 @@
 import static com.android.tools.r8.utils.DescriptorUtils.getDescriptorFromClassBinaryName;
 
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
@@ -74,6 +75,14 @@
     return inputContextOrigin;
   }
 
+  DexType createHygienicType(String syntheticId, DexItemFactory factory) {
+    // If the context is a synthetic input, then use its annotated context as the hygienic context.
+    String contextDesc = synthesizingContextType.toDescriptorString();
+    String prefix = contextDesc.substring(0, contextDesc.length() - 1);
+    String suffix = SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR + syntheticId + ";";
+    return factory.createType(prefix + suffix);
+  }
+
   SynthesizingContext rewrite(NonIdentityGraphLens lens) {
     DexType rewrittenInputeContextType = lens.lookupType(inputContextType);
     DexType rewrittenSynthesizingContextType = lens.lookupType(synthesizingContextType);
@@ -118,17 +127,15 @@
   void addIfDerivedFromMainDexClass(
       DexProgramClass externalSyntheticClass,
       MainDexClasses mainDexClasses,
-      Set<DexType> allMainDexTypes) {
+      Set<DexType> allMainDexTypes,
+      Set<DexType> derivedMainDexTypesToIgnore) {
     // The input context type (not the annotated context) determines if the derived class is to be
     // in main dex.
     // TODO(b/168584485): Once resolved allMainDexTypes == mainDexClasses.
     if (allMainDexTypes.contains(inputContextType)) {
       mainDexClasses.add(externalSyntheticClass);
+      // Mark the type as to be ignored when computing main-dex placement for legacy types.
+      derivedMainDexTypesToIgnore.add(inputContextType);
     }
   }
-
-  @Override
-  public String toString() {
-    return "SynthesizingContext{" + getSynthesizingContextType() + "}";
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
index 9d2460b..4f289c7 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
@@ -33,10 +33,8 @@
 
   private DexType superType;
   private DexTypeList interfaces = DexTypeList.empty();
-  private List<DexEncodedField> staticFields = new ArrayList<>();
-  private List<DexEncodedField> instanceFields = new ArrayList<>();
-  private List<DexEncodedMethod> directMethods = new ArrayList<>();
-  private List<DexEncodedMethod> virtualMethods = new ArrayList<>();
+
+  private int nextMethodId = 0;
   private List<SyntheticMethodBuilder> methods = new ArrayList<>();
 
   SyntheticClassBuilder(DexType type, SynthesizingContext context, DexItemFactory factory) {
@@ -54,40 +52,12 @@
     return type;
   }
 
-  public SyntheticClassBuilder setInterfaces(List<DexType> interfaces) {
-    this.interfaces =
-        interfaces.isEmpty()
-            ? DexTypeList.empty()
-            : new DexTypeList(interfaces.toArray(DexType.EMPTY_ARRAY));
-    return this;
-  }
-
-  public SyntheticClassBuilder setStaticFields(List<DexEncodedField> fields) {
-    staticFields.clear();
-    staticFields.addAll(fields);
-    return this;
-  }
-
-  public SyntheticClassBuilder setInstanceFields(List<DexEncodedField> fields) {
-    instanceFields.clear();
-    instanceFields.addAll(fields);
-    return this;
-  }
-
-  public SyntheticClassBuilder setDirectMethods(Iterable<DexEncodedMethod> methods) {
-    directMethods.clear();
-    methods.forEach(directMethods::add);
-    return this;
-  }
-
-  public SyntheticClassBuilder setVirtualMethods(Iterable<DexEncodedMethod> methods) {
-    virtualMethods.clear();
-    methods.forEach(virtualMethods::add);
-    return this;
+  private String getNextMethodName() {
+    return SyntheticItems.INTERNAL_SYNTHETIC_METHOD_PREFIX + nextMethodId++;
   }
 
   public SyntheticClassBuilder addMethod(Consumer<SyntheticMethodBuilder> fn) {
-    SyntheticMethodBuilder method = new SyntheticMethodBuilder(this);
+    SyntheticMethodBuilder method = new SyntheticMethodBuilder(this, getNextMethodName());
     fn.accept(method);
     methods.add(method);
     return this;
@@ -95,27 +65,35 @@
 
   DexProgramClass build() {
     ClassAccessFlags accessFlags =
-        ClassAccessFlags.fromSharedAccessFlags(
-            Constants.ACC_FINAL | Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
+        ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
     Kind originKind = null;
     DexString sourceFile = null;
     NestHostClassAttribute nestHost = null;
     List<NestMemberClassAttribute> nestMembers = Collections.emptyList();
     EnclosingMethodAttribute enclosingMembers = null;
     List<InnerClassAttribute> innerClasses = Collections.emptyList();
+    DexEncodedField[] staticFields = DexEncodedField.EMPTY_ARRAY;
+    DexEncodedField[] instanceFields = DexEncodedField.EMPTY_ARRAY;
+    DexEncodedMethod[] directMethods = DexEncodedMethod.EMPTY_ARRAY;
+    DexEncodedMethod[] virtualMethods = DexEncodedMethod.EMPTY_ARRAY;
+    assert !methods.isEmpty();
+    List<DexEncodedMethod> directs = new ArrayList<>(methods.size());
+    List<DexEncodedMethod> virtuals = new ArrayList<>(methods.size());
     for (SyntheticMethodBuilder builder : methods) {
       DexEncodedMethod method = builder.build();
       if (method.isNonPrivateVirtualMethod()) {
-        virtualMethods.add(method);
+        virtuals.add(method);
       } else {
-        directMethods.add(method);
+        directs.add(method);
       }
     }
-    long checksum =
-        7 * (long) directMethods.hashCode()
-            + 11 * (long) virtualMethods.hashCode()
-            + 13 * (long) staticFields.hashCode()
-            + 17 * (long) instanceFields.hashCode();
+    if (!directs.isEmpty()) {
+      directMethods = directs.toArray(new DexEncodedMethod[directs.size()]);
+    }
+    if (!virtuals.isEmpty()) {
+      virtualMethods = virtuals.toArray(new DexEncodedMethod[virtuals.size()]);
+    }
+    long checksum = 7 * (long) directs.hashCode() + 11 * (long) virtuals.hashCode();
     return new DexProgramClass(
         type,
         originKind,
@@ -130,10 +108,10 @@
         innerClasses,
         ClassSignature.noSignature(),
         DexAnnotationSet.empty(),
-        staticFields.toArray(new DexEncodedField[staticFields.size()]),
-        instanceFields.toArray(new DexEncodedField[instanceFields.size()]),
-        directMethods.toArray(new DexEncodedMethod[directMethods.size()]),
-        virtualMethods.toArray(new DexEncodedMethod[virtualMethods.size()]),
+        staticFields,
+        instanceFields,
+        directMethods,
+        virtualMethods,
         factory.getSkipNameValidationForTesting(),
         c -> checksum);
   }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassDefinition.java
deleted file mode 100644
index 4b0b2cf..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassDefinition.java
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (c) 2020, 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.synthesis;
-
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import com.android.tools.r8.utils.structural.RepresentativeMap;
-import com.google.common.hash.Hasher;
-
-/**
- * Definition of a synthetic class item.
- *
- * <p>This class is internal to the synthetic items collection, thus package-protected.
- */
-class SyntheticClassDefinition
-    extends SyntheticDefinition<SyntheticClassReference, SyntheticClassDefinition> {
-
-  private final DexProgramClass clazz;
-
-  SyntheticClassDefinition(SyntheticKind kind, SynthesizingContext context, DexProgramClass clazz) {
-    super(kind, context);
-    this.clazz = clazz;
-  }
-
-  public DexProgramClass getProgramClass() {
-    return clazz;
-  }
-
-  @Override
-  SyntheticClassReference toReference() {
-    return new SyntheticClassReference(getKind(), getContext(), clazz.getType());
-  }
-
-  @Override
-  DexProgramClass getHolder() {
-    return clazz;
-  }
-
-  @Override
-  public boolean isValid() {
-    return clazz.isPublic() && clazz.isFinal() && clazz.accessFlags.isSynthetic();
-  }
-
-  @Override
-  void internalComputeHash(Hasher hasher, RepresentativeMap map) {
-    clazz.hashWithTypeEquivalence(hasher, map);
-  }
-
-  @Override
-  int internalCompareTo(SyntheticClassDefinition o, RepresentativeMap map) {
-    return clazz.compareWithTypeEquivalenceTo(o.clazz, map);
-  }
-
-  @Override
-  public String toString() {
-    return "SyntheticClass{ clazz = "
-        + clazz.type.toSourceString()
-        + ", kind = "
-        + getKind()
-        + ", context = "
-        + getContext()
-        + " }";
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
deleted file mode 100644
index bdb5d73..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) 2020, 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.synthesis;
-
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-/**
- * Reference to a synthetic class item.
- *
- * <p>This class is internal to the synthetic items collection, thus package-protected.
- */
-class SyntheticClassReference
-    extends SyntheticReference<SyntheticClassReference, SyntheticClassDefinition> {
-  final DexType type;
-
-  SyntheticClassReference(SyntheticKind kind, SynthesizingContext context, DexType type) {
-    super(kind, context);
-    this.type = type;
-  }
-
-  @Override
-  DexType getHolder() {
-    return type;
-  }
-
-  @Override
-  SyntheticClassDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
-    DexClass clazz = definitions.apply(type);
-    if (clazz == null) {
-      return null;
-    }
-    assert clazz.isProgramClass();
-    return new SyntheticClassDefinition(getKind(), getContext(), clazz.asProgramClass());
-  }
-
-  @Override
-  SyntheticClassReference rewrite(NonIdentityGraphLens lens) {
-    DexType rewritten = lens.lookupType(type);
-    // If the reference has been non-trivially rewritten the compiler has changed it and it can no
-    // longer be considered a synthetic. The context may or may not have changed.
-    if (type != rewritten && !lens.isSimpleRenaming(type, rewritten)) {
-      // If the referenced item is rewritten, it should be moved to another holder as the
-      // synthetic holder is no longer part of the synthetic collection.
-      assert SyntheticNaming.verifyNotInternalSynthetic(rewritten);
-      return null;
-    }
-    SynthesizingContext context = getContext().rewrite(lens);
-    return context == getContext() && rewritten == type
-        ? this
-        : new SyntheticClassReference(getKind(), context, rewritten);
-  }
-
-  @Override
-  void apply(
-      Consumer<SyntheticMethodReference> onMethod, Consumer<SyntheticClassReference> onClass) {
-    onClass.accept(this);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
index 526f4fc..01f8825 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
@@ -4,71 +4,30 @@
 package com.android.tools.r8.synthesis;
 
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.structural.RepresentativeMap;
 import com.google.common.hash.HashCode;
-import com.google.common.hash.Hasher;
-import com.google.common.hash.Hashing;
 
 /**
  * Base type for the definition of a synthetic item.
  *
  * <p>This class is internal to the synthetic items collection, thus package-protected.
  */
-abstract class SyntheticDefinition<
-    R extends SyntheticReference<R, D>, D extends SyntheticDefinition<R, D>> {
-
-  private final SyntheticKind kind;
+abstract class SyntheticDefinition {
   private final SynthesizingContext context;
 
-  SyntheticDefinition(SyntheticKind kind, SynthesizingContext context) {
-    assert kind != null;
-    assert context != null;
-    this.kind = kind;
+  SyntheticDefinition(SynthesizingContext context) {
     this.context = context;
   }
 
-  abstract R toReference();
+  abstract SyntheticReference toReference();
 
-  final SyntheticKind getKind() {
-    return kind;
-  }
-
-  final SynthesizingContext getContext() {
+  SynthesizingContext getContext() {
     return context;
   }
 
   abstract DexProgramClass getHolder();
 
-  final HashCode computeHash(RepresentativeMap map, boolean intermediate) {
-    Hasher hasher = Hashing.murmur3_128().newHasher();
-    if (intermediate) {
-      // If in intermediate mode, include the context type as sharing is restricted to within a
-      // single context.
-      getContext().getSynthesizingContextType().hashWithTypeEquivalence(hasher, map);
-    }
-    internalComputeHash(hasher, map);
-    return hasher.hash();
-  }
+  abstract HashCode computeHash(RepresentativeMap map, boolean intermediate);
 
-  abstract void internalComputeHash(Hasher hasher, RepresentativeMap map);
-
-  final boolean isEquivalentTo(D other, boolean includeContext) {
-    return compareTo(other, includeContext) == 0;
-  }
-
-  int compareTo(D other, boolean includeContext) {
-    if (includeContext) {
-      int order = getContext().compareTo(other.getContext());
-      if (order != 0) {
-        return order;
-      }
-    }
-    RepresentativeMap map = t -> t == other.getHolder().getType() ? getHolder().getType() : t;
-    return internalCompareTo(other, map);
-  }
-
-  abstract int internalCompareTo(D other, RepresentativeMap map);
-
-  public abstract boolean isValid();
+  abstract boolean isEquivalentTo(SyntheticDefinition other, boolean intermediate);
 }
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 67391a2..c18b29d 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -6,31 +6,22 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
 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.DexType;
 import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.GraphLens.Builder;
 import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
-import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
 import com.android.tools.r8.graph.PrunedItems;
-import com.android.tools.r8.graph.TreeFixerBase;
-import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.collections.BidirectionalManyToManyRepresentativeMap;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeHashMap;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
-import com.android.tools.r8.utils.collections.BidirectionalOneToOneHashMap;
 import com.android.tools.r8.utils.structural.RepresentativeMap;
 import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Sets;
 import com.google.common.hash.HashCode;
@@ -41,146 +32,37 @@
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeSet;
-import java.util.function.Function;
+import java.util.function.Predicate;
 
 public class SyntheticFinalization {
 
   public static class Result {
     public final CommittedItems commit;
-    public final NonIdentityGraphLens lens;
     public final PrunedItems prunedItems;
 
-    public Result(
-        CommittedItems commit, SyntheticFinalizationGraphLens lens, PrunedItems prunedItems) {
+    public Result(CommittedItems commit, PrunedItems prunedItems) {
       this.commit = commit;
-      this.lens = lens;
       this.prunedItems = prunedItems;
     }
   }
 
-  public static class SyntheticFinalizationGraphLens extends NestedGraphLens {
+  private static class EquivalenceGroup<T extends SyntheticDefinition & Comparable<T>>
+      implements Comparable<EquivalenceGroup<T>> {
+    private List<T> members;
 
-    private final Map<DexType, DexType> syntheticTypeMap;
-    private final Map<DexMethod, DexMethod> syntheticMethodsMap;
-
-    private SyntheticFinalizationGraphLens(
-        GraphLens previous,
-        Map<DexType, DexType> syntheticClassesMap,
-        Map<DexMethod, DexMethod> syntheticMethodsMap,
-        Map<DexType, DexType> typeMap,
-        BidirectionalManyToOneRepresentativeMap<DexField, DexField> fieldMap,
-        Map<DexMethod, DexMethod> methodMap,
-        BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod> originalMethodSignatures,
-        DexItemFactory factory) {
-      super(typeMap, methodMap, fieldMap, originalMethodSignatures, previous, factory);
-      this.syntheticTypeMap = syntheticClassesMap;
-      this.syntheticMethodsMap = syntheticMethodsMap;
+    EquivalenceGroup(T singleton) {
+      this(singleton, Collections.singletonList(singleton));
     }
 
-    // The mapping is many to one, so the inverse is only defined up to equivalence groups.
-    // Override the access to renamed signatures to first check for synthetic mappings before
-    // using the original item mappings of the
-
-    @Override
-    public DexField getRenamedFieldSignature(DexField originalField) {
-      if (syntheticTypeMap.containsKey(originalField.holder)) {
-        DexField renamed = fieldMap.get(originalField);
-        if (renamed != null) {
-          return renamed;
-        }
-      }
-      return super.getRenamedFieldSignature(originalField);
-    }
-
-    @Override
-    public DexMethod getRenamedMethodSignature(DexMethod originalMethod, GraphLens applied) {
-      if (syntheticTypeMap.containsKey(originalMethod.holder)) {
-        DexMethod renamed = methodMap.get(originalMethod);
-        if (renamed != null) {
-          return renamed;
-        }
-      }
-      DexMethod renamed = syntheticMethodsMap.get(originalMethod);
-      return renamed != null ? renamed : super.getRenamedMethodSignature(originalMethod, applied);
-    }
-  }
-
-  private static class Builder {
-
-    // Forward mapping of internal to external synthetics.
-    Map<DexType, DexType> syntheticClassesMap = new IdentityHashMap<>();
-    Map<DexMethod, DexMethod> syntheticMethodsMap = new IdentityHashMap<>();
-
-    Map<DexType, DexType> typeMap = new IdentityHashMap<>();
-    BidirectionalManyToOneRepresentativeHashMap<DexField, DexField> fieldMap =
-        new BidirectionalManyToOneRepresentativeHashMap<>();
-    Map<DexMethod, DexMethod> methodMap = new IdentityHashMap<>();
-
-    protected final BidirectionalOneToOneHashMap<DexMethod, DexMethod> originalMethodSignatures =
-        new BidirectionalOneToOneHashMap<>();
-
-    void moveSyntheticClass(DexType from, DexType to) {
-      assert !syntheticClassesMap.containsKey(from);
-      syntheticClassesMap.put(from, to);
-      typeMap.put(from, to);
-    }
-
-    void moveSyntheticMethod(DexMethod from, DexMethod to) {
-      assert !syntheticMethodsMap.containsKey(from);
-      syntheticMethodsMap.put(from, to);
-      methodMap.put(from, to);
-    }
-
-    void move(DexType from, DexType to) {
-      typeMap.put(from, to);
-    }
-
-    void move(DexField from, DexField to) {
-      fieldMap.put(from, to);
-    }
-
-    void move(DexMethod from, DexMethod to) {
-      methodMap.put(from, to);
-      originalMethodSignatures.put(to, from);
-    }
-
-    SyntheticFinalizationGraphLens build(GraphLens previous, DexItemFactory factory) {
-      assert verifySubMap(syntheticClassesMap, typeMap);
-      if (typeMap.isEmpty() && fieldMap.isEmpty() && methodMap.isEmpty()) {
-        return null;
-      }
-      return new SyntheticFinalizationGraphLens(
-          previous,
-          syntheticClassesMap,
-          syntheticMethodsMap,
-          typeMap,
-          fieldMap,
-          methodMap,
-          originalMethodSignatures,
-          factory);
-    }
-
-    private static <K, V> boolean verifySubMap(Map<K, V> sub, Map<K, V> sup) {
-      for (Entry<K, V> entry : sub.entrySet()) {
-        assert sup.get(entry.getKey()) == entry.getValue();
-      }
-      return true;
-    }
-  }
-
-  public static class EquivalenceGroup<T extends SyntheticDefinition<?, T>> {
-    private final List<T> members;
-
-    public EquivalenceGroup(T representative, List<T> members) {
+    EquivalenceGroup(T representative, List<T> members) {
       assert !members.isEmpty();
       assert members.get(0) == representative;
       this.members = members;
     }
 
-    public T getRepresentative() {
+    T getRepresentative() {
       return members.get(0);
     }
 
@@ -188,103 +70,89 @@
       return members;
     }
 
-    public int compareToIncludingContext(EquivalenceGroup<T> other) {
-      return getRepresentative().compareTo(other.getRepresentative(), true);
-    }
-
-    public int compareTo(EquivalenceGroup<T> other, boolean includeContext) {
-      return getRepresentative().compareTo(other.getRepresentative(), includeContext);
-    }
-
     @Override
-    public String toString() {
-      return "EquivalenceGroup{ members = "
-          + members.size()
-          + ", repr = "
-          + getRepresentative()
-          + " }";
+    public int compareTo(EquivalenceGroup<T> other) {
+      return getRepresentative().compareTo(other.getRepresentative());
     }
   }
 
   private final InternalOptions options;
-  private final CommittedSyntheticsCollection synthetics;
+  private final ImmutableSet<DexType> legacySyntheticTypes;
+  private final ImmutableMap<DexType, SyntheticReference> syntheticItems;
 
-  SyntheticFinalization(InternalOptions options, CommittedSyntheticsCollection synthetics) {
+  SyntheticFinalization(
+      InternalOptions options,
+      ImmutableSet<DexType> legacySyntheticTypes,
+      ImmutableMap<DexType, SyntheticReference> syntheticItems) {
     this.options = options;
-    this.synthetics = synthetics;
+    this.legacySyntheticTypes = legacySyntheticTypes;
+    this.syntheticItems = syntheticItems;
   }
 
   public Result computeFinalSynthetics(AppView<?> appView) {
     assert verifyNoNestedSynthetics();
-    DexApplication application;
+    DexApplication application = appView.appInfo().app();
     MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
+    GraphLens graphLens = appView.graphLens();
+
+    Map<DexType, SyntheticMethodDefinition> methodDefinitions =
+        lookupSyntheticMethodDefinitions(application);
+
+    Collection<List<SyntheticMethodDefinition>> potentialEquivalences =
+        computePotentialEquivalences(methodDefinitions, options.intermediate);
+
+    Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> equivalences =
+        computeActualEquivalences(potentialEquivalences, options.intermediate, options.itemFactory);
+
+    Builder lensBuilder = NestedGraphLens.builder();
+    List<DexProgramClass> newProgramClasses = new ArrayList<>();
     List<DexProgramClass> finalSyntheticClasses = new ArrayList<>();
-    Builder lensBuilder = new Builder();
-    {
-      Map<DexType, NumberGenerator> generators = new IdentityHashMap<>();
-      application =
-          buildLensAndProgram(
-              appView,
-              computeEquivalences(appView, synthetics.getNonLegacyMethods().values(), generators),
-              computeEquivalences(appView, synthetics.getNonLegacyClasses().values(), generators),
-              mainDexClasses,
-              lensBuilder,
-              finalSyntheticClasses);
-    }
+    Set<DexType> derivedMainDexTypesToIgnore = Sets.newIdentityHashSet();
+    buildLensAndProgram(
+        appView,
+        equivalences,
+        syntheticItems::containsKey,
+        mainDexClasses,
+        lensBuilder,
+        newProgramClasses,
+        finalSyntheticClasses,
+        derivedMainDexTypesToIgnore);
+
+    newProgramClasses.addAll(finalSyntheticClasses);
 
     handleSynthesizedClassMapping(
-        finalSyntheticClasses, application, options, mainDexClasses, lensBuilder.typeMap);
+        finalSyntheticClasses, application, options, mainDexClasses, derivedMainDexTypesToIgnore);
 
+    DexApplication app = application.builder().replaceProgramClasses(newProgramClasses).build();
+
+    appView.setGraphLens(lensBuilder.build(options.itemFactory, graphLens));
     assert appView.appInfo().getMainDexClasses() == mainDexClasses;
 
     Set<DexType> finalSyntheticTypes = Sets.newIdentityHashSet();
     finalSyntheticClasses.forEach(clazz -> finalSyntheticTypes.add(clazz.getType()));
 
     Set<DexType> prunedSynthetics = Sets.newIdentityHashSet();
-    synthetics.forEachNonLegacyItem(
-        reference -> {
-          DexType type = reference.getHolder();
-          if (!finalSyntheticTypes.contains(type)) {
-            prunedSynthetics.add(type);
-          }
-        });
+    for (DexType type : syntheticItems.keySet()) {
+      if (!finalSyntheticTypes.contains(type)) {
+        prunedSynthetics.add(type);
+      }
+    }
 
     return new Result(
         new CommittedItems(
             SyntheticItems.INVALID_ID_AFTER_SYNTHETIC_FINALIZATION,
-            application,
-            new CommittedSyntheticsCollection(
-                synthetics.getLegacyTypes(), ImmutableMap.of(), ImmutableMap.of()),
+            app,
+            legacySyntheticTypes,
+            ImmutableMap.of(),
             ImmutableList.of()),
-        lensBuilder.build(appView.graphLens(), appView.dexItemFactory()),
-        PrunedItems.builder()
-            .setPrunedApp(application)
-            .addRemovedClasses(prunedSynthetics)
-            .build());
-  }
-
-  private <R extends SyntheticReference<R, D>, D extends SyntheticDefinition<R, D>>
-      Map<DexType, EquivalenceGroup<D>> computeEquivalences(
-          AppView<?> appView,
-          ImmutableCollection<R> references,
-          Map<DexType, NumberGenerator> generators) {
-    boolean intermediate = appView.options().intermediate;
-    Map<DexType, D> definitions = lookupDefinitions(appView, references);
-    Collection<List<D>> potentialEquivalences =
-        computePotentialEquivalences(definitions, intermediate, appView.dexItemFactory());
-    return computeActualEquivalences(potentialEquivalences, generators, appView, intermediate);
-  }
-
-  private boolean isNotSyntheticType(DexType type) {
-    return !synthetics.containsNonLegacyType(type);
+        PrunedItems.builder().setPrunedApp(app).addRemovedClasses(prunedSynthetics).build());
   }
 
   private boolean verifyNoNestedSynthetics() {
     // Check that a context is never itself synthetic class.
-    synthetics.forEachNonLegacyItem(
-        item -> {
-          assert isNotSyntheticType(item.getContext().getSynthesizingContextType());
-        });
+    for (SyntheticReference item : syntheticItems.values()) {
+      assert !syntheticItems.containsKey(item.getContext().getSynthesizingContextType());
+    }
     return true;
   }
 
@@ -293,7 +161,7 @@
       DexApplication application,
       InternalOptions options,
       MainDexClasses mainDexClasses,
-      Map<DexType, DexType> derivedMainDexTypesToIgnore) {
+      Set<DexType> derivedMainDexTypesToIgnore) {
     boolean includeSynthesizedClassMappingInOutput = shouldAnnotateSynthetics(options);
     if (includeSynthesizedClassMappingInOutput) {
       updateSynthesizedClassMapping(application, finalSyntheticClasses);
@@ -309,7 +177,7 @@
       DexApplication application, List<DexProgramClass> finalSyntheticClasses) {
     ListMultimap<DexProgramClass, DexProgramClass> originalToSynthesized =
         ArrayListMultimap.create();
-    for (DexType type : synthetics.getLegacyTypes()) {
+    for (DexType type : legacySyntheticTypes) {
       DexProgramClass clazz = DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
       if (clazz != null) {
         for (DexProgramClass origin : clazz.getSynthesizedFrom()) {
@@ -346,7 +214,7 @@
   private void updateMainDexListWithSynthesizedClassMap(
       DexApplication application,
       MainDexClasses mainDexClasses,
-      Map<DexType, DexType> derivedMainDexTypesToIgnore) {
+      Set<DexType> derivedMainDexTypesToIgnore) {
     if (mainDexClasses.isEmpty()) {
       return;
     }
@@ -360,11 +228,12 @@
                 DexAnnotation.readAnnotationSynthesizedClassMap(
                     programClass, application.dexItemFactory);
             for (DexType type : derived) {
-              DexType mappedType = derivedMainDexTypesToIgnore.getOrDefault(type, type);
-              DexProgramClass syntheticClass =
-                  DexProgramClass.asProgramClassOrNull(application.definitionFor(mappedType));
-              if (syntheticClass != null) {
-                newMainDexClasses.add(syntheticClass);
+              if (!derivedMainDexTypesToIgnore.contains(type)) {
+                DexProgramClass syntheticClass =
+                    DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
+                if (syntheticClass != null) {
+                  newMainDexClasses.add(syntheticClass);
+                }
               }
             }
           }
@@ -379,16 +248,24 @@
     }
   }
 
-  private static DexApplication buildLensAndProgram(
+  private static void buildLensAndProgram(
       AppView<?> appView,
       Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> syntheticMethodGroups,
-      Map<DexType, EquivalenceGroup<SyntheticClassDefinition>> syntheticClassGroups,
+      Predicate<DexType> isSyntheticType,
       MainDexClasses mainDexClasses,
       Builder lensBuilder,
-      List<DexProgramClass> newSyntheticClasses) {
-    DexApplication application = appView.appInfo().app();
+      List<DexProgramClass> normalClasses,
+      List<DexProgramClass> newSyntheticClasses,
+      Set<DexType> derivedMainDexTypesToIgnore) {
     DexItemFactory factory = appView.dexItemFactory();
 
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      if (!isSyntheticType.test(clazz.type)) {
+        assert SyntheticItems.verifyNotInternalSynthetic(clazz.type);
+        normalClasses.add(clazz);
+      }
+    }
+
     // TODO(b/168584485): Remove this once class-mapping support is removed.
     Set<DexType> derivedMainDexTypes = Sets.newIdentityHashSet();
     mainDexClasses.forEach(
@@ -403,178 +280,60 @@
           }
         });
 
-    Set<DexType> pruned = Sets.newIdentityHashSet();
     syntheticMethodGroups.forEach(
         (syntheticType, syntheticGroup) -> {
           SyntheticMethodDefinition representative = syntheticGroup.getRepresentative();
           SynthesizingContext context = representative.getContext();
           context.registerPrefixRewriting(syntheticType, appView);
-          DexProgramClass externalSyntheticClass =
-              createExternalMethodClass(syntheticType, representative, factory);
-          newSyntheticClasses.add(externalSyntheticClass);
-          addSyntheticMarker(representative.getKind(), externalSyntheticClass, context, appView);
+          SyntheticClassBuilder builder =
+              new SyntheticClassBuilder(syntheticType, context, factory);
+          // TODO(b/158159959): Support grouping multiple methods per synthetic class.
+          builder.addMethod(
+              methodBuilder -> {
+                DexEncodedMethod definition = representative.getMethod().getDefinition();
+                methodBuilder
+                    .setAccessFlags(definition.accessFlags)
+                    .setProto(definition.getProto())
+                    .setClassFileVersion(
+                        definition.hasClassFileVersion() ? definition.getClassFileVersion() : null)
+                    .setCode(m -> definition.getCode());
+              });
+          DexProgramClass externalSyntheticClass = builder.build();
+          if (shouldAnnotateSynthetics(appView.options())) {
+            externalSyntheticClass.setAnnotations(
+                externalSyntheticClass
+                    .annotations()
+                    .getWithAddedOrReplaced(
+                        DexAnnotation.createAnnotationSynthesizedClass(
+                            context.getSynthesizingContextType(), factory)));
+          }
           assert externalSyntheticClass.getMethodCollection().size() == 1;
           DexEncodedMethod externalSyntheticMethod =
               externalSyntheticClass.methods().iterator().next();
-          for (SyntheticMethodDefinition member : syntheticGroup.getMembers()) {
-            DexMethod memberReference = member.getMethod().getReference();
-            pruned.add(member.getHolder().getType());
-            if (memberReference != externalSyntheticMethod.method) {
-              lensBuilder.moveSyntheticMethod(memberReference, externalSyntheticMethod.method);
-            }
-          }
-        });
-
-    List<DexProgramClass> deduplicatedClasses = new ArrayList<>();
-    syntheticClassGroups.forEach(
-        (syntheticType, syntheticGroup) -> {
-          SyntheticClassDefinition representative = syntheticGroup.getRepresentative();
-          SynthesizingContext context = representative.getContext();
-          context.registerPrefixRewriting(syntheticType, appView);
-          DexProgramClass externalSyntheticClass = representative.getProgramClass();
-          newSyntheticClasses.add(externalSyntheticClass);
-          addSyntheticMarker(representative.getKind(), externalSyntheticClass, context, appView);
-          for (SyntheticClassDefinition member : syntheticGroup.getMembers()) {
-            DexProgramClass memberClass = member.getProgramClass();
-            DexType memberType = memberClass.getType();
-            pruned.add(memberType);
-            if (memberType != syntheticType) {
-              lensBuilder.moveSyntheticClass(memberType, syntheticType);
-            }
-            // The aliasing of the non-representative members needs to be recorded manually.
-            if (member != representative) {
-              deduplicatedClasses.add(memberClass);
-            }
-          }
-        });
-
-    List<DexProgramClass> newProgramClasses = new ArrayList<>(newSyntheticClasses);
-    for (DexProgramClass clazz : application.classes()) {
-      if (!pruned.contains(clazz.type)) {
-        newProgramClasses.add(clazz);
-      }
-    }
-    application = application.builder().replaceProgramClasses(newProgramClasses).build();
-
-    // We can only assert that the method container classes are in here as the classes need
-    // to be rewritten by the tree-fixer.
-    for (DexType key : syntheticMethodGroups.keySet()) {
-      assert application.definitionFor(key) != null;
-    }
-
-    newSyntheticClasses.clear();
-
-    DexApplication.Builder<?> builder = application.builder();
-    TreeFixerBase treeFixer =
-        new TreeFixerBase(appView) {
-          @Override
-          public DexType mapClassType(DexType type) {
-            return lensBuilder.syntheticClassesMap.getOrDefault(type, type);
-          }
-
-          @Override
-          public void recordFieldChange(DexField from, DexField to) {
-            lensBuilder.move(from, to);
-          }
-
-          @Override
-          public void recordMethodChange(DexMethod from, DexMethod to) {
-            lensBuilder.move(from, to);
-          }
-
-          @Override
-          public void recordClassChange(DexType from, DexType to) {
-            lensBuilder.move(from, to);
-          }
-        };
-    treeFixer.fixupClasses(deduplicatedClasses);
-    builder.replaceProgramClasses(treeFixer.fixupClasses(application.classes()));
-    application = builder.build();
-
-    // Add the synthesized from after repackaging which changed class definitions.
-    final DexApplication appForLookup = application;
-    syntheticClassGroups.forEach(
-        (syntheticType, syntheticGroup) -> {
-          DexProgramClass externalSyntheticClass = appForLookup.programDefinitionFor(syntheticType);
-          newSyntheticClasses.add(externalSyntheticClass);
-          for (SyntheticClassDefinition member : syntheticGroup.getMembers()) {
-            addMainDexAndSynthesizedFromForMember(
-                member,
-                externalSyntheticClass,
-                mainDexClasses,
-                derivedMainDexTypes,
-                appForLookup::programDefinitionFor);
-          }
-        });
-    syntheticMethodGroups.forEach(
-        (syntheticType, syntheticGroup) -> {
-          DexProgramClass externalSyntheticClass = appForLookup.programDefinitionFor(syntheticType);
           newSyntheticClasses.add(externalSyntheticClass);
           for (SyntheticMethodDefinition member : syntheticGroup.getMembers()) {
-            addMainDexAndSynthesizedFromForMember(
-                member,
-                externalSyntheticClass,
-                mainDexClasses,
-                derivedMainDexTypes,
-                appForLookup::programDefinitionFor);
+            if (member.getMethod().getReference() != externalSyntheticMethod.method) {
+              lensBuilder.map(member.getMethod().getReference(), externalSyntheticMethod.method);
+            }
+            member
+                .getContext()
+                .addIfDerivedFromMainDexClass(
+                    externalSyntheticClass,
+                    mainDexClasses,
+                    derivedMainDexTypes,
+                    derivedMainDexTypesToIgnore);
+            // TODO(b/168584485): Remove this once class-mapping support is removed.
+            DexProgramClass from =
+                DexProgramClass.asProgramClassOrNull(
+                    appView
+                        .appInfo()
+                        .definitionForWithoutExistenceAssert(
+                            member.getContext().getSynthesizingContextType()));
+            if (from != null) {
+              externalSyntheticClass.addSynthesizedFrom(from);
+            }
           }
         });
-
-    for (DexType key : syntheticMethodGroups.keySet()) {
-      assert application.definitionFor(key) != null;
-    }
-
-    for (DexType key : syntheticClassGroups.keySet()) {
-      assert application.definitionFor(key) != null;
-    }
-
-    return application;
-  }
-
-  private static void addSyntheticMarker(
-      SyntheticKind kind,
-      DexProgramClass externalSyntheticClass,
-      SynthesizingContext context,
-      AppView<?> appView) {
-    if (shouldAnnotateSynthetics(appView.options())) {
-      SyntheticMarker.addMarkerToClass(
-          externalSyntheticClass, kind, context, appView.dexItemFactory());
-    }
-  }
-
-  private static DexProgramClass createExternalMethodClass(
-      DexType syntheticType, SyntheticMethodDefinition representative, DexItemFactory factory) {
-    SyntheticClassBuilder builder =
-        new SyntheticClassBuilder(syntheticType, representative.getContext(), factory);
-    // TODO(b/158159959): Support grouping multiple methods per synthetic class.
-    builder.addMethod(
-        methodBuilder -> {
-          DexEncodedMethod definition = representative.getMethod().getDefinition();
-          methodBuilder
-              .setName(SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX)
-              .setAccessFlags(definition.accessFlags)
-              .setProto(definition.getProto())
-              .setClassFileVersion(
-                  definition.hasClassFileVersion() ? definition.getClassFileVersion() : null)
-              .setCode(m -> definition.getCode());
-        });
-    return builder.build();
-  }
-
-  private static void addMainDexAndSynthesizedFromForMember(
-      SyntheticDefinition<?, ?> member,
-      DexProgramClass externalSyntheticClass,
-      MainDexClasses mainDexClasses,
-      Set<DexType> derivedMainDexTypes,
-      Function<DexType, DexProgramClass> definitions) {
-    member
-        .getContext()
-        .addIfDerivedFromMainDexClass(externalSyntheticClass, mainDexClasses, derivedMainDexTypes);
-    // TODO(b/168584485): Remove this once class-mapping support is removed.
-    DexProgramClass from = definitions.apply(member.getContext().getSynthesizingContextType());
-    if (from != null) {
-      externalSyntheticClass.addSynthesizedFrom(from);
-    }
   }
 
   private static boolean shouldAnnotateSynthetics(InternalOptions options) {
@@ -586,12 +345,9 @@
     return options.intermediate && !options.cfToCfDesugar;
   }
 
-  private <T extends SyntheticDefinition<?, T>>
+  private static <T extends SyntheticDefinition & Comparable<T>>
       Map<DexType, EquivalenceGroup<T>> computeActualEquivalences(
-          Collection<List<T>> potentialEquivalences,
-          Map<DexType, NumberGenerator> generators,
-          AppView<?> appView,
-          boolean intermediate) {
+          Collection<List<T>> potentialEquivalences, boolean intermediate, DexItemFactory factory) {
     Map<DexType, List<EquivalenceGroup<T>>> groupsPerContext = new IdentityHashMap<>();
     potentialEquivalences.forEach(
         members -> {
@@ -612,24 +368,20 @@
     Map<DexType, EquivalenceGroup<T>> equivalences = new IdentityHashMap<>();
     groupsPerContext.forEach(
         (context, groups) -> {
-          // Sort the equivalence groups that go into 'context' including the context type of the
-          // representative which is equal to 'context' here (see assert below).
-          groups.sort(EquivalenceGroup::compareToIncludingContext);
+          groups.sort(EquivalenceGroup::compareTo);
           for (int i = 0; i < groups.size(); i++) {
             EquivalenceGroup<T> group = groups.get(i);
-            assert group.getRepresentative().getContext().getSynthesizingContextType() == context;
             // Two equivalence groups in same context type must be distinct otherwise the assignment
             // of the synthetic name will be non-deterministic between the two.
             assert i == 0 || checkGroupsAreDistinct(groups.get(i - 1), group);
-            SyntheticKind kind = group.members.get(0).getKind();
-            DexType representativeType = createExternalType(kind, context, generators, appView);
+            DexType representativeType = createExternalType(context, i, factory);
             equivalences.put(representativeType, group);
           }
         });
     return equivalences;
   }
 
-  private static <T extends SyntheticDefinition<?, T>> List<List<T>> groupEquivalent(
+  private static <T extends SyntheticDefinition & Comparable<T>> List<List<T>> groupEquivalent(
       List<T> potentialEquivalence, boolean intermediate) {
     List<List<T>> groups = new ArrayList<>();
     // Each other member is in a shared group if it is actually equivalent to the first member.
@@ -651,61 +403,42 @@
     return groups;
   }
 
-  private static <T extends SyntheticDefinition<?, T>> boolean checkGroupsAreDistinct(
+  private static <T extends SyntheticDefinition & Comparable<T>> boolean checkGroupsAreDistinct(
       EquivalenceGroup<T> g1, EquivalenceGroup<T> g2) {
-    int order = g1.compareToIncludingContext(g2);
-    assert order != 0;
-    assert order != g2.compareToIncludingContext(g1);
+    assert g1.compareTo(g2) != 0;
     return true;
   }
 
-  private static <T extends SyntheticDefinition<?, T>> T findDeterministicRepresentative(
+  private static <T extends SyntheticDefinition & Comparable<T>> T findDeterministicRepresentative(
       List<T> members) {
     // Pick a deterministic member as representative.
     T smallest = members.get(0);
     for (int i = 1; i < members.size(); i++) {
       T next = members.get(i);
-      if (next.compareTo(smallest, true) < 0) {
+      if (next.compareTo(smallest) < 0) {
         smallest = next;
       }
     }
     return smallest;
   }
 
-  private DexType createExternalType(
-      SyntheticKind kind,
-      DexType representativeContext,
-      Map<DexType, NumberGenerator> generators,
-      AppView<?> appView) {
-    NumberGenerator generator =
-        generators.computeIfAbsent(representativeContext, k -> new NumberGenerator());
-    DexType externalType;
-    do {
-      externalType =
-          SyntheticNaming.createExternalType(
-              kind,
-              representativeContext,
-              Integer.toString(generator.next()),
-              appView.dexItemFactory());
-      DexClass clazz = appView.appInfo().definitionForWithoutExistenceAssert(externalType);
-      if (clazz != null && isNotSyntheticType(clazz.type)) {
-        assert options.testing.allowConflictingSyntheticTypes
-            : "Unexpected creation of an existing external synthetic type: " + clazz;
-        externalType = null;
-      }
-    } while (externalType == null);
-    return externalType;
+  private static DexType createExternalType(
+      DexType representativeContext, int nextContextId, DexItemFactory factory) {
+    return factory.createType(
+        DescriptorUtils.getDescriptorFromClassBinaryName(
+            representativeContext.getInternalName()
+                + SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR
+                + nextContextId));
   }
 
-  private static <T extends SyntheticDefinition<?, T>>
-      Collection<List<T>> computePotentialEquivalences(
-          Map<DexType, T> definitions, boolean intermediate, DexItemFactory factory) {
+  private static <T extends SyntheticDefinition> Collection<List<T>> computePotentialEquivalences(
+      Map<DexType, T> definitions, boolean intermediate) {
     if (definitions.isEmpty()) {
       return Collections.emptyList();
     }
-    // Map all synthetic types to the java 'void' type. This is not an actual valid type, so it
-    // cannot collide with any valid java type providing a good hashing key for the synthetics.
-    RepresentativeMap map = t -> definitions.containsKey(t) ? factory.voidType : t;
+    Set<DexType> allTypes = definitions.keySet();
+    DexType representative = allTypes.iterator().next();
+    RepresentativeMap map = t -> allTypes.contains(t) ? representative : t;
     Map<HashCode, List<T>> equivalences = new HashMap<>(definitions.size());
     for (T definition : definitions.values()) {
       HashCode hash = definition.computeHash(map, intermediate);
@@ -714,24 +447,25 @@
     return equivalences.values();
   }
 
-  private <R extends SyntheticReference<R, D>, D extends SyntheticDefinition<R, D>>
-      Map<DexType, D> lookupDefinitions(AppView<?> appView, Collection<R> references) {
-    Map<DexType, D> definitions = new IdentityHashMap<>(references.size());
-    for (R reference : references) {
-      D definition = reference.lookupDefinition(appView::definitionFor);
-      if (definition == null) {
+  private Map<DexType, SyntheticMethodDefinition> lookupSyntheticMethodDefinitions(
+      DexApplication finalApp) {
+    Map<DexType, SyntheticMethodDefinition> methods = new IdentityHashMap<>(syntheticItems.size());
+    for (SyntheticReference reference : syntheticItems.values()) {
+      SyntheticDefinition definition = reference.lookupDefinition(finalApp::definitionFor);
+      if (definition == null || !(definition instanceof SyntheticMethodDefinition)) {
         // We expect pruned definitions to have been removed.
         assert false;
         continue;
       }
-      if (definition.isValid()) {
-        definitions.put(reference.getHolder(), definition);
+      SyntheticMethodDefinition method = (SyntheticMethodDefinition) definition;
+      if (SyntheticMethodBuilder.isValidSyntheticMethod(method.getMethod().getDefinition())) {
+        methods.put(method.getHolder().getType(), method);
       } else {
         // Failing this check indicates that an optimization has modified the synthetic in a
         // disruptive way.
         assert false;
       }
     }
-    return definitions;
+    return methods;
   }
 }
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 179f990..bc7d42e 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -6,8 +6,12 @@
 import com.android.tools.r8.errors.InternalCompilerError;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ClassAccessFlags;
+import com.android.tools.r8.graph.DexAnnotation;
+import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
@@ -17,8 +21,11 @@
 import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.ir.conversion.MethodProcessingId;
 import com.android.tools.r8.synthesis.SyntheticFinalization.Result;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -28,112 +35,148 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.Predicate;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
 
 public class SyntheticItems implements SyntheticDefinitionsProvider {
 
   static final int INVALID_ID_AFTER_SYNTHETIC_FINALIZATION = -1;
 
+  /**
+   * The internal synthetic class separator is only used for representing synthetic items during
+   * compilation. In particular, this separator must never be used to write synthetic classes to the
+   * final compilation result.
+   */
+  public static final String INTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$InternalSynthetic";
+
+  /**
+   * The external synthetic class separator is used when writing classes. It may appear in types
+   * during compilation as the output of a compilation may be the input to another.
+   */
+  public static final String EXTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$ExternalSynthetic";
+
+  /** Method prefix when generating synthetic methods in a class. */
+  public static final String INTERNAL_SYNTHETIC_METHOD_PREFIX = "m";
+
+  public static boolean verifyNotInternalSynthetic(DexType type) {
+    assert !type.toDescriptorString().contains(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR);
+    return true;
+  }
+
   /** Globally incremented id for the next internal synthetic class. */
   private int nextSyntheticId;
 
-  /** Collection of pending items. */
-  private static class PendingSynthetics {
-    /**
-     * Thread safe collection of synthesized classes that are not yet committed to the application.
-     *
-     * <p>TODO(b/158159959): Remove legacy support.
-     */
-    private final Map<DexType, DexProgramClass> legacyClasses = new ConcurrentHashMap<>();
+  /**
+   * Thread safe collection of synthesized classes that are not yet committed to the application.
+   *
+   * <p>TODO(b/158159959): Remove legacy support.
+   */
+  private final Map<DexType, DexProgramClass> legacyPendingClasses = new ConcurrentHashMap<>();
 
-    /** Thread safe collection of synthetic items not yet committed to the application. */
-    private final ConcurrentHashMap<DexType, SyntheticDefinition<?, ?>> nonLegacyDefinitions =
-        new ConcurrentHashMap<>();
+  /**
+   * Immutable set of synthetic types in the application (eg, committed).
+   *
+   * <p>TODO(b/158159959): Remove legacy support.
+   */
+  private final ImmutableSet<DexType> legacySyntheticTypes;
 
-    boolean isEmpty() {
-      return legacyClasses.isEmpty() && nonLegacyDefinitions.isEmpty();
-    }
+  /** Thread safe collection of synthetic items not yet committed to the application. */
+  private final ConcurrentHashMap<DexType, SyntheticDefinition> pendingDefinitions =
+      new ConcurrentHashMap<>();
 
-    boolean containsType(DexType type) {
-      return legacyClasses.containsKey(type) || nonLegacyDefinitions.containsKey(type);
-    }
-
-    boolean verifyNotRewritten(NonIdentityGraphLens lens) {
-      assert legacyClasses.keySet().equals(lens.rewriteTypes(legacyClasses.keySet()));
-      assert nonLegacyDefinitions.keySet().equals(lens.rewriteTypes(nonLegacyDefinitions.keySet()));
-      return true;
-    }
-
-    Collection<DexProgramClass> getAllClasses() {
-      List<DexProgramClass> allPending =
-          new ArrayList<>(nonLegacyDefinitions.size() + legacyClasses.size());
-      for (SyntheticDefinition<?, ?> item : nonLegacyDefinitions.values()) {
-        allPending.add(item.getHolder());
-      }
-      allPending.addAll(legacyClasses.values());
-      return Collections.unmodifiableList(allPending);
-    }
-  }
-
-  private final CommittedSyntheticsCollection committed;
-
-  private final PendingSynthetics pending = new PendingSynthetics();
+  /** Mapping from synthetic type to its synthetic description. */
+  private final ImmutableMap<DexType, SyntheticReference> nonLecacySyntheticItems;
 
   // Only for use from initial AppInfo/AppInfoWithClassHierarchy create functions. */
   public static CommittedItems createInitialSyntheticItems(DexApplication application) {
     return new CommittedItems(
-        0, application, CommittedSyntheticsCollection.empty(), ImmutableList.of());
+        0, application, ImmutableSet.of(), ImmutableMap.of(), ImmutableList.of());
   }
 
   // Only for conversion to a mutable synthetic items collection.
   SyntheticItems(CommittedItems commit) {
-    this(commit.nextSyntheticId, commit.committed);
+    this(commit.nextSyntheticId, commit.legacySyntheticTypes, commit.syntheticItems);
   }
 
-  private SyntheticItems(int nextSyntheticId, CommittedSyntheticsCollection committed) {
+  private SyntheticItems(
+      int nextSyntheticId,
+      ImmutableSet<DexType> legacySyntheticTypes,
+      ImmutableMap<DexType, SyntheticReference> nonLecacySyntheticItems) {
     this.nextSyntheticId = nextSyntheticId;
-    this.committed = committed;
+    this.legacySyntheticTypes = legacySyntheticTypes;
+    this.nonLecacySyntheticItems = nonLecacySyntheticItems;
+    assert Sets.intersection(nonLecacySyntheticItems.keySet(), legacySyntheticTypes).isEmpty();
   }
 
   public static void collectSyntheticInputs(AppView<AppInfo> appView) {
     // Collecting synthetic items must be the very first task after application build.
     SyntheticItems synthetics = appView.getSyntheticItems();
     assert synthetics.nextSyntheticId == 0;
-    assert synthetics.committed.isEmpty();
-    assert synthetics.pending.isEmpty();
+    assert synthetics.nonLecacySyntheticItems.isEmpty();
+    assert !synthetics.hasPendingSyntheticClasses();
     if (appView.options().intermediate) {
       // If the compilation is in intermediate mode the synthetics should just be passed through.
       return;
     }
-    CommittedSyntheticsCollection.Builder builder = synthetics.committed.builder();
+    ImmutableMap.Builder<DexType, SyntheticReference> pending = ImmutableMap.builder();
     // TODO(b/158159959): Consider identifying synthetics in the input reader to speed this up.
     for (DexProgramClass clazz : appView.appInfo().classes()) {
-      SyntheticMarker marker =
-          SyntheticMarker.stripMarkerFromClass(clazz, appView.dexItemFactory());
-      if (marker.isSyntheticMethods()) {
-        clazz.forEachProgramMethod(
-            // TODO(b/158159959): Support having multiple methods per class.
-            method -> {
-              builder.addNonLegacyMethod(
-                  new SyntheticMethodDefinition(marker.getKind(), marker.getContext(), method));
-            });
-      } else if (marker.isSyntheticClass()) {
-        builder.addNonLegacyClass(
-            new SyntheticClassDefinition(marker.getKind(), marker.getContext(), clazz));
+      DexType annotatedContextType = isSynthesizedMethodsContainer(clazz, appView.dexItemFactory());
+      if (annotatedContextType == null) {
+        continue;
       }
+      clazz.setAnnotations(DexAnnotationSet.empty());
+      SynthesizingContext context =
+          SynthesizingContext.fromSyntheticInputClass(clazz, annotatedContextType);
+      clazz.forEachProgramMethod(
+          // TODO(b/158159959): Support having multiple methods per class.
+          method -> {
+            method.getDefinition().setAnnotations(DexAnnotationSet.empty());
+            pending.put(clazz.type, new SyntheticMethodDefinition(context, method).toReference());
+          });
     }
-    CommittedSyntheticsCollection committed = builder.build();
-    if (committed.isEmpty()) {
+    pending.putAll(synthetics.nonLecacySyntheticItems);
+    ImmutableMap<DexType, SyntheticReference> nonLegacySyntheticItems = pending.build();
+    if (nonLegacySyntheticItems.isEmpty()) {
       return;
     }
     CommittedItems commit =
         new CommittedItems(
-            synthetics.nextSyntheticId, appView.appInfo().app(), committed, ImmutableList.of());
+            synthetics.nextSyntheticId,
+            appView.appInfo().app(),
+            synthetics.legacySyntheticTypes,
+            nonLegacySyntheticItems,
+            ImmutableList.of());
     appView.setAppInfo(new AppInfo(commit, appView.appInfo().getMainDexClasses()));
   }
 
+  private static DexType isSynthesizedMethodsContainer(
+      DexProgramClass clazz, DexItemFactory factory) {
+    ClassAccessFlags flags = clazz.accessFlags;
+    if (!flags.isSynthetic() || flags.isAbstract() || flags.isEnum()) {
+      return null;
+    }
+    DexType contextType =
+        DexAnnotation.getSynthesizedClassAnnotationContextType(clazz.annotations(), factory);
+    if (contextType == null) {
+      return null;
+    }
+    if (clazz.superType != factory.objectType) {
+      return null;
+    }
+    if (!clazz.interfaces.isEmpty()) {
+      return null;
+    }
+    if (clazz.annotations().size() != 1) {
+      return null;
+    }
+    for (DexEncodedMethod method : clazz.methods()) {
+      if (!SyntheticMethodBuilder.isValidSyntheticMethod(method)) {
+        return null;
+      }
+    }
+    return contextType;
+  }
+
   // Internal synthetic id creation helpers.
 
   private synchronized String getNextSyntheticId() {
@@ -148,52 +191,49 @@
 
   @Override
   public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
-    DexProgramClass clazz = pending.legacyClasses.get(type);
-    if (clazz == null) {
-      SyntheticDefinition<?, ?> item = pending.nonLegacyDefinitions.get(type);
+    DexProgramClass pending = legacyPendingClasses.get(type);
+    if (pending == null) {
+      SyntheticDefinition item = pendingDefinitions.get(type);
       if (item != null) {
-        clazz = item.getHolder();
+        pending = item.getHolder();
       }
     }
-    if (clazz != null) {
+    if (pending != null) {
       assert baseDefinitionFor.apply(type) == null
           : "Pending synthetic definition also present in the active program: " + type;
-      return clazz;
+      return pending;
     }
     return baseDefinitionFor.apply(type);
   }
 
-  public boolean verifyNonLegacySyntheticsAreCommitted() {
-    assert pending.nonLegacyDefinitions.isEmpty()
-        : "Uncommitted synthetics: "
-            + pending.nonLegacyDefinitions.keySet().stream()
-                .map(DexType::getName)
-                .collect(Collectors.joining());
-    return true;
-  }
-
   public boolean hasPendingSyntheticClasses() {
-    return !pending.isEmpty();
+    return !legacyPendingClasses.isEmpty() || !pendingDefinitions.isEmpty();
   }
 
   public Collection<DexProgramClass> getPendingSyntheticClasses() {
-    return pending.getAllClasses();
+    List<DexProgramClass> pending =
+        new ArrayList<>(pendingDefinitions.size() + legacyPendingClasses.size());
+    for (SyntheticDefinition item : pendingDefinitions.values()) {
+      pending.add(item.getHolder());
+    }
+    pending.addAll(legacyPendingClasses.values());
+    return Collections.unmodifiableList(pending);
   }
 
   private boolean isCommittedSynthetic(DexType type) {
-    return committed.containsType(type);
+    return nonLecacySyntheticItems.containsKey(type) || legacySyntheticTypes.contains(type);
   }
 
   private boolean isLegacyCommittedSynthetic(DexType type) {
-    return committed.containsLegacyType(type);
+    return legacySyntheticTypes.contains(type);
   }
 
   public boolean isPendingSynthetic(DexType type) {
-    return pending.containsType(type);
+    return pendingDefinitions.containsKey(type) || legacyPendingClasses.containsKey(type);
   }
 
   public boolean isLegacyPendingSynthetic(DexType type) {
-    return pending.legacyClasses.containsKey(type);
+    return legacyPendingClasses.containsKey(type);
   }
 
   public boolean isSyntheticClass(DexType type) {
@@ -207,27 +247,6 @@
     return isSyntheticClass(clazz.type);
   }
 
-  // The compiler should not inspect the kind of a synthetic, so this provided only as a assertion
-  // utility.
-  public boolean verifySyntheticLambdaProperty(
-      DexProgramClass clazz,
-      Predicate<DexProgramClass> ifIsLambda,
-      Predicate<DexProgramClass> ifNotLambda) {
-    SyntheticReference<?, ?> reference = committed.getNonLegacyItem(clazz.getType());
-    if (reference == null) {
-      SyntheticDefinition<?, ?> definition = pending.nonLegacyDefinitions.get(clazz.getType());
-      if (definition != null) {
-        reference = definition.toReference();
-      }
-    }
-    if (reference != null && reference.getKind() == SyntheticKind.LAMBDA) {
-      assert ifIsLambda.test(clazz);
-    } else {
-      assert ifNotLambda.test(clazz);
-    }
-    return true;
-  }
-
   public boolean isLegacySyntheticClass(DexType type) {
     return isLegacyCommittedSynthetic(type) || isLegacyPendingSynthetic(type);
   }
@@ -237,21 +256,18 @@
   }
 
   public Collection<DexProgramClass> getLegacyPendingClasses() {
-    return Collections.unmodifiableCollection(pending.legacyClasses.values());
+    return Collections.unmodifiableCollection(legacyPendingClasses.values());
   }
 
   private SynthesizingContext getSynthesizingContext(ProgramDefinition context) {
-    DexType contextType = context.getContextType();
-    SyntheticDefinition<?, ?> existingDefinition = pending.nonLegacyDefinitions.get(contextType);
-    if (existingDefinition != null) {
-      return existingDefinition.getContext();
+    SyntheticDefinition pendingItemContext = pendingDefinitions.get(context.getContextType());
+    if (pendingItemContext != null) {
+      return pendingItemContext.getContext();
     }
-    SyntheticReference<?, ?> existingReference = committed.getNonLegacyItem(contextType);
-    if (existingReference != null) {
-      return existingReference.getContext();
-    }
-    // This context is not nested in an existing synthetic context so create a new "leaf" context.
-    return SynthesizingContext.fromNonSyntheticInputContext(context);
+    SyntheticReference committedItemContext = nonLecacySyntheticItems.get(context.getContextType());
+    return committedItemContext != null
+        ? committedItemContext.getContext()
+        : SynthesizingContext.fromNonSyntheticInputContext(context);
   }
 
   // Addition and creation of synthetic items.
@@ -260,49 +276,25 @@
   public void addLegacySyntheticClass(DexProgramClass clazz) {
     assert clazz.type.isD8R8SynthesizedClassType();
     assert !isCommittedSynthetic(clazz.type);
-    assert !pending.nonLegacyDefinitions.containsKey(clazz.type);
-    DexProgramClass previous = pending.legacyClasses.put(clazz.type, clazz);
+    DexProgramClass previous = legacyPendingClasses.put(clazz.type, clazz);
     assert previous == null || previous == clazz;
   }
 
-  public DexProgramClass createClass(
-      SyntheticKind kind,
-      DexProgramClass context,
-      DexItemFactory factory,
-      Consumer<SyntheticClassBuilder> fn) {
-    // Obtain the outer synthesizing context in the case the context itself is synthetic.
-    // This is to ensure a flat input-type -> synthetic-item mapping.
-    SynthesizingContext outerContext = getSynthesizingContext(context);
-    DexType type =
-        SyntheticNaming.createInternalType(kind, outerContext, getNextSyntheticId(), factory);
-    SyntheticClassBuilder classBuilder = new SyntheticClassBuilder(type, outerContext, factory);
-    fn.accept(classBuilder);
-    DexProgramClass clazz = classBuilder.build();
-    addPendingDefinition(new SyntheticClassDefinition(kind, outerContext, clazz));
-    return clazz;
-  }
-
   /** Create a single synthetic method item. */
   public ProgramMethod createMethod(
-      SyntheticKind kind,
-      ProgramDefinition context,
-      DexItemFactory factory,
-      Consumer<SyntheticMethodBuilder> fn) {
-    return createMethod(kind, context, factory, fn, this::getNextSyntheticId);
+      ProgramDefinition context, DexItemFactory factory, Consumer<SyntheticMethodBuilder> fn) {
+    return createMethod(context, factory, fn, this::getNextSyntheticId);
   }
 
   public ProgramMethod createMethod(
-      SyntheticKind kind,
       ProgramDefinition context,
       DexItemFactory factory,
       Consumer<SyntheticMethodBuilder> fn,
       MethodProcessingId methodProcessingId) {
-    return createMethod(
-        kind, context, factory, fn, methodProcessingId::getFullyQualifiedIdAndIncrement);
+    return createMethod(context, factory, fn, methodProcessingId::getFullyQualifiedIdAndIncrement);
   }
 
   private ProgramMethod createMethod(
-      SyntheticKind kind,
       ProgramDefinition context,
       DexItemFactory factory,
       Consumer<SyntheticMethodBuilder> fn,
@@ -311,20 +303,16 @@
     // Obtain the outer synthesizing context in the case the context itself is synthetic.
     // This is to ensure a flat input-type -> synthetic-item mapping.
     SynthesizingContext outerContext = getSynthesizingContext(context);
-    DexType type =
-        SyntheticNaming.createInternalType(kind, outerContext, syntheticIdSupplier.get(), factory);
+    DexType type = outerContext.createHygienicType(syntheticIdSupplier.get(), factory);
     SyntheticClassBuilder classBuilder = new SyntheticClassBuilder(type, outerContext, factory);
-    DexProgramClass clazz =
-        classBuilder
-            .addMethod(fn.andThen(m -> m.setName(SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX)))
-            .build();
+    DexProgramClass clazz = classBuilder.addMethod(fn).build();
     ProgramMethod method = new ProgramMethod(clazz, clazz.methods().iterator().next());
-    addPendingDefinition(new SyntheticMethodDefinition(kind, outerContext, method));
+    addPendingDefinition(new SyntheticMethodDefinition(outerContext, method));
     return method;
   }
 
-  private void addPendingDefinition(SyntheticDefinition<?, ?> definition) {
-    pending.nonLegacyDefinitions.put(definition.getHolder().getType(), definition);
+  private void addPendingDefinition(SyntheticDefinition definition) {
+    pendingDefinitions.put(definition.getHolder().getType(), definition);
   }
 
   // Commit of the synthetic items to a new fully populated application.
@@ -334,48 +322,125 @@
   }
 
   public CommittedItems commitPrunedItems(PrunedItems prunedItems) {
-    return commit(prunedItems, pending, committed, nextSyntheticId);
+    return commit(
+        prunedItems.getPrunedApp(),
+        prunedItems.getNoLongerSyntheticItems(),
+        legacyPendingClasses,
+        legacySyntheticTypes,
+        pendingDefinitions,
+        nonLecacySyntheticItems,
+        nextSyntheticId);
   }
 
   public CommittedItems commitRewrittenWithLens(
       DexApplication application, NonIdentityGraphLens lens) {
-    assert pending.verifyNotRewritten(lens);
+    // Rewrite the previously committed synthetic types.
+    ImmutableSet<DexType> rewrittenLegacyTypes = lens.rewriteTypes(this.legacySyntheticTypes);
+    ImmutableMap.Builder<DexType, SyntheticReference> rewrittenItems = ImmutableMap.builder();
+    for (SyntheticReference reference : nonLecacySyntheticItems.values()) {
+      SyntheticReference rewritten = reference.rewrite(lens);
+      if (rewritten != null) {
+        rewrittenItems.put(rewritten.getHolder(), rewritten);
+      }
+    }
+    // No pending item should need rewriting.
+    assert legacyPendingClasses.keySet().equals(lens.rewriteTypes(legacyPendingClasses.keySet()));
+    assert pendingDefinitions.keySet().equals(lens.rewriteTypes(pendingDefinitions.keySet()));
     return commit(
-        PrunedItems.empty(application), pending, committed.rewriteWithLens(lens), nextSyntheticId);
+        application,
+        Collections.emptySet(),
+        legacyPendingClasses,
+        rewrittenLegacyTypes,
+        pendingDefinitions,
+        rewrittenItems.build(),
+        nextSyntheticId);
   }
 
   private static CommittedItems commit(
-      PrunedItems prunedItems,
-      PendingSynthetics pending,
-      CommittedSyntheticsCollection committed,
+      DexApplication application,
+      Set<DexType> removedClasses,
+      Map<DexType, DexProgramClass> legacyPendingClasses,
+      ImmutableSet<DexType> legacySyntheticTypes,
+      ConcurrentHashMap<DexType, SyntheticDefinition> pendingDefinitions,
+      ImmutableMap<DexType, SyntheticReference> syntheticItems,
       int nextSyntheticId) {
-    DexApplication application = prunedItems.getPrunedApp();
-    Set<DexType> removedClasses = prunedItems.getNoLongerSyntheticItems();
-    CommittedSyntheticsCollection.Builder builder = committed.builder();
-    // Legacy synthetics must already have been committed to the app.
-    assert verifyClassesAreInApp(application, pending.legacyClasses.values());
-    builder.addLegacyClasses(pending.legacyClasses.values());
-    // Compute the synthetic additions and add them to the application.
+    // Legacy synthetics must already have been committed.
+    assert verifyClassesAreInApp(application, legacyPendingClasses.values());
+    // Add the set of legacy definitions to the synthetic types.
+    ImmutableSet<DexType> mergedLegacyTypes = legacySyntheticTypes;
+    if (!legacyPendingClasses.isEmpty() || !removedClasses.isEmpty()) {
+      ImmutableSet.Builder<DexType> legacyBuilder = ImmutableSet.builder();
+      filteredAdd(legacySyntheticTypes, removedClasses, legacyBuilder);
+      filteredAdd(legacyPendingClasses.keySet(), removedClasses, legacyBuilder);
+      mergedLegacyTypes = legacyBuilder.build();
+    }
+    // The set of synthetic items is the union of the previous types plus the pending additions.
+    ImmutableMap<DexType, SyntheticReference> mergedItems;
     ImmutableList<DexType> additions;
     DexApplication amendedApplication;
-    if (pending.nonLegacyDefinitions.isEmpty()) {
+    if (pendingDefinitions.isEmpty()) {
+      mergedItems = filteredCopy(syntheticItems, removedClasses);
       additions = ImmutableList.of();
       amendedApplication = application;
     } else {
       DexApplication.Builder<?> appBuilder = application.builder();
+      ImmutableMap.Builder<DexType, SyntheticReference> itemsBuilder = ImmutableMap.builder();
       ImmutableList.Builder<DexType> additionsBuilder = ImmutableList.builder();
-      for (SyntheticDefinition<?, ?> definition : pending.nonLegacyDefinitions.values()) {
-        if (!removedClasses.contains(definition.getHolder().getType())) {
-          additionsBuilder.add(definition.getHolder().getType());
-          appBuilder.addProgramClass(definition.getHolder());
-          builder.addItem(definition);
+      for (SyntheticDefinition definition : pendingDefinitions.values()) {
+        if (removedClasses.contains(definition.getHolder().getType())) {
+          continue;
         }
+        SyntheticReference reference = definition.toReference();
+        itemsBuilder.put(reference.getHolder(), reference);
+        additionsBuilder.add(definition.getHolder().getType());
+        appBuilder.addProgramClass(definition.getHolder());
       }
+      filteredAdd(syntheticItems, removedClasses, itemsBuilder);
+      mergedItems = itemsBuilder.build();
       additions = additionsBuilder.build();
       amendedApplication = appBuilder.build();
     }
     return new CommittedItems(
-        nextSyntheticId, amendedApplication, builder.build().pruneItems(prunedItems), additions);
+        nextSyntheticId, amendedApplication, mergedLegacyTypes, mergedItems, additions);
+  }
+
+  private static void filteredAdd(
+      Set<DexType> input, Set<DexType> excludeSet, Builder<DexType> result) {
+    if (excludeSet.isEmpty()) {
+      result.addAll(input);
+    } else {
+      for (DexType type : input) {
+        if (!excludeSet.contains(type)) {
+          result.add(type);
+        }
+      }
+    }
+  }
+
+  private static ImmutableMap<DexType, SyntheticReference> filteredCopy(
+      ImmutableMap<DexType, SyntheticReference> syntheticItems, Set<DexType> removedClasses) {
+    if (removedClasses.isEmpty()) {
+      return syntheticItems;
+    }
+    ImmutableMap.Builder<DexType, SyntheticReference> builder = ImmutableMap.builder();
+    filteredAdd(syntheticItems, removedClasses, builder);
+    return builder.build();
+  }
+
+  private static void filteredAdd(
+      ImmutableMap<DexType, SyntheticReference> syntheticItems,
+      Set<DexType> removedClasses,
+      ImmutableMap.Builder<DexType, SyntheticReference> builder) {
+    if (removedClasses.isEmpty()) {
+      builder.putAll(syntheticItems);
+    } else {
+      syntheticItems.forEach(
+          (t, r) -> {
+            if (!removedClasses.contains(t)) {
+              builder.put(t, r);
+            }
+          });
+    }
   }
 
   private static boolean verifyClassesAreInApp(
@@ -390,6 +455,8 @@
 
   public Result computeFinalSynthetics(AppView<?> appView) {
     assert !hasPendingSyntheticClasses();
-    return new SyntheticFinalization(appView.options(), committed).computeFinalSynthetics(appView);
+    return new SyntheticFinalization(
+            appView.options(), legacySyntheticTypes, nonLecacySyntheticItems)
+        .computeFinalSynthetics(appView);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMarker.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMarker.java
deleted file mode 100644
index 03b7e36..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMarker.java
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright (c) 2020, 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.synthesis;
-
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import com.android.tools.r8.utils.Pair;
-
-public class SyntheticMarker {
-
-  public static void addMarkerToClass(
-      DexProgramClass clazz,
-      SyntheticKind kind,
-      SynthesizingContext context,
-      DexItemFactory factory) {
-    clazz.setAnnotations(
-        clazz
-            .annotations()
-            .getWithAddedOrReplaced(
-                DexAnnotation.createAnnotationSynthesizedClass(
-                    kind, context.getSynthesizingContextType(), factory)));
-  }
-
-  public static SyntheticMarker stripMarkerFromClass(
-      DexProgramClass clazz, DexItemFactory factory) {
-    SyntheticMarker marker = internalStripMarkerFromClass(clazz, factory);
-    assert marker != NO_MARKER
-        || DexAnnotation.getSynthesizedClassAnnotationContextType(clazz.annotations(), factory)
-            == null;
-    return marker;
-  }
-
-  private static SyntheticMarker internalStripMarkerFromClass(
-      DexProgramClass clazz, DexItemFactory factory) {
-    ClassAccessFlags flags = clazz.accessFlags;
-    if (clazz.superType != factory.objectType) {
-      return NO_MARKER;
-    }
-    if (!flags.isSynthetic() || flags.isAbstract() || flags.isEnum()) {
-      return NO_MARKER;
-    }
-    Pair<SyntheticKind, DexType> info =
-        DexAnnotation.getSynthesizedClassAnnotationContextType(clazz.annotations(), factory);
-    if (info == null) {
-      return NO_MARKER;
-    }
-    assert clazz.annotations().size() == 1;
-    SyntheticKind kind = info.getFirst();
-    DexType context = info.getSecond();
-    if (kind.isSingleSyntheticMethod) {
-      if (!clazz.interfaces.isEmpty()) {
-        return NO_MARKER;
-      }
-      for (DexEncodedMethod method : clazz.methods()) {
-        if (!SyntheticMethodBuilder.isValidSyntheticMethod(method)) {
-          return NO_MARKER;
-        }
-      }
-    }
-    clazz.setAnnotations(DexAnnotationSet.empty());
-    return new SyntheticMarker(kind, SynthesizingContext.fromSyntheticInputClass(clazz, context));
-  }
-
-  private static final SyntheticMarker NO_MARKER = new SyntheticMarker(null, null);
-
-  private final SyntheticKind kind;
-  private final SynthesizingContext context;
-
-  public SyntheticMarker(SyntheticKind kind, SynthesizingContext context) {
-    this.kind = kind;
-    this.context = context;
-  }
-
-  public boolean isSyntheticMethods() {
-    return kind != null && kind.isSingleSyntheticMethod;
-  }
-
-  public boolean isSyntheticClass() {
-    return kind != null && !kind.isSingleSyntheticMethod;
-  }
-
-  public SyntheticKind getKind() {
-    return kind;
-  }
-
-  public SynthesizingContext getContext() {
-    return context;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
index 60e3079..9fcc7d9 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ParameterAnnotationsList;
@@ -21,25 +20,15 @@
   }
 
   private final SyntheticClassBuilder parent;
-  private DexString name = null;
+  private final String name;
   private DexProto proto = null;
   private CfVersion classFileVersion;
   private SyntheticCodeGenerator codeGenerator = null;
   private MethodAccessFlags accessFlags = null;
 
-  SyntheticMethodBuilder(SyntheticClassBuilder parent) {
+  SyntheticMethodBuilder(SyntheticClassBuilder parent, String name) {
     this.parent = parent;
-  }
-
-  public SyntheticMethodBuilder setName(String name) {
-    return setName(parent.getFactory().createString(name));
-  }
-
-  public SyntheticMethodBuilder setName(DexString name) {
-    assert name != null;
-    assert this.name == null;
     this.name = name;
-    return this;
   }
 
   public SyntheticMethodBuilder setProto(DexProto proto) {
@@ -63,7 +52,6 @@
   }
 
   DexEncodedMethod build() {
-    assert name != null;
     boolean isCompilerSynthesized = true;
     DexMethod methodSignature = getMethodSignature();
     DexEncodedMethod method =
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
index 0ba1127..ecc1a81 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
@@ -3,24 +3,27 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.synthesis;
 
+import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.structural.RepresentativeMap;
+import com.google.common.hash.HashCode;
 import com.google.common.hash.Hasher;
+import com.google.common.hash.Hashing;
+import java.util.Comparator;
 
 /**
  * Definition of a synthetic method item.
  *
  * <p>This class is internal to the synthetic items collection, thus package-protected.
  */
-class SyntheticMethodDefinition
-    extends SyntheticDefinition<SyntheticMethodReference, SyntheticMethodDefinition> {
+class SyntheticMethodDefinition extends SyntheticDefinition
+    implements Comparable<SyntheticMethodDefinition> {
 
   private final ProgramMethod method;
 
-  SyntheticMethodDefinition(SyntheticKind kind, SynthesizingContext context, ProgramMethod method) {
-    super(kind, context);
+  SyntheticMethodDefinition(SynthesizingContext context, ProgramMethod method) {
+    super(context);
     this.method = method;
   }
 
@@ -29,8 +32,8 @@
   }
 
   @Override
-  SyntheticMethodReference toReference() {
-    return new SyntheticMethodReference(getKind(), getContext(), method.getReference());
+  SyntheticReference toReference() {
+    return new SyntheticMethodReference(getContext(), method.getReference());
   }
 
   @Override
@@ -39,18 +42,39 @@
   }
 
   @Override
-  void internalComputeHash(Hasher hasher, RepresentativeMap map) {
-    method.getDefinition().hashWithTypeEquivalence(hasher, map);
+  HashCode computeHash(RepresentativeMap map, boolean intermediate) {
+    Hasher hasher = Hashing.sha256().newHasher();
+    if (intermediate) {
+      // If in intermediate mode, include the context type as sharing is restricted to within a
+      // single context.
+      hasher.putInt(getContext().getSynthesizingContextType().hashCode());
+    }
+    method.getDefinition().hashSyntheticContent(hasher, map);
+    return hasher.hash();
   }
 
   @Override
-  int internalCompareTo(SyntheticMethodDefinition other, RepresentativeMap map) {
-    return method.getDefinition().compareWithTypeEquivalenceTo(other.method.getDefinition(), map);
+  boolean isEquivalentTo(SyntheticDefinition other, boolean intermediate) {
+    if (!(other instanceof SyntheticMethodDefinition)) {
+      return false;
+    }
+    if (intermediate
+        && getContext().getSynthesizingContextType()
+            != other.getContext().getSynthesizingContextType()) {
+      // If in intermediate mode, only synthetics within the same context should be considered
+      // equal.
+      return false;
+    }
+    SyntheticMethodDefinition o = (SyntheticMethodDefinition) other;
+    return method.getDefinition().isSyntheticContentEqual(o.method.getDefinition());
   }
 
+  // Since methods are sharable they must define an order from which representatives can be found.
   @Override
-  public boolean isValid() {
-    return SyntheticMethodBuilder.isValidSyntheticMethod(method.getDefinition());
+  public int compareTo(SyntheticMethodDefinition other) {
+    return Comparator.comparing(SyntheticMethodDefinition::getContext)
+        .thenComparing(m -> m.method.getDefinition(), DexEncodedMethod::syntheticCompareTo)
+        .compare(this, other);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
index 39d68ed..28913d0 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
@@ -5,11 +5,10 @@
 
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import java.util.function.Consumer;
 import java.util.function.Function;
 
 /**
@@ -17,35 +16,37 @@
  *
  * <p>This class is internal to the synthetic items collection, thus package-protected.
  */
-class SyntheticMethodReference
-    extends SyntheticReference<SyntheticMethodReference, SyntheticMethodDefinition> {
+class SyntheticMethodReference extends SyntheticReference {
   final DexMethod method;
 
-  SyntheticMethodReference(SyntheticKind kind, SynthesizingContext context, DexMethod method) {
-    super(kind, context);
+  SyntheticMethodReference(SynthesizingContext context, DexMethod method) {
+    super(context);
     this.method = method;
   }
 
   @Override
+  DexReference getReference() {
+    return method;
+  }
+
+  @Override
   DexType getHolder() {
     return method.holder;
   }
 
   @Override
-  SyntheticMethodDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
+  SyntheticDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
     DexClass clazz = definitions.apply(method.holder);
     if (clazz == null) {
       return null;
     }
     assert clazz.isProgramClass();
     ProgramMethod definition = clazz.asProgramClass().lookupProgramMethod(method);
-    return definition != null
-        ? new SyntheticMethodDefinition(getKind(), getContext(), definition)
-        : null;
+    return definition != null ? new SyntheticMethodDefinition(getContext(), definition) : null;
   }
 
   @Override
-  SyntheticMethodReference rewrite(NonIdentityGraphLens lens) {
+  SyntheticReference rewrite(NonIdentityGraphLens lens) {
     DexMethod rewritten = lens.lookupMethod(method);
     // If the reference has been non-trivially rewritten the compiler has changed it and it can no
     // longer be considered a synthetic. The context may or may not have changed.
@@ -53,18 +54,12 @@
       // If the referenced item is rewritten, it should be moved to another holder as the
       // synthetic holder is no longer part of the synthetic collection.
       assert method.holder != rewritten.holder;
-      assert SyntheticNaming.verifyNotInternalSynthetic(rewritten.holder);
+      assert SyntheticItems.verifyNotInternalSynthetic(rewritten.holder);
       return null;
     }
     SynthesizingContext context = getContext().rewrite(lens);
     return context == getContext() && rewritten == method
         ? this
-        : new SyntheticMethodReference(getKind(), context, rewritten);
-  }
-
-  @Override
-  void apply(
-      Consumer<SyntheticMethodReference> onMethod, Consumer<SyntheticClassReference> onClass) {
-    onMethod.accept(this);
+        : new SyntheticMethodReference(context, rewritten);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
deleted file mode 100644
index 644a359..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright (c) 2020, 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.synthesis;
-
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.utils.DescriptorUtils;
-
-public class SyntheticNaming {
-
-  /**
-   * Enumeration of all kinds of synthetic items.
-   *
-   * <p>The synthetic kinds are used to provide hinting about what a synthetic item represents. The
-   * kinds must *not* be used be the compiler and are only meant for "debugging". The compiler and
-   * its test may use the kind information as part of asserting properties of the compiler. The kind
-   * will be put into any non-minified synthetic name and thus the kind "descriptor" must be a
-   * distinct for each kind.
-   */
-  public enum SyntheticKind {
-    // Class synthetics.
-    LAMBDA("Lambda", false),
-    // Method synthetics.
-    BACKPORT("Backport", true),
-    STATIC_INTERFACE_CALL("StaticInterfaceCall", true),
-    TO_STRING_IF_NOT_NULL("ToStringIfNotNull", true),
-    THROW_CCE_IF_NOT_NULL("ThrowCCEIfNotNull", true);
-
-    public final String descriptor;
-    public final boolean isSingleSyntheticMethod;
-
-    SyntheticKind(String descriptor, boolean isSingleSyntheticMethod) {
-      this.descriptor = descriptor;
-      this.isSingleSyntheticMethod = isSingleSyntheticMethod;
-    }
-
-    public static SyntheticKind fromDescriptor(String descriptor) {
-      for (SyntheticKind kind : values()) {
-        if (kind.descriptor.equals(descriptor)) {
-          return kind;
-        }
-      }
-      return null;
-    }
-  }
-
-  /**
-   * The internal synthetic class separator is only used for representing synthetic items during
-   * compilation. In particular, this separator must never be used to write synthetic classes to the
-   * final compilation result.
-   */
-  private static final String INTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$InternalSynthetic";
-  /**
-   * The external synthetic class separator is used when writing classes. It may appear in types
-   * during compilation as the output of a compilation may be the input to another.
-   */
-  private static final String EXTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$ExternalSynthetic";
-  /** Method prefix when generating synthetic methods in a class. */
-  static final String INTERNAL_SYNTHETIC_METHOD_PREFIX = "m";
-
-  // TODO(b/158159959): Remove usage of name-based identification.
-  public static boolean isSyntheticName(String typeName) {
-    return typeName.contains(INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
-        || typeName.contains(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR);
-  }
-
-  static DexType createInternalType(
-      SyntheticKind kind, SynthesizingContext context, String id, DexItemFactory factory) {
-    return createType(
-        INTERNAL_SYNTHETIC_CLASS_SEPARATOR,
-        kind,
-        context.getSynthesizingContextType(),
-        id,
-        factory);
-  }
-
-  static DexType createExternalType(
-      SyntheticKind kind, DexType context, String id, DexItemFactory factory) {
-    return createType(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR, kind, context, id, factory);
-  }
-
-  private static DexType createType(
-      String separator, SyntheticKind kind, DexType context, String id, DexItemFactory factory) {
-    return factory.createType(createDescriptor(separator, kind, context.getInternalName(), id));
-  }
-
-  private static String createDescriptor(
-      String separator, SyntheticKind kind, String context, String id) {
-    return DescriptorUtils.getDescriptorFromClassBinaryName(
-        context + separator + kind.descriptor + id);
-  }
-
-  public static boolean verifyNotInternalSynthetic(DexType type) {
-    return verifyNotInternalSynthetic(type.toDescriptorString());
-  }
-
-  public static boolean verifyNotInternalSynthetic(ClassReference reference) {
-    return verifyNotInternalSynthetic(reference.getDescriptor());
-  }
-
-  public static boolean verifyNotInternalSynthetic(String typeBinaryNameOrDescriptor) {
-    assert !typeBinaryNameOrDescriptor.contains(INTERNAL_SYNTHETIC_CLASS_SEPARATOR);
-    return true;
-  }
-
-  // Visible via package protection in SyntheticItemsTestUtils.
-
-  enum Phase {
-    INTERNAL,
-    EXTERNAL
-  }
-
-  static String getPhaseSeparator(Phase phase) {
-    assert phase != null;
-    return phase == Phase.INTERNAL
-        ? INTERNAL_SYNTHETIC_CLASS_SEPARATOR
-        : EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
-  }
-
-  static ClassReference makeSyntheticReferenceForTest(
-      ClassReference context, SyntheticKind kind, String id) {
-    return Reference.classFromDescriptor(
-        createDescriptor(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR, kind, context.getBinaryName(), id));
-  }
-
-  static boolean isSynthetic(ClassReference clazz, Phase phase, SyntheticKind kind) {
-    String typeName = clazz.getTypeName();
-    String separator = getPhaseSeparator(phase);
-    int i = typeName.indexOf(separator);
-    return i >= 0 && checkMatchFrom(kind, typeName, i, separator);
-  }
-
-  private static boolean checkMatchFrom(
-      SyntheticKind kind, String name, int i, String externalSyntheticClassSeparator) {
-    int end = i + externalSyntheticClassSeparator.length() + kind.descriptor.length();
-    if (end >= name.length()) {
-      return false;
-    }
-    String prefix = name.substring(i, end);
-    return prefix.equals(externalSyntheticClassSeparator + kind.descriptor)
-        && isInt(name.substring(end));
-  }
-
-  private static boolean isInt(String str) {
-    if (str.isEmpty()) {
-      return false;
-    }
-    if ('0' == str.charAt(0)) {
-      return str.length() == 1;
-    }
-    for (int i = 0; i < str.length(); i++) {
-      if (!Character.isDigit(str.charAt(i))) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
index ea33564..6618378 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
@@ -4,10 +4,9 @@
 package com.android.tools.r8.synthesis;
 
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import java.util.function.Consumer;
 import java.util.function.Function;
 
 /**
@@ -15,24 +14,16 @@
  *
  * <p>This class is internal to the synthetic items collection, thus package-protected.
  */
-abstract class SyntheticReference<
-    R extends SyntheticReference<R, D>, D extends SyntheticDefinition<R, D>> {
-
-  private final SyntheticKind kind;
+abstract class SyntheticReference {
   private final SynthesizingContext context;
 
-  SyntheticReference(SyntheticKind kind, SynthesizingContext context) {
-    assert kind != null;
-    assert context != null;
-    this.kind = kind;
+  SyntheticReference(SynthesizingContext context) {
     this.context = context;
   }
 
-  abstract D lookupDefinition(Function<DexType, DexClass> definitions);
+  abstract SyntheticDefinition lookupDefinition(Function<DexType, DexClass> definitions);
 
-  final SyntheticKind getKind() {
-    return kind;
-  }
+  abstract DexReference getReference();
 
   final SynthesizingContext getContext() {
     return context;
@@ -40,8 +31,5 @@
 
   abstract DexType getHolder();
 
-  abstract R rewrite(NonIdentityGraphLens lens);
-
-  abstract void apply(
-      Consumer<SyntheticMethodReference> onMethod, Consumer<SyntheticClassReference> onClass);
+  abstract SyntheticReference rewrite(NonIdentityGraphLens lens);
 }
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 62196ab..985090a 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1275,7 +1275,6 @@
 
     public boolean enable = true;
     public boolean enableConstructorMerging = true;
-    // TODO(b/174809311): Update or remove the option and its tests after new lambdas synthetics.
     public boolean enableJavaLambdaMerging = false;
     public boolean enableKotlinLambdaMerging = true;
 
@@ -1469,8 +1468,6 @@
     public boolean allowInvalidCfAccessFlags =
         System.getProperty("com.android.tools.r8.allowInvalidCfAccessFlags") != null;
 
-    public boolean allowConflictingSyntheticTypes = false;
-
     // Flag to allow processing of resources in D8. A data resource consumer still needs to be
     // specified.
     public boolean enableD8ResourcesPassThrough = false;
diff --git a/src/main/java/com/android/tools/r8/utils/ListUtils.java b/src/main/java/com/android/tools/r8/utils/ListUtils.java
index fe6feab..40ae9ce 100644
--- a/src/main/java/com/android/tools/r8/utils/ListUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ListUtils.java
@@ -40,14 +40,6 @@
     return -1;
   }
 
-  public static <S, T> List<T> map(Iterable<S> list, Function<S, T> fn) {
-    List<T> result = new ArrayList<>();
-    for (S element : list) {
-      result.add(fn.apply(element));
-    }
-    return result;
-  }
-
   public static <S, T> List<T> map(Collection<S> list, Function<S, T> fn) {
     List<T> result = new ArrayList<>(list.size());
     for (S element : list) {
diff --git a/src/main/java/com/android/tools/r8/utils/Pair.java b/src/main/java/com/android/tools/r8/utils/Pair.java
index c2f3489..ac58f56 100644
--- a/src/main/java/com/android/tools/r8/utils/Pair.java
+++ b/src/main/java/com/android/tools/r8/utils/Pair.java
@@ -50,9 +50,4 @@
   public boolean equals(Object obj) {
     throw new Unreachable("Pair does not want to support equality!");
   }
-
-  @Override
-  public String toString() {
-    return "Pair{" + first + ", " + second + '}';
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java
index c721599..234732c 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java
@@ -18,39 +18,29 @@
 /** Base class to share most visiting methods */
 public abstract class CompareToVisitorBase extends CompareToVisitor {
 
-  private static boolean DEBUG = false;
-
-  // Helper to debug insert a breakpoint on order values.
-  public static int debug(int order) {
-    if (DEBUG && order != 0) {
-      return order;
-    }
-    return order;
-  }
-
   @Override
   public final int visitBool(boolean value1, boolean value2) {
-    return debug(Boolean.compare(value1, value2));
+    return Boolean.compare(value1, value2);
   }
 
   @Override
   public final int visitInt(int value1, int value2) {
-    return debug(Integer.compare(value1, value2));
+    return Integer.compare(value1, value2);
   }
 
   @Override
   public int visitLong(long value1, long value2) {
-    return debug(Long.compare(value1, value2));
+    return Long.compare(value1, value2);
   }
 
   @Override
   public int visitFloat(float value1, float value2) {
-    return debug(Float.compare(value1, value2));
+    return Float.compare(value1, value2);
   }
 
   @Override
   public int visitDouble(double value1, double value2) {
-    return debug(Double.compare(value1, value2));
+    return Double.compare(value1, value2);
   }
 
   @Override
@@ -63,12 +53,12 @@
     if (order == 0) {
       order = visitBool(it1.hasNext(), it2.hasNext());
     }
-    return debug(order);
+    return order;
   }
 
   @Override
   public int visitDexString(DexString string1, DexString string2) {
-    return debug(string1.compareTo(string2));
+    return string1.compareTo(string2);
   }
 
   @Override
@@ -84,19 +74,19 @@
         order = visitDexMethod(reference1.asDexMethod(), reference2.asDexMethod());
       }
     }
-    return debug(order);
+    return order;
   }
 
   @Override
   public final <S> int visit(S item1, S item2, Comparator<S> comparator) {
-    return debug(comparator.compare(item1, item2));
+    return comparator.compare(item1, item2);
   }
 
   @Override
   public final <S> int visit(S item1, S item2, StructuralMapping<S> accept) {
     ItemSpecification<S> itemVisitor = new ItemSpecification<>(item1, item2, this);
     accept.apply(itemVisitor);
-    return debug(itemVisitor.order);
+    return itemVisitor.order;
   }
 
   private static class ItemSpecification<T>
@@ -208,7 +198,7 @@
     }
 
     @Override
-    protected <S> ItemSpecification<T> withCustomItemIterator(
+    protected <S> ItemSpecification<T> withItemIterator(
         Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher) {
       if (order == 0) {
         order = parent.visitItemIterator(getter.apply(item1), getter.apply(item2), compare);
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java
index 7569929..f581065 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java
@@ -29,35 +29,34 @@
 
   @Override
   public int visitDexType(DexType type1, DexType type2) {
-    return debug(
-        namingLens
-            .lookupDescriptor(type1)
-            .acceptCompareTo(namingLens.lookupDescriptor(type2), this));
+    return namingLens
+        .lookupDescriptor(type1)
+        .acceptCompareTo(namingLens.lookupDescriptor(type2), this);
   }
 
   @Override
   public int visitDexField(DexField field1, DexField field2) {
     int order = field1.holder.acceptCompareTo(field2.holder, this);
     if (order != 0) {
-      return debug(order);
+      return order;
     }
     order = namingLens.lookupName(field1).acceptCompareTo(namingLens.lookupName(field2), this);
     if (order != 0) {
-      return debug(order);
+      return order;
     }
-    return debug(field1.type.acceptCompareTo(field2.type, this));
+    return field1.type.acceptCompareTo(field2.type, this);
   }
 
   @Override
   public int visitDexMethod(DexMethod method1, DexMethod method2) {
     int order = method1.holder.acceptCompareTo(method2.holder, this);
     if (order != 0) {
-      return debug(order);
+      return order;
     }
     order = namingLens.lookupName(method1).acceptCompareTo(namingLens.lookupName(method2), this);
     if (order != 0) {
-      return debug(order);
+      return order;
     }
-    return debug(method1.proto.acceptCompareTo(method2.proto, this));
+    return method1.proto.acceptCompareTo(method2.proto, this);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java
index ccb5c9e..89bd02b 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java
@@ -28,6 +28,6 @@
   public int visitDexType(DexType type1, DexType type2) {
     DexType repr1 = representatives.getRepresentative(type1);
     DexType repr2 = representatives.getRepresentative(type2);
-    return debug(repr1.getDescriptor().acceptCompareTo(repr2.getDescriptor(), this));
+    return repr1.getDescriptor().acceptCompareTo(repr2.getDescriptor(), this);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java b/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java
index 244d404..892183d 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java
@@ -105,7 +105,7 @@
   }
 
   @Override
-  protected <S> HashCodeVisitor<T> withCustomItemIterator(
+  protected <S> HashCodeVisitor<T> withItemIterator(
       Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher) {
     Iterator<S> it = getter.apply(item);
     while (it.hasNext()) {
diff --git a/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java b/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java
index 6c388fb..e63ac6c 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java
@@ -170,7 +170,7 @@
     }
 
     @Override
-    protected <S> ItemSpecification<T> withCustomItemIterator(
+    protected <S> ItemSpecification<T> withItemIterator(
         Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher) {
       parent.visitItemIterator(getter.apply(item), hasher);
       return this;
diff --git a/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java b/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java
index 69d8796..a81fc18 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java
@@ -51,12 +51,12 @@
       HashingAccept<S> hasher);
 
   /** Base implementation for visiting an enumeration of items. */
-  protected abstract <S> V withCustomItemIterator(
+  protected abstract <S> V withItemIterator(
       Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher);
 
   public final <S> V withCustomItemCollection(
       Function<T, Collection<S>> getter, StructuralAcceptor<S> acceptor) {
-    return withCustomItemIterator(getter.andThen(Collection::iterator), acceptor, acceptor);
+    return withItemIterator(getter.andThen(Collection::iterator), acceptor, acceptor);
   }
 
   /**
@@ -79,23 +79,24 @@
         predicate, getter, StructuralItem::acceptCompareTo, StructuralItem::acceptHashing);
   }
 
-  public final <S extends StructuralItem<S>> V withItemIterator(Function<T, Iterator<S>> getter) {
-    return withCustomItemIterator(
-        getter, StructuralItem::acceptCompareTo, StructuralItem::acceptHashing);
-  }
-
   public final <S extends StructuralItem<S>> V withItemCollection(
       Function<T, Collection<S>> getter) {
-    return withItemIterator(getter.andThen(Collection::iterator));
+    return withItemIterator(
+        getter.andThen(Collection::iterator),
+        StructuralItem::acceptCompareTo,
+        StructuralItem::acceptHashing);
   }
 
   public final <S extends StructuralItem<S>> V withItemArray(Function<T, S[]> getter) {
-    return withItemIterator(getter.andThen(a -> Arrays.asList(a).iterator()));
+    return withItemIterator(
+        getter.andThen(a -> Arrays.asList(a).iterator()),
+        StructuralItem::acceptCompareTo,
+        StructuralItem::acceptHashing);
   }
 
   public final <S extends StructuralItem<S>> V withItemArrayAllowingNullMembers(
       Function<T, S[]> getter) {
-    return withCustomItemIterator(
+    return withItemIterator(
         getter.andThen(a -> Arrays.asList(a).iterator()),
         (a, b, visitor) -> {
           if (a == null || b == null) {
diff --git a/src/test/examplesAndroidO/multidex004/ref-list-1.txt b/src/test/examplesAndroidO/multidex004/ref-list-1.txt
index c817c33..ac6e888 100644
--- a/src/test/examplesAndroidO/multidex004/ref-list-1.txt
+++ b/src/test/examplesAndroidO/multidex004/ref-list-1.txt
@@ -1,4 +1,4 @@
-Lmultidex004/MainActivity-$$ExternalSyntheticLambda0;
+Lmultidex004/-$$Lambda$MainActivity$g120D_43GXrTOaB3kfYt6wSIJh4;
 Lmultidex004/MainActivity;
 Lmultidex004/VersionInterface;
 Lmultidex004/VersionStatic;
diff --git a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
index f5348c3..726136f 100644
--- a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
@@ -13,10 +13,9 @@
 import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
+import com.android.tools.r8.ir.desugar.LambdaRewriter;
 import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -94,13 +93,12 @@
         for (String descriptor : descriptors) {
           // classes are either lambda classes used by the main class, companion classes of the main
           // interface, the main class/interface, or for JDK9, desugaring of try-with-resources.
-          ClassReference reference = Reference.classFromDescriptor(descriptor);
           Assert.assertTrue(
-              descriptor.endsWith(InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX + ";")
+              descriptor.contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX)
+                  || descriptor.endsWith(InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX + ";")
                   || descriptor.endsWith(InterfaceMethodRewriter.DISPATCH_CLASS_NAME_SUFFIX + ";")
                   || descriptor.equals(TwrCloseResourceRewriter.UTILITY_CLASS_DESCRIPTOR)
-                  || SyntheticItemsTestUtils.isExternalLambda(reference)
-                  || SyntheticItemsTestUtils.isExternalStaticInterfaceCall(reference)
+                  || descriptor.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
                   || descriptor.equals(mainClassDescriptor));
         }
         String classDescriptor =
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
index 8ca6aeb..0b9c896 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
@@ -107,7 +107,7 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = false)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 103, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 102, "lambdadesugaring"))
         .run();
 
     test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
@@ -115,7 +115,7 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = true)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 8, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 7, "lambdadesugaring"))
         .run();
   }
 
@@ -147,7 +147,7 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = false)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 103, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 102, "lambdadesugaring"))
         .run();
 
     test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
@@ -155,7 +155,7 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = true)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 8, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 7, "lambdadesugaring"))
         .run();
   }
 
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
index 63c1f18..adabb3e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
@@ -4,18 +4,16 @@
 
 package com.android.tools.r8.classmerging.horizontal;
 
+import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.codeinspector.VerticallyMergedClassesInspector;
 import java.util.Set;
 import java.util.stream.Collectors;
-import org.junit.Ignore;
 import org.junit.Test;
 
 public class JavaLambdaMergingTest extends HorizontalClassMergingTestBase {
@@ -25,7 +23,6 @@
   }
 
   @Test
-  @Ignore("b/174809311): Test does not work with hygienic lambdas. Rewrite or remove")
   public void test() throws Exception {
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
@@ -41,12 +38,16 @@
             inspector -> {
               Set<DexType> lambdaSources =
                   inspector.getSources().stream()
-                      .filter(JavaLambdaMergingTest::isLambda)
+                      .filter(x -> x.toSourceString().contains(LAMBDA_CLASS_NAME_PREFIX))
                       .collect(Collectors.toSet());
               assertEquals(3, lambdaSources.size());
               DexType firstTarget = inspector.getTarget(lambdaSources.iterator().next());
               for (DexType lambdaSource : lambdaSources) {
-                assertTrue(isLambda(inspector.getTarget(lambdaSource)));
+                assertTrue(
+                    inspector
+                        .getTarget(lambdaSource)
+                        .toSourceString()
+                        .contains(LAMBDA_CLASS_NAME_PREFIX));
                 assertEquals(firstTarget, inspector.getTarget(lambdaSource));
               }
             })
@@ -58,11 +59,6 @@
         .assertSuccessWithOutputLines("Hello world!");
   }
 
-  private static boolean isLambda(DexType type) {
-    return SyntheticItemsTestUtils.isExternalLambda(
-        Reference.classFromDescriptor(type.toDescriptorString()));
-  }
-
   public static class Main {
 
     public static void main(String[] args) {
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
index a5a1a8a..13d59dc 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.ClassAccessFlags;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.ClassNamingForNameMapper;
 import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
@@ -2162,28 +2161,8 @@
       }
 
       private static boolean isInLambdaClass(VmMirror mirror, Location location) {
-        // TODO(b/174809573): These "lambda" specific methods are highly questionable.
-        //   Determine the exact filtering behavior of intellij (which is very likely not name
-        //   based) and update this filter accordingly.
-        CommandPacket cmd =
-            new CommandPacket(
-                ReferenceTypeCommandSet.CommandSetID, ReferenceTypeCommandSet.ModifiersCommand);
-        cmd.setNextValueAsReferenceTypeID(location.classID);
-        ReplyPacket reply = mirror.performCommand(cmd);
-        mirror.checkReply(reply);
-        int modifiers = reply.getNextValueAsInt();
-        ClassAccessFlags flags = ClassAccessFlags.fromCfAccessFlags(modifiers);
-        if (!flags.isSynthetic()) {
-          return false;
-        }
-        String signature = mirror.getClassSignature(location.classID);
-        if (signature.contains("-CC")) {
-          // TODO(b/174809573): The need to return false here indicates a questionable test
-          //  expectation. Either the test is incorrect or there is a bug in our generation of
-          //  -CC classes marked as synthetic as that would lead to unwanted debugger filtering.
-          return false;
-        }
-        return true;
+        String classSig = mirror.getClassSignature(location.classID);
+        return classSig.contains("$$Lambda$");
       }
 
       private static boolean isLambdaMethod(VmMirror mirror, Location location) {
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java b/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java
index 875ead2..8f304c6 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.desugar;
 
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -17,7 +19,6 @@
 import com.android.tools.r8.errors.InterfaceDesugarMissingTypeDiagnostic;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import org.junit.Test;
@@ -78,7 +79,7 @@
         assertEquals(
             Reference.classFromClass(MissingInterface.class), desugarWarning.getMissingType());
         // TODO(b/132671303): The context class should not be the synthesized lambda class.
-        assertTrue(SyntheticItemsTestUtils.isInternalLambda(desugarWarning.getContextType()));
+        assertThat(desugarWarning.getContextType().getDescriptor(), containsString("$$Lambda"));
         // TODO(b/132671303): The position info should be the method context.
         assertEquals(Position.UNKNOWN, desugarWarning.getPosition());
       }
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java
index dc6e894..c9377fe 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java
@@ -48,7 +48,7 @@
   private void checkHasLambdaClass(CodeInspector inspector) {
     assertTrue(
         inspector.allClasses().stream()
-            .anyMatch(subject -> subject.isSynthesizedJavaLambdaClass()));
+            .anyMatch(subject -> subject.getOriginalName().contains("-$$Lambda$")));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
index acfc021..d094c78 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.desugar.backports;
 
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeTrue;
@@ -13,10 +16,10 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.desugar.backports.AbstractBackportTest.MiniAssert;
 import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
-import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.google.common.collect.ImmutableList;
@@ -197,7 +200,9 @@
   private void checkNoOriginalsAndNoInternalSynthetics(CodeInspector inspector) {
     inspector.forAllClasses(
         clazz -> {
-          SyntheticNaming.verifyNotInternalSynthetic(clazz.getFinalReference());
+          assertThat(
+              clazz.getFinalName(),
+              not(containsString(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)));
           if (!clazz.getOriginalName().equals(MiniAssert.class.getTypeName())) {
             clazz.forAllMethods(
                 method ->
@@ -228,11 +233,11 @@
     // of intermediates.
     Set<MethodReference> expectedSynthetics =
         ImmutableSet.of(
-            SyntheticItemsTestUtils.syntheticBackportMethod(
+            SyntheticItemsTestUtils.syntheticMethod(
                 User1.class, 0, Character.class.getMethod("compare", char.class, char.class)),
-            SyntheticItemsTestUtils.syntheticBackportMethod(
+            SyntheticItemsTestUtils.syntheticMethod(
                 User1.class, 1, Boolean.class.getMethod("compare", boolean.class, boolean.class)),
-            SyntheticItemsTestUtils.syntheticBackportMethod(
+            SyntheticItemsTestUtils.syntheticMethod(
                 User2.class, 0, Integer.class.getMethod("compare", int.class, int.class)));
     assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
index 05f84af..45f8957 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.desugar.backports;
 
+import static com.android.tools.r8.synthesis.SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -24,11 +25,11 @@
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -56,6 +57,11 @@
   static final List<Class<?>> MAIN_DEX_LIST_CLASSES =
       ImmutableList.of(MiniAssert.class, TestClass.class, User2.class);
 
+  static final String SyntheticUnderUser1 =
+      User1.class.getTypeName() + EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
+  static final String SyntheticUnderUser2 =
+      User2.class.getTypeName() + EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
+
   private final TestParameters parameters;
 
   @Parameterized.Parameters(name = "{0}")
@@ -335,16 +341,16 @@
   private ImmutableSet<MethodReference> getNonMainDexExpectedSynthetics()
       throws NoSuchMethodException {
     return ImmutableSet.of(
-        SyntheticItemsTestUtils.syntheticBackportMethod(
+        SyntheticItemsTestUtils.syntheticMethod(
             User1.class, 1, Boolean.class.getMethod("compare", boolean.class, boolean.class)));
   }
 
   private ImmutableSet<MethodReference> getMainDexExpectedSynthetics()
       throws NoSuchMethodException {
     return ImmutableSet.of(
-        SyntheticItemsTestUtils.syntheticBackportMethod(
+        SyntheticItemsTestUtils.syntheticMethod(
             User1.class, 0, Character.class.getMethod("compare", char.class, char.class)),
-        SyntheticItemsTestUtils.syntheticBackportMethod(
+        SyntheticItemsTestUtils.syntheticMethod(
             User2.class, 0, Integer.class.getMethod("compare", int.class, int.class)));
   }
 
diff --git a/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java b/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java
index fdb1044..2dbcc30 100644
--- a/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java
@@ -62,7 +62,12 @@
             codeInspector -> {
               boolean foundBridge = false;
               for (FoundClassSubject clazz : codeInspector.allClasses()) {
-                if (clazz.isSynthesizedJavaLambdaClass()) {
+                if (clazz
+                    .getOriginalName()
+                    .contains(
+                        "-$$Lambda$"
+                            + LambdaWithMultipleImplementingInterfaces.class.getSimpleName()
+                            + "$")) {
                   // Find bridge method and check whether or not it has a cast.
                   for (FoundMethodSubject bridge : clazz.allMethods(FoundMethodSubject::isBridge)) {
                     foundBridge = true;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java
index bfb1885..f7b5e5d 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java
@@ -17,16 +17,11 @@
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import com.google.common.collect.Sets;
-import com.google.common.collect.Sets.SetView;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
 import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -58,29 +53,12 @@
   private void assertIdenticalInspectors(Path libDexFile1, Path libDexFile2) throws IOException {
     CodeInspector i1 = new CodeInspector(libDexFile1.resolve("classes.dex"));
     CodeInspector i2 = new CodeInspector(libDexFile2.resolve("classes.dex"));
-    assertIdenticalInspectors(i1, i2);
-  }
-
-  public static void assertIdenticalInspectors(CodeInspector i1, CodeInspector i2) {
     assertEquals(i1.allClasses().size(), i2.allClasses().size());
     Map<DexEncodedMethod, DexEncodedMethod> diffs = new IdentityHashMap<>();
     for (FoundClassSubject clazz1 : i1.allClasses()) {
       ClassSubject clazz = i2.clazz(clazz1.getOriginalName());
       assertTrue(clazz.isPresent());
       FoundClassSubject clazz2 = clazz.asFoundClassSubject();
-      Set<String> methods1 =
-          clazz1.allMethods().stream().map(m -> m.toString()).collect(Collectors.toSet());
-      Set<String> methods2 =
-          clazz2.allMethods().stream().map(m -> m.toString()).collect(Collectors.toSet());
-      SetView<String> union = Sets.union(methods1, methods2);
-      assertEquals(
-          "Inspector 1 contains more methods",
-          Collections.emptySet(),
-          Sets.difference(union, methods1));
-      assertEquals(
-          "Inspector 2 contains more methods",
-          Collections.emptySet(),
-          Sets.difference(union, methods2));
       assertEquals(clazz1.allMethods().size(), clazz2.allMethods().size());
       for (FoundMethodSubject method1 : clazz1.allMethods()) {
         MethodSubject method = clazz2.method(method1.asMethodReference());
@@ -101,7 +79,7 @@
     assertTrue(printDiffs(diffs), diffs.isEmpty());
   }
 
-  private static String printDiffs(Map<DexEncodedMethod, DexEncodedMethod> diffs) {
+  private String printDiffs(Map<DexEncodedMethod, DexEncodedMethod> diffs) {
     StringBuilder sb = new StringBuilder();
     sb.append("The following methods had differences from one dex file to the other (")
         .append(diffs.size())
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/DeduplicateLambdasWithDefaultMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/DeduplicateLambdasWithDefaultMethodsTest.java
deleted file mode 100644
index b252cf4..0000000
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/DeduplicateLambdasWithDefaultMethodsTest.java
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) 2020, 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.desugar.lambdas;
-
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
-import com.google.common.collect.ImmutableSet;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class DeduplicateLambdasWithDefaultMethodsTest extends TestBase {
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withNoneRuntime().build();
-  }
-
-  public DeduplicateLambdasWithDefaultMethodsTest(TestParameters parameters) {
-    parameters.assertNoneRuntime();
-  }
-
-  @Test
-  public void test() throws Exception {
-    assertEquals(
-        ImmutableSet.of(
-            Reference.classFromClass(I.class),
-            Reference.classFromClass(TestClass.class),
-            SyntheticItemsTestUtils.syntheticCompanionClass(I.class),
-            SyntheticItemsTestUtils.syntheticLambdaClass(TestClass.class, 0)),
-        testForD8(Backend.CF)
-            .addInnerClasses(getClass())
-            .setIntermediate(true)
-            .setMinApi(AndroidApiLevel.B)
-            .compile()
-            .inspector()
-            .allClasses()
-            .stream()
-            .map(FoundClassSubject::getFinalReference)
-            .collect(Collectors.toSet()));
-  }
-
-  interface I {
-    void foo();
-
-    // Lots of methods which may cause the ordering of methods on a class to change between builds.
-    default void a() {
-      System.out.print("a");
-    }
-
-    default void b() {
-      System.out.print("b");
-    }
-
-    default void c() {
-      System.out.print("c");
-    }
-
-    default void x() {
-      System.out.print("x");
-    }
-
-    default void y() {
-      System.out.print("y");
-    }
-
-    default void z() {
-      System.out.print("z");
-    }
-  }
-
-  public static class TestClass {
-    private static void foo() {
-      System.out.println("foo");
-    }
-
-    private static void pI(I i) {
-      i.a();
-      i.b();
-      i.c();
-      i.x();
-      i.y();
-      i.z();
-      i.foo();
-    }
-
-    public static void main(String[] args) {
-      // Duplication of the same lambda, each of which should become a shared instance.
-      pI(TestClass::foo);
-      pI(TestClass::foo);
-      pI(TestClass::foo);
-      pI(TestClass::foo);
-      pI(TestClass::foo);
-      pI(TestClass::foo);
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaEqualityTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaEqualityTest.java
deleted file mode 100644
index 90c8009..0000000
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaEqualityTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2020, 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.desugar.lambdas;
-
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.utils.StringUtils;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-/**
- * These tests document the behavior of lambdas w.r.t identity and equality.
- *
- * <p>The D8 and R8 compilers take the stance that a program should not rely on either identity or
- * equality of any lambda metafactory allocated lambda. Thus the status of these tests differ
- * between JVM, D8/CF, D8/DEX and R8 runs as the compilers may or may not share classes and
- * allocations as seen fit.
- */
-@RunWith(Parameterized.class)
-public class LambdaEqualityTest extends TestBase {
-
-  static final String EXPECTED_JAVAC =
-      StringUtils.lines(
-          "Same method refs",
-          "true",
-          "true",
-          "true",
-          "Different method refs",
-          "false",
-          "false",
-          "false",
-          "Empty lambda",
-          "false",
-          "false",
-          "false");
-
-  static final String EXPECTED_D8 =
-      StringUtils.lines(
-          "Same method refs",
-          "true",
-          "true",
-          "true",
-          "Different method refs",
-          "true", // D8 will share the class for the method references.
-          "false",
-          "false",
-          "Empty lambda",
-          "false",
-          "false",
-          "false");
-
-  static final String EXPECTED_R8 =
-      StringUtils.lines(
-          "Same method refs",
-          "true",
-          "true",
-          "true",
-          "Different method refs",
-          "true", // R8 will share the class for the method references.
-          "false",
-          "false",
-          "Empty lambda",
-          "true", // R8 will eliminate the call to the impl method thus making lambdas equal.
-          "true",
-          "true");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
-  }
-
-  public LambdaEqualityTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void testJvm() throws Exception {
-    assumeTrue(parameters.isCfRuntime());
-    testForRuntime(parameters)
-        .addInnerClasses(LambdaEqualityTest.class)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED_JAVAC);
-  }
-
-  @Test
-  public void testD8() throws Exception {
-    testForD8(parameters.getBackend())
-        .addInnerClasses(LambdaEqualityTest.class)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED_D8);
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    testForR8(parameters.getBackend())
-        .addInnerClasses(LambdaEqualityTest.class)
-        .setMinApi(parameters.getApiLevel())
-        .addKeepMainRule(TestClass.class)
-        .addKeepMethodRules(
-            Reference.methodFromMethod(
-                TestClass.class.getDeclaredMethod(
-                    "compare", String.class, MyInterface.class, MyInterface.class)))
-        .run(parameters.getRuntime(), TestClass.class)
-        // The use of invoke dynamics prohibits the optimization and sharing of lambdas in R8.
-        .assertSuccessWithOutput(parameters.isCfRuntime() ? EXPECTED_JAVAC : EXPECTED_R8);
-  }
-
-  interface MyInterface {
-    void foo();
-  }
-
-  static class TestClass {
-
-    public static void compare(String msg, MyInterface i1, MyInterface i2) {
-      System.out.println(msg);
-      System.out.println(i1.getClass() == i2.getClass());
-      System.out.println(i1 == i2);
-      System.out.println(i1.equals(i2));
-    }
-
-    public static void main(String[] args) {
-      MyInterface println = System.out::println;
-      // These lambdas are physically the same and should remain so in all cases.
-      compare("Same method refs", println, println);
-      // These lambdas can be shared as they reference the same actual function.
-      compare("Different method refs", println, System.out::println);
-      // These lambdas cannot be shared (by D8) as javac will generate a lambda$main$X for each.
-      compare("Empty lambda", () -> {}, () -> {});
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaNamingConflictTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaNamingConflictTest.java
deleted file mode 100644
index 1a6e364..0000000
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaNamingConflictTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright (c) 2020, 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.desugar.lambdas;
-
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.StringUtils;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class LambdaNamingConflictTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("boo!");
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters()
-        .withAllRuntimes()
-        .withApiLevel(AndroidApiLevel.B)
-        .enableApiLevelsForCf()
-        .build();
-  }
-
-  // The expected synthetic name is the context of the lambda, TestClass, and the first id.
-  private static final ClassReference CONFLICTING_NAME =
-      SyntheticItemsTestUtils.syntheticLambdaClass(TestClass.class, 0);
-
-  private final TestParameters parameters;
-
-  public LambdaNamingConflictTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void testJvm() throws Exception {
-    assumeTrue(parameters.isCfRuntime());
-    testForJvm()
-        .addProgramClasses(I.class)
-        .addProgramClassFileData(getConflictingNameClass())
-        .addProgramClassFileData(getTransformedMainClass())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testD8() throws Exception {
-    testForD8(parameters.getBackend())
-        .addProgramClasses(I.class)
-        .addProgramClassFileData(getConflictingNameClass())
-        .addProgramClassFileData(getTransformedMainClass())
-        .setMinApi(parameters.getApiLevel())
-        .addOptionsModification(o -> o.testing.allowConflictingSyntheticTypes = true)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    testForR8(parameters.getBackend())
-        .addProgramClasses(I.class)
-        .addProgramClassFileData(getConflictingNameClass())
-        .addProgramClassFileData(getTransformedMainClass())
-        .setMinApi(parameters.getApiLevel())
-        .addOptionsModification(o -> o.testing.allowConflictingSyntheticTypes = true)
-        .addKeepMainRule(TestClass.class)
-        // Ensure that R8 cannot remove or rename the conflicting name.
-        .addKeepClassAndMembersRules(CONFLICTING_NAME.getTypeName())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  private byte[] getTransformedMainClass() throws Exception {
-    return transformer(TestClass.class)
-        .transformMethodInsnInMethod(
-            "main",
-            (opcode, owner, name, descriptor, isInterface, visitor) ->
-                visitor.visitMethodInsn(
-                    opcode, CONFLICTING_NAME.getBinaryName(), name, descriptor, isInterface))
-        .transform();
-  }
-
-  private byte[] getConflictingNameClass() throws Exception {
-    return transformer(WillBeConflictingName.class)
-        .setClassDescriptor(CONFLICTING_NAME.getDescriptor())
-        .transform();
-  }
-
-  interface I {
-    void bar();
-  }
-
-  static class WillBeConflictingName {
-    public static void foo(I i) {
-      i.bar();
-    }
-  }
-
-  static class TestClass {
-
-    public static void main(String[] args) {
-      WillBeConflictingName.foo(() -> System.out.println("boo!"));
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
deleted file mode 100644
index ac5b076..0000000
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
+++ /dev/null
@@ -1,281 +0,0 @@
-// Copyright (c) 2020, 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.desugar.lambdas;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.OutputMode;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import com.google.common.collect.Sets.SetView;
-import java.nio.file.Path;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class LambdaStaticInstanceFieldDuplicationTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("User1.1", "User1.2", "User2");
-
-  static final List<Class<?>> CLASSES =
-      ImmutableList.of(TestClass.class, MyConsumer.class, Accept.class, User1.class, User2.class);
-
-  static final List<String> CLASS_TYPE_NAMES =
-      CLASSES.stream().map(Class::getTypeName).collect(Collectors.toList());
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters()
-        .withAllRuntimes()
-        .withApiLevel(AndroidApiLevel.J)
-        .enableApiLevelsForCf()
-        .build();
-  }
-
-  public LambdaStaticInstanceFieldDuplicationTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    // R8 does not support desugaring with class file output so this test is only valid for DEX.
-    assumeTrue(parameters.isDexRuntime());
-    runR8(false);
-    runR8(true);
-  }
-
-  private void runR8(boolean minify) throws Exception {
-    testForR8(parameters.getBackend())
-        .addProgramClasses(CLASSES)
-        .addKeepMainRule(TestClass.class)
-        // Prevent R8 from eliminating the lambdas by keeping the application of them.
-        .addKeepClassAndMembersRules(Accept.class)
-        .setMinApi(parameters.getApiLevel())
-        .minification(minify)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
-  }
-
-  @Test
-  public void testD8() throws Exception {
-    testForD8(parameters.getBackend())
-        .addProgramClasses(CLASSES)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(this::checkExpectedSynthetics);
-    ;
-  }
-
-  @Test
-  public void testD8Merging() throws Exception {
-    assumeTrue(
-        "b/147485959: Merging does not happen for CF due to lack of synthetic annotations",
-        parameters.isDexRuntime());
-    boolean intermediate = true;
-    runD8Merging(intermediate);
-  }
-
-  @Test
-  public void testD8MergingNonIntermediate() throws Exception {
-    boolean intermediate = false;
-    runD8Merging(intermediate);
-  }
-
-  private void runD8Merging(boolean intermediate) throws Exception {
-    // Compile part 1 of the input (maybe intermediate)
-    Path out1 =
-        testForD8(parameters.getBackend())
-            .addProgramClasses(User1.class)
-            .addClasspathClasses(CLASSES)
-            .setMinApi(parameters.getApiLevel())
-            .setIntermediate(intermediate)
-            .compile()
-            .writeToZip();
-
-    // Compile part 2 of the input (maybe intermediate)
-    Path out2 =
-        testForD8(parameters.getBackend())
-            .addProgramClasses(User2.class)
-            .addClasspathClasses(CLASSES)
-            .setMinApi(parameters.getApiLevel())
-            .setIntermediate(intermediate)
-            .compile()
-            .writeToZip();
-
-    SetView<MethodReference> syntheticsInParts =
-        Sets.union(
-            getSyntheticMethods(new CodeInspector(out1)),
-            getSyntheticMethods(new CodeInspector(out2)));
-
-    // Merge parts as an intermediate artifact.
-    // This will not merge synthetics regardless of the setting of intermediate.
-    Path out3 = temp.newFolder().toPath().resolve("out3.zip");
-    testForD8(parameters.getBackend())
-        .addProgramClasses(TestClass.class, MyConsumer.class, Accept.class)
-        .addProgramFiles(out1, out2)
-        .setMinApi(parameters.getApiLevel())
-        .setIntermediate(true)
-        .compile()
-        .writeToZip(out3)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(inspector -> assertEquals(syntheticsInParts, getSyntheticMethods(inspector)));
-
-    // Finally do a non-intermediate merge.
-    testForD8(parameters.getBackend())
-        .addProgramFiles(out3)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(
-            inspector -> {
-              if (intermediate) {
-                // If all previous builds where intermediate then synthetics are merged.
-                checkExpectedSynthetics(inspector);
-              } else {
-                // Otherwise merging non-intermediate artifacts, synthetics will not be identified.
-                // Check that they are exactly as in the part inputs.
-                assertEquals(syntheticsInParts, getSyntheticMethods(inspector));
-              }
-            });
-  }
-
-  @Test
-  public void testD8FilePerClassFile() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    runD8FilePerMode(OutputMode.DexFilePerClassFile);
-  }
-
-  @Test
-  public void testD8FilePerClass() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    runD8FilePerMode(OutputMode.DexFilePerClass);
-  }
-
-  public void runD8FilePerMode(OutputMode outputMode) throws Exception {
-    Path perClassOutput =
-        testForD8(parameters.getBackend())
-            .setOutputMode(outputMode)
-            .addProgramClasses(CLASSES)
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .writeToZip();
-    testForD8()
-        .addProgramFiles(perClassOutput)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(this::checkExpectedSynthetics);
-  }
-
-  private void checkNoOriginalsAndNoInternalSynthetics(CodeInspector inspector) {
-    inspector.forAllClasses(
-        clazz -> {
-          assertFalse(SyntheticItemsTestUtils.isInternalLambda(clazz.getFinalReference()));
-          clazz.forAllMethods(
-              method ->
-                  assertTrue(
-                      "Unexpected invoke dynamic:\n" + method.getMethod().codeToString(),
-                      method.isAbstract()
-                          || method
-                              .streamInstructions()
-                              .noneMatch(InstructionSubject::isInvokeDynamic)));
-        });
-  }
-
-  private Set<MethodReference> getSyntheticMethods(CodeInspector inspector) {
-    Set<MethodReference> methods = new HashSet<>();
-    inspector.allClasses().stream()
-        .filter(c -> !CLASS_TYPE_NAMES.contains(c.getFinalName()))
-        .forEach(
-            c ->
-                c.allMethods(m -> !m.isInstanceInitializer() && !m.isClassInitializer())
-                    .forEach(m -> methods.add(m.asMethodReference())));
-    return methods;
-  }
-
-  private void checkExpectedSynthetics(CodeInspector inspector) throws Exception {
-    // Hardcoded set of expected synthetics in a "final" build. This set could change if the
-    // compiler makes any changes to the naming, sorting or grouping of synthetics. It is hard-coded
-    // here to check that the compiler generates this deterministically for any single run or merge
-    // of intermediates.
-    Set<MethodReference> expectedSynthetics =
-        ImmutableSet.of(
-            // User1 has two lambdas.
-            SyntheticItemsTestUtils.syntheticLambdaMethod(
-                User1.class, 0, MyConsumer.class.getMethod("accept", Object.class)),
-            SyntheticItemsTestUtils.syntheticLambdaMethod(
-                User1.class, 1, MyConsumer.class.getMethod("accept", Object.class)),
-            // User2 has one lambda.
-            SyntheticItemsTestUtils.syntheticLambdaMethod(
-                User2.class, 0, MyConsumer.class.getMethod("accept", Object.class)));
-    assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
-  }
-
-  interface MyConsumer {
-    void accept(Object o);
-  }
-
-  static class Accept {
-    public static void accept(Object o, MyConsumer consumer) {
-      consumer.accept(o);
-    }
-  }
-
-  static class User1 {
-
-    private static void testSystemPrintln1() {
-      // The lambda will reference a lambda$x method on User1 which is created by javac for each
-      // lambda on the class. Thus there can be no sharing unless R8 inlines the lambda method into
-      // the desugared lambda classes.
-      Accept.accept("1.1", o -> System.out.println("User" + o));
-    }
-
-    private static void testSystemPrintln2() {
-      Accept.accept("1.2", o -> System.out.println("User" + o));
-    }
-  }
-
-  static class User2 {
-
-    private static void testSystemPrintln() {
-      Accept.accept("2", o -> System.out.println("User" + o));
-    }
-  }
-
-  static class TestClass {
-
-    public static void main(String[] args) {
-      User1.testSystemPrintln1();
-      User1.testSystemPrintln2();
-      User2.testSystemPrintln();
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
deleted file mode 100644
index 5b73125..0000000
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2020, 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.desugar.lambdas;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.OutputMode;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import com.google.common.collect.Sets.SetView;
-import java.nio.file.Path;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class LambdaToSysOutPrintlnDuplicationTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("User1", "User2");
-
-  static final List<Class<?>> CLASSES =
-      ImmutableList.of(TestClass.class, MyConsumer.class, Accept.class, User1.class, User2.class);
-
-  static final List<String> CLASS_TYPE_NAMES =
-      CLASSES.stream().map(Class::getTypeName).collect(Collectors.toList());
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters()
-        .withAllRuntimes()
-        .withApiLevel(AndroidApiLevel.J)
-        .enableApiLevelsForCf()
-        .build();
-  }
-
-  public LambdaToSysOutPrintlnDuplicationTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    // R8 does not support desugaring with class file output so this test is only valid for DEX.
-    assumeTrue(parameters.isDexRuntime());
-    runR8(false);
-    runR8(true);
-  }
-
-  private void runR8(boolean minify) throws Exception {
-    testForR8(parameters.getBackend())
-        .addProgramClasses(CLASSES)
-        .addKeepMainRule(TestClass.class)
-        .setMinApi(parameters.getApiLevel())
-        .minification(minify)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
-  }
-
-  @Test
-  public void testD8() throws Exception {
-    testForD8(parameters.getBackend())
-        .addProgramClasses(CLASSES)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(this::checkExpectedSynthetics);
-    ;
-  }
-
-  @Test
-  public void testD8Merging() throws Exception {
-    assumeTrue(
-        "b/147485959: Merging does not happen for CF due to lack of synthetic annotations",
-        parameters.isDexRuntime());
-    boolean intermediate = true;
-    runD8Merging(intermediate);
-  }
-
-  @Test
-  public void testD8MergingNonIntermediate() throws Exception {
-    boolean intermediate = false;
-    runD8Merging(intermediate);
-  }
-
-  private void runD8Merging(boolean intermediate) throws Exception {
-    // Compile part 1 of the input (maybe intermediate)
-    Path out1 =
-        testForD8(parameters.getBackend())
-            .addProgramClasses(User1.class)
-            .addClasspathClasses(CLASSES)
-            .setMinApi(parameters.getApiLevel())
-            .setIntermediate(intermediate)
-            .compile()
-            .writeToZip();
-
-    // Compile part 2 of the input (maybe intermediate)
-    Path out2 =
-        testForD8(parameters.getBackend())
-            .addProgramClasses(User2.class)
-            .addClasspathClasses(CLASSES)
-            .setMinApi(parameters.getApiLevel())
-            .setIntermediate(intermediate)
-            .compile()
-            .writeToZip();
-
-    SetView<MethodReference> syntheticsInParts =
-        Sets.union(
-            getSyntheticMethods(new CodeInspector(out1)),
-            getSyntheticMethods(new CodeInspector(out2)));
-
-    // Merge parts as an intermediate artifact.
-    // This will not merge synthetics regardless of the setting of intermediate.
-    Path out3 = temp.newFolder().toPath().resolve("out3.zip");
-    testForD8(parameters.getBackend())
-        .addProgramClasses(TestClass.class, MyConsumer.class, Accept.class)
-        .addProgramFiles(out1, out2)
-        .setMinApi(parameters.getApiLevel())
-        .setIntermediate(true)
-        .compile()
-        .writeToZip(out3)
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(inspector -> assertEquals(syntheticsInParts, getSyntheticMethods(inspector)));
-
-    // Finally do a non-intermediate merge.
-    testForD8(parameters.getBackend())
-        .addProgramFiles(out3)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(
-            inspector -> {
-              if (intermediate) {
-                // If all previous builds where intermediate then synthetics are merged.
-                checkExpectedSynthetics(inspector);
-              } else {
-                // Otherwise merging non-intermediate artifacts, synthetics will not be identified.
-                // Check that they are exactly as in the part inputs.
-                assertEquals(syntheticsInParts, getSyntheticMethods(inspector));
-              }
-            });
-  }
-
-  @Test
-  public void testD8FilePerClassFile() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    runD8FilePerMode(OutputMode.DexFilePerClassFile);
-  }
-
-  @Test
-  public void testD8FilePerClass() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    runD8FilePerMode(OutputMode.DexFilePerClass);
-  }
-
-  public void runD8FilePerMode(OutputMode outputMode) throws Exception {
-    Path perClassOutput =
-        testForD8(parameters.getBackend())
-            .setOutputMode(outputMode)
-            .addProgramClasses(CLASSES)
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .writeToZip();
-    testForD8()
-        .addProgramFiles(perClassOutput)
-        .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED)
-        .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
-        .inspect(this::checkExpectedSynthetics);
-  }
-
-  private void checkNoOriginalsAndNoInternalSynthetics(CodeInspector inspector) {
-    inspector.forAllClasses(
-        clazz -> {
-          assertFalse(SyntheticItemsTestUtils.isInternalLambda(clazz.getFinalReference()));
-          clazz.forAllMethods(
-              method ->
-                  assertTrue(
-                      "Unexpected invoke dynamic:\n" + method.getMethod().codeToString(),
-                      method.isAbstract()
-                          || method
-                              .streamInstructions()
-                              .noneMatch(InstructionSubject::isInvokeDynamic)));
-        });
-  }
-
-  private Set<MethodReference> getSyntheticMethods(CodeInspector inspector) {
-    Set<MethodReference> methods = new HashSet<>();
-    inspector.allClasses().stream()
-        .filter(c -> !CLASS_TYPE_NAMES.contains(c.getFinalName()))
-        .forEach(
-            c ->
-                c.allMethods(m -> !m.isInstanceInitializer())
-                    .forEach(m -> methods.add(m.asMethodReference())));
-    return methods;
-  }
-
-  private void checkExpectedSynthetics(CodeInspector inspector) throws Exception {
-    // Hardcoded set of expected synthetics in a "final" build. This set could change if the
-    // compiler makes any changes to the naming, sorting or grouping of synthetics. It is hard-coded
-    // here to check that the compiler generates this deterministically for any single run or merge
-    // of intermediates.
-    Set<MethodReference> expectedSynthetics =
-        ImmutableSet.of(
-            SyntheticItemsTestUtils.syntheticLambdaMethod(
-                User1.class, 0, MyConsumer.class.getMethod("accept", Object.class)));
-    assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
-  }
-
-  interface MyConsumer {
-    void accept(Object o);
-  }
-
-  static class Accept {
-    public static void accept(Object o, MyConsumer consumer) {
-      consumer.accept(o);
-    }
-  }
-
-  static class User1 {
-
-    private static void testSystemPrintln() {
-      Accept.accept("User1", System.out::println);
-    }
-  }
-
-  static class User2 {
-
-    private static void testSystemPrintln() {
-      Accept.accept("User2", System.out::println);
-    }
-  }
-
-  static class TestClass {
-
-    public static void main(String[] args) {
-      User1.testSystemPrintln();
-      User2.testSystemPrintln();
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LegacyLambdaMergeTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LegacyLambdaMergeTest.java
deleted file mode 100644
index dd00acf..0000000
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LegacyLambdaMergeTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright (c) 2020, 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.desugar.lambdas;
-
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.D8TestCompileResult;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.graph.AccessFlags;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.transformers.ClassFileTransformer.MethodInsnTransform;
-import com.android.tools.r8.transformers.ClassFileTransformer.TypeInsnTransform;
-import com.android.tools.r8.utils.StringUtils;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.objectweb.asm.MethodVisitor;
-
-@RunWith(Parameterized.class)
-public class LegacyLambdaMergeTest extends TestBase {
-
-  static final String EXPECTED = StringUtils.lines("Hello, world");
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
-  }
-
-  public LegacyLambdaMergeTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void testReference() throws Exception {
-    assumeTrue(parameters.isCfRuntime());
-    testForJvm()
-        .addProgramClassFileData(getTransformedMain())
-        // Add the lambda twice (JVM just picks the first).
-        .addProgramClassFileData(getTransformedLambda())
-        .addProgramClassFileData(getTransformedLambda())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  @Test
-  public void testD8() throws Exception {
-    // Merging legacy lambdas is only valid for DEX inputs, thus also not R8 applicable.
-    assumeTrue(parameters.isDexRuntime());
-    D8TestCompileResult lambda =
-        testForD8()
-            .setMinApi(parameters.getApiLevel())
-            .addProgramClassFileData(getTransformedLambda())
-            .compile();
-    testForD8()
-        .setMinApi(parameters.getApiLevel())
-        .addProgramClassFileData(getTransformedMain())
-        // Add the lambda twice.
-        .addProgramFiles(lambda.writeToZip())
-        .addProgramFiles(lambda.writeToZip())
-        .run(parameters.getRuntime(), TestClass.class)
-        .assertSuccessWithOutput(EXPECTED);
-  }
-
-  private ClassReference LAMBDA =
-      Reference.classFromDescriptor(
-          Reference.classFromClass(WillBeLambda.class)
-              .getDescriptor()
-              .replace("WillBeLambda", "-$$Lambda$XYZ"));
-
-  private byte[] getTransformedLambda() throws Exception {
-    return transformer(WillBeLambda.class)
-        .setClassDescriptor(LAMBDA.getDescriptor())
-        .setAccessFlags(AccessFlags::setSynthetic)
-        .transform();
-  }
-
-  private byte[] getTransformedMain() throws Exception {
-    return transformer(TestClass.class)
-        .transformMethodInsnInMethod(
-            "main",
-            new MethodInsnTransform() {
-              @Override
-              public void visitMethodInsn(
-                  int opcode,
-                  String owner,
-                  String name,
-                  String descriptor,
-                  boolean isInterface,
-                  MethodVisitor visitor) {
-                visitor.visitMethodInsn(
-                    opcode, LAMBDA.getBinaryName(), name, descriptor, isInterface);
-              }
-            })
-        .transformTypeInsnInMethod(
-            "main",
-            new TypeInsnTransform() {
-              @Override
-              public void visitTypeInsn(int opcode, String type, MethodVisitor visitor) {
-                visitor.visitTypeInsn(opcode, LAMBDA.getBinaryName());
-              }
-            })
-        .transform();
-  }
-
-  static class WillBeLambda {
-    public void foo() {
-      System.out.println("Hello, world");
-    }
-  }
-
-  static class TestClass {
-
-    public static void main(String[] args) {
-      new WillBeLambda().foo();
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java b/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java
index 5730599..934a15b 100644
--- a/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java
@@ -47,9 +47,9 @@
     if (parameters.isDexRuntime()) {
       result.inspect(
           inspector -> {
-            // With the hygienic synthetics the reference to System.out::print can always be shared.
+            // When in the same package we expect the two System.out::print lambdas to be shared.
             assertEquals(
-                2,
+                samePackage ? 2 : 3,
                 inspector.allClasses().stream()
                     .filter(c -> c.isSynthesizedJavaLambdaClass())
                     .count());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index 38bb02e..e0266bd 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.ir.optimize.classinliner;
 
+import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
 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;
@@ -321,8 +322,8 @@
     Set<String> expectedTypes = Sets.newHashSet("java.lang.StringBuilder");
     expectedTypes.addAll(
         inspector.allClasses().stream()
-            .filter(FoundClassSubject::isSynthesizedJavaLambdaClass)
             .map(FoundClassSubject::getFinalName)
+            .filter(name -> name.contains(LAMBDA_CLASS_NAME_PREFIX))
             .collect(Collectors.toList()));
     assertEquals(expectedTypes, collectTypes(clazz.uniqueMethodWithName("testStatefulLambda")));
     assertTrue(
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
index 854c85d..447ed7e 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
@@ -6,7 +6,6 @@
 
 import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
 import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -17,7 +16,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.FileUtils;
 import com.google.common.collect.ImmutableList;
@@ -61,8 +59,8 @@
     @Override
     public void finished(DiagnosticsHandler handler) {
       String string = builder.toString();
-      assertThat(string, containsString(testClassMainDexName));
-      assertThat(string, SyntheticItemsTestUtils.containsExternalSyntheticReference());
+      assertTrue(string.contains(testClassMainDexName));
+      assertTrue(string.contains("Lambda"));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
index bd3eb53..6ef399e 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
@@ -24,9 +24,9 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ir.desugar.LambdaRewriter;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -406,13 +406,13 @@
     for (int i = 0; i < refList.length; i++) {
       String reference = refList[i].trim();
       // The main dex list generator does not do any lambda desugaring.
-      if (!isExternalSyntheticLambda(reference)) {
+      if (!isLambda(reference)) {
         if (mainDexGeneratorMainDexList.size() <= i - nonLambdaOffset) {
           fail("Main dex list generator is missing '" + reference + "'");
         }
         String fromList = mainDexGeneratorMainDexList.get(i - nonLambdaOffset);
         String fromConsumer = mainDexGeneratorMainDexListFromConsumer.get(i - nonLambdaOffset);
-        if (isExternalSyntheticLambda(fromList)) {
+        if (isLambda(fromList)) {
           assertEquals(Backend.DEX, backend);
           assertEquals(fromList, fromConsumer);
           nonLambdaOffset--;
@@ -454,8 +454,8 @@
     assertArrayEquals(entriesUnsorted, entriesSorted);
   }
 
-  private boolean isExternalSyntheticLambda(String mainDexEntry) {
-    return SyntheticItemsTestUtils.isExternalLambda(Reference.classFromDescriptor(mainDexEntry));
+  private boolean isLambda(String mainDexEntry) {
+    return mainDexEntry.contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX);
   }
 
   private String mainDexStringToDescriptor(String mainDexString) {
@@ -465,8 +465,11 @@
   }
 
   private void checkSameMainDexEntry(String reference, String computed) {
-    if (isExternalSyntheticLambda(reference)) {
-      // For synthetic classes we check that the context classes match.
+    if (isLambda(reference)) {
+      // For lambda classes we check that there is a lambda class for the right containing
+      // class. However, we do not check the hash for the generated lambda class. The hash
+      // changes for different compiler versions because different compiler versions generate
+      // different lambda implementation method names.
       reference = reference.substring(0, reference.lastIndexOf('$'));
       computed = computed.substring(0, computed.lastIndexOf('$'));
     }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
index 9fa7fe9..d102004 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.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.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.ir.desugar.LambdaRewriter;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -100,11 +100,10 @@
         inspector.allClasses().stream()
             .anyMatch(
                 clazz ->
-                    clazz.isSynthesizedJavaLambdaClass()
+                    clazz.getOriginalName().contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX)
                         && clazz
-                            .getOriginalReference()
-                            .equals(
-                                SyntheticItemsTestUtils.syntheticLambdaClass(lambdaHolder, 0))));
+                            .getOriginalName()
+                            .contains("$" + lambdaHolder.getSimpleName() + "$")));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
index 6ae3a6f..3959d84 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
@@ -14,8 +14,6 @@
 import com.android.tools.r8.CompilationMode;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.naming.retrace.StackTrace.StackTraceLine;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.google.common.collect.ImmutableList;
 import java.util.Collection;
@@ -59,8 +57,7 @@
   }
 
   private boolean isSynthesizedLambdaFrame(StackTraceLine line) {
-    // TODO(141287349): The mapping should not map the external name to the internal name!
-    return SyntheticItemsTestUtils.isInternalLambda(Reference.classFromTypeName(line.className));
+    return line.className.contains("-$$Lambda$");
   }
 
   private void checkLambdaFrame(StackTrace retracedStackTrace) {
diff --git a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
index c2f8041..cd153f2 100644
--- a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
@@ -79,7 +79,8 @@
                     codeInspector.allClasses().stream()
                         .anyMatch(
                             c -> {
-                              if (c.isSynthesizedJavaLambdaClass()) {
+                              if (c.getOriginalName()
+                                  .contains("-$$Lambda$PreserveDesugaredLambdaTest$Main")) {
                                 assertThat(c.uniqueMethodWithName("computeTheFoo"), isPresent());
                                 return true;
                               }
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java
index 436c030..4d385a0 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java
@@ -21,7 +21,6 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.graphinspector.GraphInspector;
@@ -29,7 +28,6 @@
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
 import java.util.function.Supplier;
-import org.hamcrest.Matcher;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -131,13 +129,12 @@
     consumer.printWhyAreYouKeeping(classFromClass(A.class), new PrintStream(baos));
     assertThat(baos.toString(), containsString(KEPT_REASON_SUFFIX));
 
-    // TODO(b/124499108): Currently (internal) synthetic lambda classes are referenced,
+    // TODO(b/124499108): Currently synthetic lambda classes are referenced,
     //  should be their originating context.
-    Matcher<String> hasLambda = SyntheticItemsTestUtils.containsInternalSyntheticReference();
     if (parameters.isDexRuntime()) {
-      assertThat(baos.toString(), hasLambda);
+      assertThat(baos.toString(), containsString("-$$Lambda$"));
     } else {
-      assertThat(baos.toString(), not(hasLambda));
+      assertThat(baos.toString(), not(containsString("-$$Lambda$")));
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
deleted file mode 100644
index dba85d6..0000000
--- a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) 2020, 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.synthesis;
-
-import static org.hamcrest.CoreMatchers.containsString;
-
-import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticNaming.Phase;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import java.lang.reflect.Method;
-import org.hamcrest.Matcher;
-
-public class SyntheticItemsTestUtils {
-
-  public static ClassReference syntheticCompanionClass(Class<?> clazz) {
-    return Reference.classFromDescriptor(
-        InterfaceMethodRewriter.getCompanionClassDescriptor(
-            Reference.classFromClass(clazz).getDescriptor()));
-  }
-
-  private static ClassReference syntheticClass(Class<?> clazz, SyntheticKind kind, int id) {
-    return SyntheticNaming.makeSyntheticReferenceForTest(
-        Reference.classFromClass(clazz), kind, "" + id);
-  }
-
-  public static MethodReference syntheticBackportMethod(Class<?> clazz, int id, Method method) {
-    ClassReference syntheticHolder =
-        syntheticClass(clazz, SyntheticNaming.SyntheticKind.BACKPORT, id);
-    MethodReference originalMethod = Reference.methodFromMethod(method);
-    return Reference.methodFromDescriptor(
-        syntheticHolder.getDescriptor(),
-        SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX,
-        originalMethod.getMethodDescriptor());
-  }
-
-  public static ClassReference syntheticLambdaClass(Class<?> clazz, int id) {
-    return syntheticClass(clazz, SyntheticNaming.SyntheticKind.LAMBDA, id);
-  }
-
-  public static MethodReference syntheticLambdaMethod(Class<?> clazz, int id, Method method) {
-    ClassReference syntheticHolder = syntheticLambdaClass(clazz, id);
-    MethodReference originalMethod = Reference.methodFromMethod(method);
-    return Reference.methodFromDescriptor(
-        syntheticHolder.getDescriptor(),
-        originalMethod.getMethodName(),
-        originalMethod.getMethodDescriptor());
-  }
-
-  public static boolean isInternalLambda(ClassReference reference) {
-    return SyntheticNaming.isSynthetic(reference, Phase.INTERNAL, SyntheticKind.LAMBDA);
-  }
-
-  public static boolean isExternalLambda(ClassReference reference) {
-    return SyntheticNaming.isSynthetic(reference, Phase.EXTERNAL, SyntheticKind.LAMBDA);
-  }
-
-  public static boolean isExternalStaticInterfaceCall(ClassReference reference) {
-    return SyntheticNaming.isSynthetic(
-        reference, Phase.EXTERNAL, SyntheticKind.STATIC_INTERFACE_CALL);
-  }
-
-  public static Matcher<String> containsInternalSyntheticReference() {
-    return containsString(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
-  }
-
-  public static Matcher<String> containsExternalSyntheticReference() {
-    return containsString(SyntheticNaming.getPhaseSeparator(Phase.EXTERNAL));
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/utils/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/utils/SyntheticItemsTestUtils.java
new file mode 100644
index 0000000..9e78bac
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/SyntheticItemsTestUtils.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.utils;
+
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItems;
+import java.lang.reflect.Method;
+
+public class SyntheticItemsTestUtils {
+
+  public static ClassReference syntheticClass(Class<?> clazz, int id) {
+    return Reference.classFromTypeName(
+        clazz.getTypeName() + SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR + id);
+  }
+
+  public static MethodReference syntheticMethod(Class<?> clazz, int id, Method method) {
+    ClassReference syntheticHolder = syntheticClass(clazz, id);
+    MethodReference originalMethod = Reference.methodFromMethod(method);
+    return Reference.methodFromDescriptor(
+        syntheticHolder.getDescriptor(),
+        SyntheticItems.INTERNAL_SYNTHETIC_METHOD_PREFIX + 0,
+        originalMethod.getMethodDescriptor());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
index a42fa4b..ffe8151 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
@@ -136,11 +136,6 @@
   }
 
   @Override
-  public ClassReference getOriginalReference() {
-    return null;
-  }
-
-  @Override
   public ClassReference getFinalReference() {
     return null;
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
index f4b1eaf..4e6a3f5 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
@@ -280,7 +280,6 @@
         && ((CfInvoke) instruction).getOpcode() == Opcodes.INVOKESPECIAL;
   }
 
-  @Override
   public boolean isInvokeDynamic() {
     return instruction instanceof CfInvokeDynamic;
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
index 20d7466..a2d32eb 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
@@ -191,8 +191,6 @@
 
   public abstract String getOriginalBinaryName();
 
-  public abstract ClassReference getOriginalReference();
-
   public abstract ClassReference getFinalReference();
 
   public abstract String getFinalName();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
index 6057aa0..26944f9 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
@@ -209,11 +209,6 @@
     return false;
   }
 
-  @Override
-  public boolean isInvokeDynamic() {
-    return isInvokeCustom();
-  }
-
   public boolean isInvokeCustom() {
     return instruction instanceof InvokeCustom || instruction instanceof InvokeCustomRange;
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index 4220b50..a676666 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -34,7 +34,6 @@
 import com.android.tools.r8.retrace.RetraceTypeResult;
 import com.android.tools.r8.retrace.RetracedField;
 import com.android.tools.r8.retrace.Retracer;
-import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.ZipUtils;
@@ -390,11 +389,6 @@
   }
 
   @Override
-  public ClassReference getOriginalReference() {
-    return Reference.classFromDescriptor(getOriginalDescriptor());
-  }
-
-  @Override
   public ClassReference getFinalReference() {
     return Reference.classFromDescriptor(getFinalDescriptor());
   }
@@ -436,9 +430,7 @@
 
   @Override
   public boolean isSynthesizedJavaLambdaClass() {
-    // TODO(141287349): Make this precise based on the map input.
-    return SyntheticItemsTestUtils.isExternalLambda(getOriginalReference())
-        || SyntheticItemsTestUtils.isExternalLambda(getFinalReference());
+    return dexClass.type.getName().contains("$Lambda$");
   }
 
   @Override
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
index eee6ec3..e6e26fd 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
@@ -43,8 +43,6 @@
 
   boolean isInvokeSpecial();
 
-  boolean isInvokeDynamic();
-
   DexMethod getMethod();
 
   boolean isNop();
diff --git a/tools/toolhelper.py b/tools/toolhelper.py
index 1cfd0f0..45d84e2 100644
--- a/tools/toolhelper.py
+++ b/tools/toolhelper.py
@@ -27,10 +27,6 @@
   cmd.append(jdk.GetJavaExecutable())
   if extra_args:
     cmd.extend(extra_args)
-  agent, args = extract_debug_agent_from_args(args)
-  if agent:
-    cmd.append(
-        '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005')
   if debug:
     cmd.append('-ea')
   if profile:
@@ -107,13 +103,3 @@
     else:
       args.append(arg)
   return lib, args
-
-def extract_debug_agent_from_args(input_args):
-  agent = False
-  args = []
-  for arg in input_args:
-    if arg in ('--debug-agent', '--debug_agent'):
-      agent = True
-    else:
-      args.append(arg)
-  return agent, args