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 e1be490..db83f6a 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -10,6 +10,7 @@
 import com.google.common.collect.ImmutableMap.Builder;
 import com.google.common.collect.ImmutableSet;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -22,6 +23,10 @@
   public final DexItemFactory dexItemFactory;
   private final ConcurrentHashMap<DexType, Map<Descriptor<?,?>, KeyedDexItem<?>>> definitions =
       new ConcurrentHashMap<>();
+  // For some optimizations, e.g. optimizing synthetic classes, we may need to resolve the current
+  // class being optimized.
+  private ConcurrentHashMap<DexType, DexProgramClass> synthesizedClasses =
+      new ConcurrentHashMap<>();
 
   public AppInfo(DexApplication application) {
     this.app = application;
@@ -42,6 +47,16 @@
     this(application);
   }
 
+  public void addSynthesizedClass(DexProgramClass clazz) {
+    assert clazz.type.isD8R8SynthesizedClassType();
+    DexProgramClass previous = synthesizedClasses.put(clazz.type, clazz);
+    assert previous == null || previous == clazz;
+  }
+
+  public Collection<DexProgramClass> getSynthesizedClassesForSanityCheck() {
+    return Collections.unmodifiableCollection(synthesizedClasses.values());
+  }
+
   private Map<Descriptor<?,?>, KeyedDexItem<?>> computeDefinitions(DexType type) {
     Builder<Descriptor<?,?>, KeyedDexItem<?>> builder = ImmutableMap.builder();
     DexClass clazz = app.definitionFor(type);
@@ -72,6 +87,11 @@
   }
 
   public DexClass definitionFor(DexType type) {
+    DexProgramClass cached = synthesizedClasses.get(type);
+    if (cached != null) {
+      assert app.definitionFor(type) == null;
+      return cached;
+    }
     return app.definitionFor(type);
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
index 0efc380..96f34bc 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
@@ -114,7 +114,7 @@
     // The only way to figure out whether the DexValue contains the final value
     // is ensure the value is not the default or check <clinit> is not present.
     boolean isEffectivelyFinal =
-        (accessFlags.isFinal() || !appInfo.fieldsWritten.contains(field))
+        (accessFlags.isFinal() || !appInfo.isFieldWritten(field))
             && !appInfo.isPinned(field);
     if (!isEffectivelyFinal) {
       return null;
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 2ebccfe..249a2b5 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -10,7 +10,8 @@
 
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.logging.Log;
+import com.android.tools.r8.ir.desugar.Java8MethodRewriter;
+import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
@@ -221,14 +222,6 @@
     }
     while (other.hierarchyLevel < self.hierarchyLevel) {
       DexClass holder = appInfo.definitionFor(self);
-      // TODO(b/113374256): even synthesized class should be available ATM.
-      if (holder == null) {
-        assert self.isD8R8SynthesizedClassType();
-        if (Log.ENABLED) {
-          Log.debug(getClass(), "%s is not in AppInfo yet.", self.toSourceString());
-        }
-        return orElse;
-      }
       assert holder != null && !holder.isInterface();
       self = holder.superType;
     }
@@ -483,7 +476,9 @@
         || name.contains(DISPATCH_CLASS_NAME_SUFFIX)
         || name.contains(LAMBDA_CLASS_NAME_PREFIX)
         || name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX)
-        || name.contains(OutlineOptions.CLASS_NAME);
+        || name.contains(OutlineOptions.CLASS_NAME)
+        || name.contains(TwrCloseResourceRewriter.UTILITY_CLASS_NAME)
+        || name.contains(Java8MethodRewriter.UTILITY_CLASS_NAME_PREFIX);
   }
 
   public int elementSizeForPrimitiveArrayType() {
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLense.java b/src/main/java/com/android/tools/r8/graph/GraphLense.java
index 5fd473f..b964dd3 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLense.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLense.java
@@ -388,9 +388,7 @@
   public abstract DexMethod getRenamedMethodSignature(DexMethod originalMethod);
 
   public DexEncodedMethod mapDexEncodedMethod(
-      DexEncodedMethod originalEncodedMethod,
-      AppInfo appInfo,
-      Map<DexType, DexProgramClass> synthesizedClasses) {
+      DexEncodedMethod originalEncodedMethod, AppInfo appInfo) {
     DexMethod newMethod = getRenamedMethodSignature(originalEncodedMethod.method);
     // Note that:
     // * Even if `newMethod` is the same as `originalEncodedMethod.method`, we still need to look it
@@ -398,14 +396,7 @@
     // * We can't directly use AppInfo#definitionFor(DexMethod) since definitions may not be
     //   updated either yet.
     DexClass newHolder = appInfo.definitionFor(newMethod.holder);
-
-    // TODO(b/120130831): Need to ensure that all synthesized classes are part of the application.
-    if (newHolder == null) {
-      newHolder = synthesizedClasses.get(newMethod.holder);
-    }
-
     assert newHolder != null;
-
     DexEncodedMethod newEncodedMethod = newHolder.lookupMethod(newMethod);
     assert newEncodedMethod != null;
     return newEncodedMethod;
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 cb7a5d5..ff6abd3 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
@@ -89,12 +89,10 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
-import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -149,10 +147,6 @@
   private final OptimizationFeedback simpleOptimizationFeedback = new OptimizationFeedbackSimple();
   private DexString highestSortingString;
 
-  // For some optimizations, e.g. optimizing synthetic classes, we may need to resolve
-  // the current class being optimized.
-  private ConcurrentHashMap<DexType, DexProgramClass> cachedClasses = new ConcurrentHashMap<>();
-
   // The argument `appView` is only available when full program optimizations are allowed
   // (i.e., when running R8).
   private IRConverter(
@@ -352,30 +346,24 @@
       InterfaceMethodRewriter.Flavor includeAllResources,
       ExecutorService executorService)
       throws ExecutionException {
-    desugarInterfaceMethods(builder, includeAllResources, executorService, null);
-  }
-
-  private void desugarInterfaceMethods(
-      Builder<?> builder,
-      InterfaceMethodRewriter.Flavor includeAllResources,
-      ExecutorService executorService,
-      Map<DexType, DexProgramClass> synthesizedClasses)
-      throws ExecutionException {
     if (interfaceMethodRewriter != null) {
       interfaceMethodRewriter.desugarInterfaceMethods(
-          builder, includeAllResources, executorService, synthesizedClasses);
+          builder, includeAllResources, executorService);
     }
   }
 
-  private void synthesizeTwrCloseResourceUtilityClass(Builder<?> builder) {
+  private void synthesizeTwrCloseResourceUtilityClass(
+      Builder<?> builder, ExecutorService executorService)
+      throws ExecutionException {
     if (twrCloseResourceRewriter != null) {
-      twrCloseResourceRewriter.synthesizeUtilityClass(builder, options);
+      twrCloseResourceRewriter.synthesizeUtilityClass(builder, executorService, options);
     }
   }
 
-  private void synthesizeJava8UtilityClass(Builder<?> builder) {
+  private void synthesizeJava8UtilityClass(
+      Builder<?> builder, ExecutorService executorService) throws ExecutionException {
     if (java8MethodRewriter != null) {
-      java8MethodRewriter.synthesizeUtilityClass(builder, options);
+      java8MethodRewriter.synthesizeUtilityClass(builder, executorService, options);
     }
   }
 
@@ -398,8 +386,8 @@
 
     synthesizeLambdaClasses(builder, executor);
     desugarInterfaceMethods(builder, ExcludeDexResources, executor);
-    synthesizeTwrCloseResourceUtilityClass(builder);
-    synthesizeJava8UtilityClass(builder);
+    synthesizeTwrCloseResourceUtilityClass(builder, executor);
+    synthesizeJava8UtilityClass(builder, executor);
     processCovariantReturnTypeAnnotations(builder);
 
     handleSynthesizedClassMapping(builder);
@@ -590,21 +578,20 @@
     synthesizeLambdaClasses(builder, executorService);
 
     printPhase("Interface method desugaring");
-    Map<DexType, DexProgramClass> synthesizedClasses = new IdentityHashMap<>();
-    desugarInterfaceMethods(builder, IncludeAllResources, executorService, synthesizedClasses);
+    desugarInterfaceMethods(builder, IncludeAllResources, executorService);
 
     printPhase("Twr close resource utility class synthesis");
-    synthesizeTwrCloseResourceUtilityClass(builder);
-    synthesizeJava8UtilityClass(builder);
+    synthesizeTwrCloseResourceUtilityClass(builder, executorService);
+    synthesizeJava8UtilityClass(builder, executorService);
     handleSynthesizedClassMapping(builder);
 
     printPhase("Lambda merging finalization");
-    finalizeLambdaMerging(application, feedback, builder, executorService, synthesizedClasses);
+    finalizeLambdaMerging(application, feedback, builder, executorService);
 
     if (outliner != null) {
       printPhase("Outlining");
       timing.begin("IR conversion phase 2");
-      if (outliner.selectMethodsForOutlining(synthesizedClasses)) {
+      if (outliner.selectMethodsForOutlining()) {
         forEachSelectedOutliningMethod(
             executorService,
             (code, method) -> {
@@ -612,7 +599,8 @@
               outliner.identifyOutlineSites(code, method);
             });
         DexProgramClass outlineClass = outliner.buildOutlinerClass(computeOutlineClassType());
-        optimizeSynthesizedClass(outlineClass);
+        appInfo.addSynthesizedClass(outlineClass);
+        optimizeSynthesizedClass(outlineClass, executorService);
         forEachSelectedOutliningMethod(
             executorService,
             (code, method) -> {
@@ -636,6 +624,12 @@
       uninstantiatedTypeOptimization.logResults();
     }
 
+    // Check if what we've added to the application builder as synthesized classes are same as
+    // what we've added and used through AppInfo.
+    assert appInfo.getSynthesizedClassesForSanityCheck()
+            .containsAll(builder.getSynthesizedClasses())
+        && builder.getSynthesizedClasses()
+            .containsAll(appInfo.getSynthesizedClassesForSanityCheck());
     return builder.build();
   }
 
@@ -687,14 +681,13 @@
 
   private void finalizeLambdaMerging(
       DexApplication application,
-      OptimizationFeedback directFeedback,
+      OptimizationFeedback feedback,
       Builder<?> builder,
-      ExecutorService executorService,
-      Map<DexType, DexProgramClass> synthesizedClasses)
+      ExecutorService executorService)
       throws ExecutionException {
     if (lambdaMerger != null) {
       lambdaMerger.applyLambdaClassMapping(
-          application, this, directFeedback, builder, executorService, synthesizedClasses);
+          application, this, feedback, builder, executorService);
     }
   }
 
@@ -744,49 +737,24 @@
     return result;
   }
 
-  public DexClass definitionFor(DexType type) {
-    DexProgramClass cached = cachedClasses.get(type);
-    return cached != null ? cached : appInfo.definitionFor(type);
-  }
-
-  public void optimizeSynthesizedClass(DexProgramClass clazz) {
-    try {
-      enterCachedClass(clazz);
-      // Process the generated class, but don't apply any outlining.
-      clazz.forEachMethod(this::optimizeSynthesizedMethod);
-    } finally {
-      leaveCachedClass(clazz);
-    }
+  public void optimizeSynthesizedClass(
+      DexProgramClass clazz, ExecutorService executorService)
+      throws ExecutionException {
+    Set<DexEncodedMethod> methods = Sets.newIdentityHashSet();
+    clazz.forEachMethod(methods::add);
+    // Process the generated class, but don't apply any outlining.
+    optimizeSynthesizedMethodsConcurrently(methods, executorService);
   }
 
   public void optimizeSynthesizedClasses(
       Collection<DexProgramClass> classes, ExecutorService executorService)
       throws ExecutionException {
     Set<DexEncodedMethod> methods = Sets.newIdentityHashSet();
-    try {
-      for (DexProgramClass clazz : classes) {
-        enterCachedClass(clazz);
-        clazz.forEachMethod(methods::add);
-      }
-      // Process the generated class, but don't apply any outlining.
-      optimizeSynthesizedMethods(methods, executorService);
-    } finally {
-      for (DexProgramClass clazz : classes) {
-        leaveCachedClass(clazz);
-      }
+    for (DexProgramClass clazz : classes) {
+      clazz.forEachMethod(methods::add);
     }
-  }
-
-  public void optimizeMethodOnSynthesizedClass(DexProgramClass clazz, DexEncodedMethod method) {
-    if (!method.isProcessed()) {
-      try {
-        enterCachedClass(clazz);
-        // Process the generated method, but don't apply any outlining.
-        optimizeSynthesizedMethod(method);
-      } finally {
-        leaveCachedClass(clazz);
-      }
-    }
+    // Process the generated class, but don't apply any outlining.
+    optimizeSynthesizedMethodsConcurrently(methods, executorService);
   }
 
   public void optimizeSynthesizedMethod(DexEncodedMethod method) {
@@ -801,7 +769,7 @@
     }
   }
 
-  public void optimizeSynthesizedMethods(
+  public void optimizeSynthesizedMethodsConcurrently(
       Collection<DexEncodedMethod> methods, ExecutorService executorService)
       throws ExecutionException {
     List<Future<?>> futures = new ArrayList<>();
@@ -821,16 +789,6 @@
     ThreadUtils.awaitFutures(futures);
   }
 
-  private void enterCachedClass(DexProgramClass clazz) {
-    DexProgramClass previous = cachedClasses.put(clazz.type, clazz);
-    assert previous == null;
-  }
-
-  private void leaveCachedClass(DexProgramClass clazz) {
-    DexProgramClass existing = cachedClasses.remove(clazz.type);
-    assert existing == clazz;
-  }
-
   private String logCode(InternalOptions options, DexEncodedMethod method) {
     return options.useSmaliSyntax ? method.toSmaliString(null) : method.codeToString();
   }
@@ -1198,7 +1156,8 @@
       // original method signature (this could have changed as a result of, for example, class
       // merging). Then, we find the type that now corresponds to the the original holder.
       DexMethod originalSignature = graphLense().getOriginalMethodSignature(method.method);
-      DexClass originalHolder = definitionFor(graphLense().lookupType(originalSignature.holder));
+      DexClass originalHolder = appInfo.definitionFor(
+          graphLense().lookupType(originalSignature.holder));
       if (originalHolder.hasKotlinInfo()) {
         KotlinInfo kotlinInfo = originalHolder.getKotlinInfo();
         if (kotlinInfo.hasNonNullParameterHints()) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
index ec788a4..401feaa 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
@@ -60,7 +60,7 @@
     DexType superType = clazz.superType;
     // If superClass definition is missing, just skip this part and let real processing of its
     // subclasses report the error if it is required.
-    DexClass superClass = superType == null ? null : rewriter.findDefinitionFor(superType);
+    DexClass superClass = superType == null ? null : rewriter.appInfo.definitionFor(superType);
     if (superClass != null && superType != rewriter.factory.objectType) {
       if (superClass.isInterface()) {
         throw new CompilationError("Interface `" + superClass.toSourceString()
@@ -96,7 +96,7 @@
 
   private DexEncodedMethod addForwardingMethod(DexEncodedMethod defaultMethod, DexClass clazz) {
     DexMethod method = defaultMethod.method;
-    DexClass target = rewriter.findDefinitionFor(method.holder);
+    DexClass target = rewriter.appInfo.definitionFor(method.holder);
     // NOTE: Never add a forwarding method to methods of classes unknown or coming from android.jar
     // even if this results in invalid code, these classes are never desugared.
     assert target != null && !target.isLibraryClass();
@@ -168,7 +168,7 @@
       if (current.superType == null) {
         break;
       } else {
-        DexClass superClass = rewriter.findDefinitionFor(current.superType);
+        DexClass superClass = rewriter.appInfo.definitionFor(current.superType);
         if (superClass != null) {
           current = superClass;
         } else {
@@ -206,7 +206,7 @@
       DexType superType = current.superType;
       DexClass superClass = null;
       if (superType != null) {
-        superClass = rewriter.findDefinitionFor(superType);
+        superClass = rewriter.appInfo.definitionFor(superType);
         // It's available or we would have failed while analyzing the hierarchy for interfaces.
         assert superClass != null;
       }
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 e79017d..abd38a5 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
@@ -6,6 +6,7 @@
 
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexApplication.Builder;
@@ -80,6 +81,7 @@
   public static final String PRIVATE_METHOD_PREFIX = "$private$";
 
   private final AppView<? extends AppInfoWithLiveness> appView;
+  final AppInfo appInfo;
   private final IRConverter converter;
   private final InternalOptions options;
   final DexItemFactory factory;
@@ -121,6 +123,7 @@
     assert converter != null;
     this.appView = appView;
     this.converter = converter;
+    this.appInfo = converter.appInfo;
     this.options = options;
     this.factory = options.itemFactory;
   }
@@ -156,7 +159,7 @@
         if (instruction.isInvokeStatic()) {
           InvokeStatic invokeStatic = instruction.asInvokeStatic();
           DexMethod method = invokeStatic.getInvokedMethod();
-          DexClass clazz = findDefinitionFor(method.holder);
+          DexClass clazz = appInfo.definitionFor(method.holder);
           if (Java8MethodRewriter.hasJava8MethodRewritePrefix(method.holder)) {
             // We did not create this code yet, but it will not require rewriting.
             continue;
@@ -187,7 +190,7 @@
                         invokeStatic.outValue(), invokeStatic.arguments()));
                 requiredDispatchClasses
                     .computeIfAbsent(clazz.asLibraryClass(), k -> Sets.newConcurrentHashSet())
-                    .add(findDefinitionFor(encodedMethod.method.holder).asProgramClass());
+                    .add(appInfo.definitionFor(encodedMethod.method.holder).asProgramClass());
               }
             } else {
               instructions.replaceCurrentInstruction(
@@ -201,7 +204,7 @@
         if (instruction.isInvokeSuper()) {
           InvokeSuper invokeSuper = instruction.asInvokeSuper();
           DexMethod method = invokeSuper.getInvokedMethod();
-          DexClass clazz = findDefinitionFor(method.holder);
+          DexClass clazz = appInfo.definitionFor(method.holder);
           if (clazz == null) {
             // NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
             // exception but we can not report it as error since it can also be the intended
@@ -218,7 +221,7 @@
             // WARNING: This may result in incorrect code on older platforms!
             // Retarget call to an appropriate method of companion class.
             DexMethod amendedMethod = amendDefaultMethod(
-                findDefinitionFor(encodedMethod.method.holder), method);
+                appInfo.definitionFor(encodedMethod.method.holder), method);
             instructions.replaceCurrentInstruction(
                 new InvokeStatic(defaultAsMethodOfCompanionClass(amendedMethod),
                     invokeSuper.outValue(), invokeSuper.arguments()));
@@ -233,7 +236,7 @@
             continue;
           }
 
-          DexClass clazz = findDefinitionFor(method.holder);
+          DexClass clazz = appInfo.definitionFor(method.holder);
           if (clazz == null) {
             // Report missing class since we don't know if it is an interface.
             warnMissingType(encodedMethod.method, method.holder);
@@ -279,7 +282,7 @@
 
   private void reportStaticInterfaceMethodHandle(DexMethod referencedFrom, DexMethodHandle handle) {
     if (handle.type.isInvokeStatic()) {
-      DexClass holderClass = findDefinitionFor(handle.asMethod().holder);
+      DexClass holderClass = appInfo.definitionFor(handle.asMethod().holder);
       // NOTE: If the class definition is missing we can't check. Let it be handled as any other
       // missing call target.
       if (holderClass == null) {
@@ -292,15 +295,6 @@
     }
   }
 
-  /**
-   * Returns the class definition for the specified type.
-   *
-   * @return may return null if no definition for the given type is available.
-   */
-  final DexClass findDefinitionFor(DexType type) {
-    return converter.definitionFor(type);
-  }
-
   // Gets the companion class for the interface `type`.
   final DexType getCompanionClassType(DexType type) {
     assert type.isClassType();
@@ -334,7 +328,7 @@
   }
 
   private boolean isInMainDexList(DexType iface) {
-    return converter.appInfo.isInMainDexList(iface);
+    return appInfo.isInMainDexList(iface);
   }
 
   // Represent a static interface method as a method of companion class.
@@ -393,8 +387,7 @@
   public void desugarInterfaceMethods(
       Builder<?> builder,
       Flavor flavour,
-      ExecutorService executorService,
-      Map<DexType, DexProgramClass> synthesizedClasses)
+      ExecutorService executorService)
       throws ExecutionException {
     // Process all classes first. Add missing forwarding methods to
     // replace desugared default interface methods.
@@ -409,13 +402,10 @@
       // are just moved from interfaces and don't need to be re-processed.
       DexProgramClass synthesizedClass = entry.getValue();
       builder.addSynthesizedClass(synthesizedClass, isInMainDexList(entry.getKey()));
-
-      if (synthesizedClasses != null) {
-        synthesizedClasses.put(synthesizedClass.type, synthesizedClass);
-      }
+      appInfo.addSynthesizedClass(synthesizedClass);
     }
 
-    converter.optimizeSynthesizedMethods(synthesizedMethods, executorService);
+    converter.optimizeSynthesizedMethodsConcurrently(synthesizedMethods, executorService);
 
     // Cached data is not needed any more.
     clear();
@@ -528,7 +518,7 @@
     if (isCompanionClassType(holder)) {
       holder = getInterfaceClassType(holder);
     }
-    DexClass clazz = converter.appInfo.definitionFor(holder);
+    DexClass clazz = appInfo.definitionFor(holder);
     return clazz == null ? Origin.unknown() : clazz.getOrigin();
   }
 
@@ -550,7 +540,7 @@
       DexClass implementing,
       DexType iface) {
     DefaultMethodsHelper helper = new DefaultMethodsHelper();
-    DexClass definedInterface = findDefinitionFor(iface);
+    DexClass definedInterface = appInfo.definitionFor(iface);
     if (definedInterface == null) {
       warnMissingInterface(classToDesugar, implementing, iface);
       return helper.wrapInCollection();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
index 054b950..e4d4b01 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
@@ -322,7 +322,7 @@
         if (!seenBefore.add(superType)) {
           continue;
         }
-        DexClass clazz = rewriter.findDefinitionFor(superType);
+        DexClass clazz = rewriter.appInfo.definitionFor(superType);
         if (clazz != null) {
           if (clazz.lookupVirtualMethod(method.method) != null) {
             return false;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/Java8MethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/Java8MethodRewriter.java
index 9e2e9ab..e930bcf 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/Java8MethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/Java8MethodRewriter.java
@@ -37,9 +37,12 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
 import java.util.function.BiFunction;
 
 public final class Java8MethodRewriter {
+  public static final String UTILITY_CLASS_NAME_PREFIX = "$r8$java8methods$utility";
   private static final String UTILITY_CLASS_DESCRIPTOR_PREFIX = "L$r8$java8methods$utility";
   private final Set<DexType> holders = Sets.newConcurrentHashSet();
   private final IRConverter converter;
@@ -88,7 +91,9 @@
     return clazz.descriptor.toString().startsWith(UTILITY_CLASS_DESCRIPTOR_PREFIX);
   }
 
-  public void synthesizeUtilityClass(Builder<?> builder, InternalOptions options) {
+  public void synthesizeUtilityClass(
+      Builder<?> builder, ExecutorService executorService, InternalOptions options)
+      throws ExecutionException {
     if (holders.isEmpty()) {
       return;
     }
@@ -134,7 +139,8 @@
       code.setUpContext(utilityClass);
       boolean addToMainDexList = referencingClasses.stream()
           .anyMatch(clazz -> converter.appInfo.isInMainDexList(clazz.type));
-      converter.optimizeSynthesizedClass(utilityClass);
+      converter.appInfo.addSynthesizedClass(utilityClass);
+      converter.optimizeSynthesizedClass(utilityClass, executorService);
       builder.addSynthesizedClass(utilityClass, addToMainDexList);
     }
   }
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 865a62c..cff5392 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
@@ -153,8 +153,9 @@
             synthesizeVirtualMethods(mainMethod),
             rewriter.factory.getSkipNameValidationForTesting());
     // Optimize main method.
-    rewriter.converter.optimizeMethodOnSynthesizedClass(
-        clazz, clazz.lookupVirtualMethod(mainMethod));
+    rewriter.converter.appInfo.addSynthesizedClass(clazz);
+    rewriter.converter.optimizeSynthesizedMethod(clazz.lookupVirtualMethod(mainMethod));
+
     // The method addSynthesizedFrom() may be called concurrently. To avoid a Concurrent-
     // ModificationException we must use synchronization.
     synchronized (synthesizedFrom) {
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 4e29e6f..a1bb373 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
@@ -181,14 +181,15 @@
   /** Generates lambda classes and adds them to the builder. */
   public void synthesizeLambdaClasses(Builder<?> builder, ExecutorService executorService)
       throws ExecutionException {
+    for (LambdaClass lambdaClass : knownLambdaClasses.values()) {
+      DexProgramClass synthesizedClass = lambdaClass.getLambdaClass();
+      appInfo.addSynthesizedClass(synthesizedClass);
+      builder.addSynthesizedClass(synthesizedClass, lambdaClass.addToMainDexList.get());
+    }
     converter.optimizeSynthesizedClasses(
         knownLambdaClasses.values().stream()
             .map(LambdaClass::getLambdaClass).collect(ImmutableSet.toImmutableSet()),
         executorService);
-    for (LambdaClass lambdaClass : knownLambdaClasses.values()) {
-      DexProgramClass synthesizedClass = lambdaClass.getLambdaClass();
-      builder.addSynthesizedClass(synthesizedClass, lambdaClass.addToMainDexList.get());
-    }
   }
 
   public Set<DexCallSite> getDesugaredCallSites() {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
index 568e021..965d44e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
@@ -31,6 +31,8 @@
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
 
 // Try with resources outlining processor. Handles $closeResource methods
 // synthesized by java 9 compiler.
@@ -45,6 +47,7 @@
 // tree shaking to remove them since now they should not be referenced.
 //
 public final class TwrCloseResourceRewriter {
+  public static final String UTILITY_CLASS_NAME = "$r8$twr$utility";
   public static final String UTILITY_CLASS_DESCRIPTOR = "L$r8$twr$utility;";
 
   private final IRConverter converter;
@@ -107,7 +110,9 @@
         && original.proto == converter.appInfo.dexItemFactory.twrCloseResourceMethodProto;
   }
 
-  public void synthesizeUtilityClass(Builder<?> builder, InternalOptions options) {
+  public void synthesizeUtilityClass(
+      Builder<?> builder, ExecutorService executorService, InternalOptions options)
+      throws ExecutionException {
     if (referencingClasses.isEmpty()) {
       return;
     }
@@ -144,7 +149,8 @@
     // Process created class and method.
     boolean addToMainDexList = referencingClasses.stream()
         .anyMatch(clazz -> converter.appInfo.isInMainDexList(clazz.type));
-    converter.optimizeSynthesizedClass(utilityClass);
+    converter.appInfo.addSynthesizedClass(utilityClass);
+    converter.optimizeSynthesizedClass(utilityClass, executorService);
     builder.addSynthesizedClass(utilityClass, addToMainDexList);
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index f7baf3e..b1bb84e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -1886,7 +1886,7 @@
       return;
     }
 
-    DexClass clazz = definitionFor(method.method.getHolder());
+    DexClass clazz = appInfo.definitionFor(method.method.getHolder());
     if (clazz == null) {
       return;
     }
@@ -2087,10 +2087,6 @@
     }
   }
 
-  DexClass definitionFor(DexType type) {
-    return converter.definitionFor(type);
-  }
-
   public void removeTrivialCheckCastAndInstanceOfInstructions(
       IRCode code, boolean enableWholeProgramOptimizations) {
     if (!enableWholeProgramOptimizations) {
@@ -2196,7 +2192,7 @@
     if (baseType.isPrimitiveType()) {
       return false;
     }
-    DexClass clazz = definitionFor(baseType);
+    DexClass clazz = appInfo.definitionFor(baseType);
     if (clazz == null) {
       // Conservatively say yes.
       return true;
@@ -3874,7 +3870,7 @@
       if (type == dexItemFactory.throwableType) {
         return true;
       }
-      DexClass dexClass = definitionFor(type);
+      DexClass dexClass = appInfo.definitionFor(type);
       if (dexClass == null) {
         throw new CompilationError("Class or interface " + type.toSourceString() +
             " required for desugaring of try-with-resources is not found.");
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
index 2c14153..22c3da8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
@@ -286,7 +286,7 @@
             ? appInfo.lookupInstanceTarget(field.getHolder(), field)
             : appInfo.lookupStaticTarget(field.getHolder(), field);
     // TODO(b/123857022): Should be possible to use `!isFieldRead(field)`.
-    if (target != null && !isFieldRead(target.field)) {
+    if (target != null && !appInfo.isFieldRead(target.field)) {
       // Remove writes to dead (i.e. never read) fields.
       iterator.removeOrReplaceByDebugLocalRead();
     }
@@ -327,17 +327,4 @@
     }
     assert code.isConsistentSSA();
   }
-
-  private boolean isFieldRead(DexField field) {
-    return appInfo.fieldsRead.contains(field)
-        // TODO(b/121354886): Pinned fields should be in `fieldsRead`.
-        || appInfo.isPinned(field)
-        // For library classes we don't know whether a field is read.
-        || isLibraryField(field);
-  }
-
-  private boolean isLibraryField(DexField field) {
-    DexClass holder = appInfo.definitionFor(field.clazz);
-    return holder == null || holder.isLibraryClass();
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index 73f2a91..27ec7dc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -1232,7 +1232,7 @@
     }
   }
 
-  public boolean selectMethodsForOutlining(Map<DexType, DexProgramClass> synthesizedClasses) {
+  public boolean selectMethodsForOutlining() {
     assert methodsSelectedForOutlining.size() == 0;
     assert outlineSites.size() == 0;
     for (List<DexEncodedMethod> outlineMethods : candidateMethodLists) {
@@ -1241,7 +1241,7 @@
           methodsSelectedForOutlining.add(
               converter
                   .graphLense()
-                  .mapDexEncodedMethod(outlineMethod, appInfo, synthesizedClasses));
+                  .mapDexEncodedMethod(outlineMethod, appInfo));
         }
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 1f036b6..a0ba213 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -117,12 +117,14 @@
     if (!eligibleClass.isClassType()) {
       return false;
     }
-    eligibleClassDefinition = appInfo.definitionFor(eligibleClass);
-    if (eligibleClassDefinition == null && lambdaRewriter != null) {
+    if (lambdaRewriter != null) {
       // Check if the class is synthesized for a desugared lambda
       eligibleClassDefinition = lambdaRewriter.getLambdaClass(eligibleClass);
       isDesugaredLambda = eligibleClassDefinition != null;
     }
+    if (eligibleClassDefinition == null) {
+      eligibleClassDefinition = appInfo.definitionFor(eligibleClass);
+    }
     return eligibleClassDefinition != null;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
index b988a89..ab6f635 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
@@ -26,6 +26,7 @@
 import com.android.tools.r8.ir.conversion.CallSiteInformation;
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.conversion.OptimizationFeedback;
+import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.Outliner;
 import com.android.tools.r8.ir.optimize.lambda.CodeProcessor.Strategy;
 import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
@@ -36,6 +37,7 @@
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.IdentityHashMap;
@@ -194,8 +196,7 @@
       IRConverter converter,
       OptimizationFeedback feedback,
       Builder<?> builder,
-      ExecutorService executorService,
-      Map<DexType, DexProgramClass> synthesizedClasses)
+      ExecutorService executorService)
       throws ExecutionException {
     if (lambdas.isEmpty()) {
       return;
@@ -218,18 +219,29 @@
     this.strategyFactory = ApplyStrategy::new;
 
     // Add synthesized lambda group classes to the builder.
-    converter.optimizeSynthesizedClasses(lambdaGroupsClasses.values(), executorService);
 
     for (Entry<LambdaGroup, DexProgramClass> entry : lambdaGroupsClasses.entrySet()) {
       DexProgramClass synthesizedClass = entry.getValue();
-      synthesizedClasses.put(synthesizedClass.type, synthesizedClass);
+      converter.appInfo.addSynthesizedClass(synthesizedClass);
       builder.addSynthesizedClass(
           synthesizedClass, entry.getKey().shouldAddToMainDex(converter.appInfo));
+      // Eventually, we need to process synthesized methods in the lambda group.
+      // Otherwise, abstract SynthesizedCode will be flown to Enqueuer.
+      // But that process should not see the holder. Otherwise, lambda calls in the main dispatch
+      // method became recursive calls via the lense rewriter. They should remain, then inliner
+      // will inline methods from mergee lambdas to the main dispatch method.
+      // Then, there is a dilemma: other sub optimizations trigger subtype lookup that will throw
+      // NPE if it cannot find the holder for this synthesized lambda group.
+      // One hack here is to mark those methods `processed` so that the lense rewriter is skipped.
+      synthesizedClass.forEachMethod(encodedMethod -> {
+        encodedMethod.markProcessed(ConstraintWithTarget.NEVER);
+      });
     }
+    converter.optimizeSynthesizedClasses(lambdaGroupsClasses.values(), executorService);
 
     // Rewrite lambda class references into lambda group class
     // references inside methods from the processing queue.
-    rewriteLambdaReferences(converter, synthesizedClasses, feedback);
+    rewriteLambdaReferences(converter, feedback);
     this.strategyFactory = null;
   }
 
@@ -304,10 +316,7 @@
     }
   }
 
-  private void rewriteLambdaReferences(
-      IRConverter converter,
-      Map<DexType, DexProgramClass> synthesizedClasses,
-      OptimizationFeedback feedback) {
+  private void rewriteLambdaReferences(IRConverter converter, OptimizationFeedback feedback) {
     List<DexEncodedMethod> methods =
         methodsToReprocess
             .stream()
@@ -315,9 +324,9 @@
             .collect(Collectors.toList());
     for (DexEncodedMethod method : methods) {
       DexEncodedMethod mappedMethod =
-          converter.graphLense().mapDexEncodedMethod(method, converter.appInfo, synthesizedClasses);
+          converter.graphLense().mapDexEncodedMethod(method, converter.appInfo);
       converter.processMethod(mappedMethod, feedback,
-          x -> false, CallSiteInformation.empty(), Outliner::noProcessing);
+          Predicates.alwaysFalse(), CallSiteInformation.empty(), Outliner::noProcessing);
       assert mappedMethod.isProcessed();
     }
   }
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 f40cb1d..8de2695 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -1985,11 +1985,11 @@
     /**
      * Set of all fields which may be touched by a get operation. This is actual field definitions.
      */
-    public final SortedSet<DexField> fieldsRead;
+    private final SortedSet<DexField> fieldsRead;
     /**
      * Set of all fields which may be touched by a put operation. This is actual field definitions.
      */
-    public final SortedSet<DexField> fieldsWritten;
+    private final SortedSet<DexField> fieldsWritten;
     /**
      * Set of all field ids used in instance field reads, along with access context.
      */
@@ -2359,7 +2359,8 @@
 
     public boolean isInstantiatedDirectly(DexType type) {
       assert type.isClassType();
-      return instantiatedTypes.contains(type)
+      return type.isD8R8SynthesizedClassType()
+          || instantiatedTypes.contains(type)
           || instantiatedLambdas.contains(type)
           || instantiatedAnnotationTypes.contains(type);
     }
@@ -2386,6 +2387,31 @@
       return isInstantiatedDirectly(type) || isInstantiatedIndirectly(type);
     }
 
+    public boolean isFieldRead(DexField field) {
+      return fieldsRead.contains(field)
+          // TODO(b/121354886): Pinned fields should be in `fieldsRead`.
+          || isPinned(field)
+          // Fields in the class that is synthesized by D8/R8 would be used soon.
+          || field.getHolder().isD8R8SynthesizedClassType()
+          // For library classes we don't know whether a field is read.
+          || isLibraryField(field);
+    }
+
+    public boolean isFieldWritten(DexField field) {
+      return fieldsWritten.contains(field)
+          // TODO(b/121354886): Pinned fields should be in `fieldsWritten`.
+          || isPinned(field)
+          // Fields in the class that is synthesized by D8/R8 would be used soon.
+          || field.clazz.isD8R8SynthesizedClassType()
+          // For library classes we don't know whether a field is rewritten.
+          || isLibraryField(field);
+    }
+
+    private boolean isLibraryField(DexField field) {
+      DexClass holder = definitionFor(field.clazz);
+      return holder == null || holder.isLibraryClass();
+    }
+
     private Object2BooleanMap<DexReference> joinIdentifierNameStrings(
         Set<DexReference> explicit, Set<DexReference> implicit) {
       Object2BooleanMap<DexReference> result = new Object2BooleanArrayMap<>();
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index dd8bcd6..786d026 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -228,8 +228,8 @@
     Predicate<DexField> isReachableOrReferencedField =
         field ->
             appInfo.liveFields.contains(field)
-                || appInfo.fieldsRead.contains(field)
-                || appInfo.fieldsWritten.contains(field);
+                || appInfo.isFieldRead(field)
+                || appInfo.isFieldWritten(field);
     int firstUnreachable =
         firstUnreachableIndex(Arrays.asList(fields), isReachableOrReferencedField);
     // Return the original array if all fields are used.