diff --git a/build.gradle b/build.gradle
index 921a270..2045d5a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -45,8 +45,8 @@
     mockitoVersion = '2.10.0'
     // The kotlin version is only here to specify the kotlin language level,
     // all kotlin compilations are done in tests.
-    kotlinVersion = '1.5.0'
-    kotlinExtMetadataJVMVersion = '0.3.0'
+    kotlinVersion = '1.6.0'
+    kotlinExtMetadataJVMVersion = '0.4.1'
     smaliVersion = '2.2b4'
     errorproneVersion = '2.3.2'
     testngVersion = '6.10'
@@ -2201,6 +2201,13 @@
         systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
     }
 
+    if (project.hasProperty('kotlin_compiler_dev')) {
+        systemProperty 'com.android.tools.r8.kotlincompilerdev', '1';
+    }
+
+    if (project.hasProperty('kotlin_compiler_old')) {
+        systemProperty 'com.android.tools.r8.kotlincompilerold', '1';
+    }
 
     if (!useTestingState) {
         testLogging.exceptionFormat = 'full'
diff --git a/infra/config/global/generated/cr-buildbucket.cfg b/infra/config/global/generated/cr-buildbucket.cfg
index 4623314..31f7a57 100644
--- a/infra/config/global/generated/cr-buildbucket.cfg
+++ b/infra/config/global/generated/cr-buildbucket.cfg
@@ -1078,7 +1078,7 @@
         cipd_package: "infra_internal/recipe_bundles/chrome-internal.googlesource.com/chrome/tools/build_limited/scripts/slave"
         cipd_version: "refs/heads/master"
         properties_j: "builder_group:\"internal.client.r8\""
-        properties_j: "test_options:[\"--runtimes=dex-default:jdk11\",\"--kotlin-compiler-dev\",\"--one_line_per_test\",\"--archive_failures\",\"--no-internal\",\"*kotlin*\"]"
+        properties_j: "test_options:[\"--runtimes=dex-default:jdk11\",\"--kotlin-compiler-dev\",\"--one_line_per_test\",\"--archive_failures\",\"--no-internal\",\"*kotlin*\",\"*debug*\"]"
       }
       priority: 26
       execution_timeout_secs: 43200
@@ -1107,7 +1107,7 @@
         cipd_package: "infra_internal/recipe_bundles/chrome-internal.googlesource.com/chrome/tools/build_limited/scripts/slave"
         cipd_version: "refs/heads/master"
         properties_j: "builder_group:\"internal.client.r8\""
-        properties_j: "test_options:[\"--runtimes=dex-default:jdk11\",\"--kotlin-compiler-old\",\"--one_line_per_test\",\"--archive_failures\",\"--no-internal\",\"*kotlin*\"]"
+        properties_j: "test_options:[\"--runtimes=dex-default:jdk11\",\"--kotlin-compiler-old\",\"--one_line_per_test\",\"--archive_failures\",\"--no-internal\",\"*kotlin*\",\"*debug*\"]"
       }
       priority: 26
       execution_timeout_secs: 43200
diff --git a/infra/config/global/main.star b/infra/config/global/main.star
index 3aa3fe2..6d178eb 100755
--- a/infra/config/global/main.star
+++ b/infra/config/global/main.star
@@ -332,7 +332,7 @@
     expiration_timeout = time.hour * 35,
     properties = {
       "builder_group" : "internal.client.r8",
-      "test_options" : ["--runtimes=dex-default:jdk11", "--kotlin-compiler-dev", "--one_line_per_test", "--archive_failures", "--no-internal", "*kotlin*"]
+      "test_options" : ["--runtimes=dex-default:jdk11", "--kotlin-compiler-dev", "--one_line_per_test", "--archive_failures", "--no-internal", "*kotlin*", "*debug*"]
     }
 )
 
@@ -343,7 +343,7 @@
     expiration_timeout = time.hour * 35,
     properties = {
       "builder_group" : "internal.client.r8",
-      "test_options" : ["--runtimes=dex-default:jdk11", "--kotlin-compiler-old", "--one_line_per_test", "--archive_failures", "--no-internal", "*kotlin*"]
+      "test_options" : ["--runtimes=dex-default:jdk11", "--kotlin-compiler-old", "--one_line_per_test", "--archive_failures", "--no-internal", "*kotlin*", "*debug*"]
     }
 )
 
diff --git a/src/main/java/com/android/tools/r8/DumpOptions.java b/src/main/java/com/android/tools/r8/DumpOptions.java
index e8c6a49..14ae9c6 100644
--- a/src/main/java/com/android/tools/r8/DumpOptions.java
+++ b/src/main/java/com/android/tools/r8/DumpOptions.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8;
 
 import com.android.tools.r8.dex.Marker.Tool;
+import com.android.tools.r8.experimental.startup.StartupConfiguration;
 import com.android.tools.r8.features.FeatureSplitConfiguration;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryConfiguration;
 import com.android.tools.r8.shaking.ProguardConfiguration;
@@ -147,6 +148,11 @@
     return featureSplitConfiguration;
   }
 
+  public StartupConfiguration getStartupConfiguration() {
+    // The startup configuration is not included in dumps.
+    return null;
+  }
+
   public String getParsedProguardConfiguration() {
     return proguardConfiguration == null ? null : proguardConfiguration.getParsedConfiguration();
   }
diff --git a/src/main/java/com/android/tools/r8/FeatureSplit.java b/src/main/java/com/android/tools/r8/FeatureSplit.java
index d0eafdb..9b55bde 100644
--- a/src/main/java/com/android/tools/r8/FeatureSplit.java
+++ b/src/main/java/com/android/tools/r8/FeatureSplit.java
@@ -38,6 +38,14 @@
         }
       };
 
+  public static final FeatureSplit BASE_STARTUP =
+      new FeatureSplit(null, null) {
+        @Override
+        public boolean isBase() {
+          return true;
+        }
+      };
+
   private final ProgramConsumer programConsumer;
   private final List<ProgramResourceProvider> programResourceProviders;
 
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index 9946047..b0eec1a 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -19,7 +19,6 @@
 import com.android.tools.r8.naming.PrefixRewritingNamingLens;
 import com.android.tools.r8.naming.signature.GenericSignatureRewriter;
 import com.android.tools.r8.origin.CommandLineOrigin;
-import com.android.tools.r8.shaking.AnnotationRemover;
 import com.android.tools.r8.shaking.L8TreePruner;
 import com.android.tools.r8.synthesis.SyntheticFinalization;
 import com.android.tools.r8.utils.AndroidApp;
@@ -135,10 +134,6 @@
 
       AppView<AppInfo> appView = readApp(inputApp, options, executor, timing);
 
-      if (!options.testing.disableL8AnnotationRemoval) {
-        AnnotationRemover.clearAnnotations(appView);
-      }
-
       new IRConverter(appView, timing).convert(appView, executor);
 
       SyntheticFinalization.finalize(appView, executor);
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index cec2d83..4b53393 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.dex.Marker.Tool;
 import com.android.tools.r8.errors.DexFileOverflowDiagnostic;
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
+import com.android.tools.r8.experimental.startup.StartupConfiguration;
 import com.android.tools.r8.features.FeatureSplitConfiguration;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.inspector.Inspector;
@@ -819,6 +820,10 @@
     skipDump = false;
   }
 
+  public DexItemFactory getDexItemFactory() {
+    return proguardConfiguration.getDexItemFactory();
+  }
+
   /** Get the enable-tree-shaking state. */
   public boolean getEnableTreeShaking() {
     return enableTreeShaking;
@@ -905,6 +910,9 @@
 
     internal.featureSplitConfiguration = featureSplitConfiguration;
 
+    internal.startupConfiguration =
+        StartupConfiguration.createStartupConfiguration(getDexItemFactory(), getReporter());
+
     internal.syntheticProguardRulesConsumer = syntheticProguardRulesConsumer;
 
     internal.outputInspections = InspectorImpl.wrapInspections(getOutputInspections());
diff --git a/src/main/java/com/android/tools/r8/dex/JumboStringRewriter.java b/src/main/java/com/android/tools/r8/dex/JumboStringRewriter.java
index e402ce5..990d545 100644
--- a/src/main/java/com/android/tools/r8/dex/JumboStringRewriter.java
+++ b/src/main/java/com/android/tools/r8/dex/JumboStringRewriter.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.dex;
 
 import static com.android.tools.r8.graph.DexCode.TryHandler.NO_HANDLER;
+import static com.android.tools.r8.graph.DexDebugEventBuilder.addDefaultEventWithAdvancePcIfNecessary;
 
 import com.android.tools.r8.code.ConstString;
 import com.android.tools.r8.code.ConstStringJumbo;
@@ -233,7 +234,7 @@
           Instruction target = debugEventTargets.get(lastOriginalOffset);
           int lineDelta = defaultEvent.getLineDelta();
           int pcDelta = target.getOffset() - lastNewOffset;
-          addDefaultEvent(lineDelta, pcDelta, events);
+          addDefaultEventWithAdvancePcIfNecessary(lineDelta, pcDelta, events, factory);
           lastNewOffset = target.getOffset();
         } else {
           events.add(event);
@@ -247,27 +248,6 @@
     return code.getDebugInfo();
   }
 
-  // Add a default event. If the lineDelta and pcDelta can be encoded in one default event
-  // that will be done. Otherwise, this can output an advance line and/or advance pc event
-  // followed by a default event. A default event is always emitted as that is what will
-  // materialize an entry in the line table.
-  private void addDefaultEvent(int lineDelta, int pcDelta, List<DexDebugEvent> events) {
-    if (lineDelta < Constants.DBG_LINE_BASE
-        || lineDelta - Constants.DBG_LINE_BASE >= Constants.DBG_LINE_RANGE) {
-      events.add(factory.createAdvanceLine(lineDelta));
-      lineDelta = 0;
-    }
-    if (pcDelta >= Constants.DBG_ADDRESS_RANGE) {
-      events.add(factory.createAdvancePC(pcDelta));
-      pcDelta = 0;
-    }
-    int specialOpcode =
-        0x0a + (lineDelta - Constants.DBG_LINE_BASE) + Constants.DBG_LINE_RANGE * pcDelta;
-    assert specialOpcode >= 0x0a;
-    assert specialOpcode <= 0xff;
-    events.add(factory.createDefault(specialOpcode));
-  }
-
   private List<Instruction> expandCode() {
     LinkedList<Instruction> instructions = new LinkedList<>();
     Collections.addAll(instructions, method.getCode().asDexCode().instructions);
diff --git a/src/main/java/com/android/tools/r8/experimental/startup/StartupConfiguration.java b/src/main/java/com/android/tools/r8/experimental/startup/StartupConfiguration.java
new file mode 100644
index 0000000..c87d584
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/experimental/startup/StartupConfiguration.java
@@ -0,0 +1,69 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.experimental.startup;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.ExceptionDiagnostic;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.StringDiagnostic;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StartupConfiguration {
+
+  List<DexType> startupClasses;
+
+  public StartupConfiguration(List<DexType> startupClasses) {
+    this.startupClasses = startupClasses;
+  }
+
+  public static StartupConfiguration createStartupConfiguration(
+      DexItemFactory dexItemFactory, Reporter reporter) {
+    String propertyValue = System.getProperty("com.android.tools.r8.startupclassdescriptors");
+    if (propertyValue == null) {
+      return null;
+    }
+
+    List<String> startupClassDescriptors;
+    try {
+      startupClassDescriptors = FileUtils.readAllLines(Paths.get(propertyValue));
+    } catch (IOException e) {
+      throw reporter.fatalError(new ExceptionDiagnostic(e));
+    }
+
+    if (startupClassDescriptors.isEmpty()) {
+      return null;
+    }
+
+    List<DexType> startupClasses = new ArrayList<>(startupClassDescriptors.size());
+    for (String startupClassDescriptor : startupClassDescriptors) {
+      if (startupClassDescriptor.trim().isEmpty()) {
+        continue;
+      }
+      if (!DescriptorUtils.isClassDescriptor(startupClassDescriptor)) {
+        reporter.warning(
+            new StringDiagnostic(
+                "Invalid class descriptor for startup class: " + startupClassDescriptor));
+        continue;
+      }
+      DexType startupClass = dexItemFactory.createType(startupClassDescriptor);
+      startupClasses.add(startupClass);
+    }
+    return new StartupConfiguration(startupClasses);
+  }
+
+  public boolean hasStartupClasses() {
+    return !startupClasses.isEmpty();
+  }
+
+  public List<DexType> getStartupClasses() {
+    return startupClasses;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java b/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
index f460b50..215b25a 100644
--- a/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
+++ b/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.ProgramResource;
 import com.android.tools.r8.ProgramResourceProvider;
 import com.android.tools.r8.ResourceException;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.experimental.startup.StartupConfiguration;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
@@ -22,78 +22,96 @@
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Reporter;
 import com.google.common.collect.Sets;
-import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
 
 public class ClassToFeatureSplitMap {
 
-  private final Map<DexType, FeatureSplit> classToFeatureSplitMap = new IdentityHashMap<>();
+  private final FeatureSplit baseStartup;
+  private final Map<DexType, FeatureSplit> classToFeatureSplitMap;
   private final Map<FeatureSplit, String> representativeStringsForFeatureSplit;
 
-  private ClassToFeatureSplitMap() {
-    this(new HashMap<>());
-  }
-
-  private ClassToFeatureSplitMap(Map<FeatureSplit, String> representativeStringsForFeatureSplit) {
+  private ClassToFeatureSplitMap(
+      FeatureSplit baseStartup,
+      Map<DexType, FeatureSplit> classToFeatureSplitMap,
+      Map<FeatureSplit, String> representativeStringsForFeatureSplit) {
+    this.baseStartup = baseStartup;
+    this.classToFeatureSplitMap = classToFeatureSplitMap;
     this.representativeStringsForFeatureSplit = representativeStringsForFeatureSplit;
   }
 
   public static ClassToFeatureSplitMap createEmptyClassToFeatureSplitMap() {
-    return new ClassToFeatureSplitMap(null);
-  }
-
-  public static ClassToFeatureSplitMap createInitialClassToFeatureSplitMap(
-      AppView<? extends AppInfoWithClassHierarchy> appView) {
-    return createInitialClassToFeatureSplitMap(appView.options());
+    return new ClassToFeatureSplitMap(FeatureSplit.BASE, new IdentityHashMap<>(), null);
   }
 
   public static ClassToFeatureSplitMap createInitialClassToFeatureSplitMap(
       InternalOptions options) {
     return createInitialClassToFeatureSplitMap(
-        options.dexItemFactory(), options.featureSplitConfiguration, options.reporter);
+        options.dexItemFactory(),
+        options.featureSplitConfiguration,
+        options.startupConfiguration,
+        options.reporter);
   }
 
   public static ClassToFeatureSplitMap createInitialClassToFeatureSplitMap(
       DexItemFactory dexItemFactory,
       FeatureSplitConfiguration featureSplitConfiguration,
+      StartupConfiguration startupConfiguration,
       Reporter reporter) {
-
-    ClassToFeatureSplitMap result = new ClassToFeatureSplitMap();
-    if (featureSplitConfiguration == null) {
-      return result;
+    if (featureSplitConfiguration == null && startupConfiguration == null) {
+      return createEmptyClassToFeatureSplitMap();
     }
 
-    for (FeatureSplit featureSplit : featureSplitConfiguration.getFeatureSplits()) {
-      String representativeType = null;
-      for (ProgramResourceProvider programResourceProvider :
-          featureSplit.getProgramResourceProviders()) {
-        try {
-          for (ProgramResource programResource : programResourceProvider.getProgramResources()) {
-            for (String classDescriptor : programResource.getClassDescriptors()) {
-              DexType type = dexItemFactory.createType(classDescriptor);
-              result.classToFeatureSplitMap.put(type, featureSplit);
-              if (representativeType == null || classDescriptor.compareTo(representativeType) > 0) {
-                representativeType = classDescriptor;
+    Map<DexType, FeatureSplit> classToFeatureSplitMap = new IdentityHashMap<>();
+    Map<FeatureSplit, String> representativeStringsForFeatureSplit = new IdentityHashMap<>();
+    if (featureSplitConfiguration != null) {
+      for (FeatureSplit featureSplit : featureSplitConfiguration.getFeatureSplits()) {
+        String representativeType = null;
+        for (ProgramResourceProvider programResourceProvider :
+            featureSplit.getProgramResourceProviders()) {
+          try {
+            for (ProgramResource programResource : programResourceProvider.getProgramResources()) {
+              for (String classDescriptor : programResource.getClassDescriptors()) {
+                DexType type = dexItemFactory.createType(classDescriptor);
+                classToFeatureSplitMap.put(type, featureSplit);
+                if (representativeType == null
+                    || classDescriptor.compareTo(representativeType) > 0) {
+                  representativeType = classDescriptor;
+                }
               }
             }
+          } catch (ResourceException e) {
+            throw reporter.fatalError(e.getMessage());
           }
-        } catch (ResourceException e) {
-          throw reporter.fatalError(e.getMessage());
+        }
+        if (representativeType != null) {
+          representativeStringsForFeatureSplit.put(featureSplit, representativeType);
         }
       }
-      if (representativeType != null) {
-        result.representativeStringsForFeatureSplit.put(featureSplit, representativeType);
-      }
     }
-    return result;
-  }
 
-  public int compareFeatureSplitsForDexTypes(DexType a, DexType b, SyntheticItems syntheticItems) {
-    FeatureSplit featureSplitA = getFeatureSplit(a, syntheticItems);
-    FeatureSplit featureSplitB = getFeatureSplit(b, syntheticItems);
-    return compareFeatureSplits(featureSplitA, featureSplitB);
+    FeatureSplit baseStartup;
+    if (startupConfiguration != null && startupConfiguration.hasStartupClasses()) {
+      DexType representativeType = null;
+      for (DexType startupClass : startupConfiguration.getStartupClasses()) {
+        if (classToFeatureSplitMap.containsKey(startupClass)) {
+          continue;
+        }
+        classToFeatureSplitMap.put(startupClass, FeatureSplit.BASE_STARTUP);
+        if (representativeType == null
+            || startupClass.getDescriptor().compareTo(representativeType.getDescriptor()) > 0) {
+          representativeType = startupClass;
+        }
+      }
+      baseStartup = FeatureSplit.BASE_STARTUP;
+      representativeStringsForFeatureSplit.put(
+          baseStartup, representativeType.toDescriptorString());
+    } else {
+      baseStartup = FeatureSplit.BASE;
+    }
+    return new ClassToFeatureSplitMap(
+        baseStartup, classToFeatureSplitMap, representativeStringsForFeatureSplit);
   }
 
   public int compareFeatureSplits(FeatureSplit featureSplitA, FeatureSplit featureSplitB) {
@@ -114,6 +132,14 @@
         .compareTo(representativeStringsForFeatureSplit.get(featureSplitB));
   }
 
+  /**
+   * Returns the base startup if there are any startup classes given on input. Otherwise returns
+   * base.
+   */
+  public FeatureSplit getBaseStartup() {
+    return baseStartup;
+  }
+
   public Map<FeatureSplit, Set<DexProgramClass>> getFeatureSplitClasses(
       Set<DexProgramClass> classes, SyntheticItems syntheticItems) {
     Map<FeatureSplit, Set<DexProgramClass>> result = new IdentityHashMap<>();
@@ -135,7 +161,7 @@
     if (feature != null) {
       return feature;
     }
-    feature = syntheticItems.getContextualFeatureSplit(type);
+    feature = syntheticItems.getContextualFeatureSplit(type, this);
     if (feature != null) {
       return feature;
     }
@@ -168,23 +194,18 @@
     return !isInBase(clazz, syntheticItems);
   }
 
-  public boolean isInSameFeatureOrBothInBase(
+  public boolean isInSameFeatureOrBothInSameBase(
       ProgramMethod a, ProgramMethod b, SyntheticItems syntheticItems) {
-    return isInSameFeatureOrBothInBase(a.getHolder(), b.getHolder(), syntheticItems);
+    return isInSameFeatureOrBothInSameBase(a.getHolder(), b.getHolder(), syntheticItems);
   }
 
-  public boolean isInSameFeatureOrBothInBase(
+  public boolean isInSameFeatureOrBothInSameBase(
       DexProgramClass a, DexProgramClass b, SyntheticItems syntheticItems) {
     return getFeatureSplit(a, syntheticItems) == getFeatureSplit(b, syntheticItems);
   }
 
-  public boolean isInSameFeatureOrBothInBase(DexType a, DexType b, SyntheticItems syntheticItems) {
-    return getFeatureSplit(a, syntheticItems) == getFeatureSplit(b, syntheticItems);
-  }
-
   public ClassToFeatureSplitMap rewrittenWithLens(GraphLens lens) {
-    ClassToFeatureSplitMap rewrittenClassToFeatureSplitMap =
-        new ClassToFeatureSplitMap(representativeStringsForFeatureSplit);
+    Map<DexType, FeatureSplit> rewrittenClassToFeatureSplitMap = new IdentityHashMap<>();
     classToFeatureSplitMap.forEach(
         (type, featureSplit) -> {
           DexType rewrittenType = lens.lookupType(type);
@@ -192,25 +213,24 @@
             // The type was removed by enum unboxing.
             return;
           }
-          FeatureSplit existing =
-              rewrittenClassToFeatureSplitMap.classToFeatureSplitMap.put(
-                  rewrittenType, featureSplit);
+          FeatureSplit existing = rewrittenClassToFeatureSplitMap.put(rewrittenType, featureSplit);
           // If we map two classes to the same class then they must be from the same feature split.
           assert existing == null || existing == featureSplit;
         });
-    return rewrittenClassToFeatureSplitMap;
+    return new ClassToFeatureSplitMap(
+        baseStartup, rewrittenClassToFeatureSplitMap, representativeStringsForFeatureSplit);
   }
 
   public ClassToFeatureSplitMap withoutPrunedItems(PrunedItems prunedItems) {
-    ClassToFeatureSplitMap classToFeatureSplitMapAfterPruning =
-        new ClassToFeatureSplitMap(representativeStringsForFeatureSplit);
+    Map<DexType, FeatureSplit> rewrittenClassToFeatureSplitMap = new IdentityHashMap<>();
     classToFeatureSplitMap.forEach(
         (type, featureSplit) -> {
           if (!prunedItems.getRemovedClasses().contains(type)) {
-            classToFeatureSplitMapAfterPruning.classToFeatureSplitMap.put(type, featureSplit);
+            rewrittenClassToFeatureSplitMap.put(type, featureSplit);
           }
         });
-    return classToFeatureSplitMapAfterPruning;
+    return new ClassToFeatureSplitMap(
+        baseStartup, rewrittenClassToFeatureSplitMap, representativeStringsForFeatureSplit);
   }
 
   // Static helpers to avoid verbose predicates.
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 e5a744b..1cf6ae7 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
-import com.android.tools.r8.FeatureSplit;
 import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter;
 import com.android.tools.r8.origin.Origin;
@@ -13,7 +12,6 @@
 import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.BooleanBox;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.IterableUtils;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -125,26 +123,6 @@
     return syntheticItems;
   }
 
-  public void addSynthesizedClassForLibraryDesugaring(DexProgramClass clazz) {
-    assert checkIfObsolete();
-    assert options().desugaredLibraryConfiguration != null;
-    syntheticItems.addLegacySyntheticClassForLibraryDesugaring(clazz);
-  }
-
-  public void addSynthesizedClass(DexProgramClass clazz, ProgramDefinition context) {
-    assert checkIfObsolete();
-    assert context != null;
-    syntheticItems.addLegacySyntheticClass(clazz, context, FeatureSplit.BASE);
-  }
-
-  public void addSynthesizedClassToBase(DexProgramClass clazz, Iterable<DexProgramClass> contexts) {
-    assert checkIfObsolete();
-    assert !IterableUtils.isEmpty(contexts);
-    SyntheticItems syntheticItems = getSyntheticItems();
-    contexts.forEach(
-        context -> syntheticItems.addLegacySyntheticClass(clazz, context, FeatureSplit.BASE));
-  }
-
   public List<DexProgramClass> classes() {
     assert checkIfObsolete();
     return app.classes();
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
index 4eaea9f..c928847 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
@@ -7,7 +7,6 @@
 import static com.android.tools.r8.utils.TraversalContinuation.BREAK;
 import static com.android.tools.r8.utils.TraversalContinuation.CONTINUE;
 
-import com.android.tools.r8.FeatureSplit;
 import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
 import com.android.tools.r8.graph.MethodResolutionResult.ArrayCloneMethodResult;
@@ -161,15 +160,6 @@
     return this;
   }
 
-  @Override
-  public void addSynthesizedClass(DexProgramClass clazz, ProgramDefinition context) {
-    assert checkIfObsolete();
-    assert context != null;
-    FeatureSplit featureSplit =
-        classToFeatureSplitMap.getFeatureSplit(context, getSyntheticItems());
-    getSyntheticItems().addLegacySyntheticClass(clazz, context, featureSplit);
-  }
-
   /** Primitive traversal over all (non-interface) superclasses of a given type. */
   public TraversalContinuation traverseSuperClasses(
       DexClass clazz, TriFunction<DexType, DexClass, DexClass, TraversalContinuation> fn) {
diff --git a/src/main/java/com/android/tools/r8/graph/AppServices.java b/src/main/java/com/android/tools/r8/graph/AppServices.java
index 7fedd7c..b5b0c60 100644
--- a/src/main/java/com/android/tools/r8/graph/AppServices.java
+++ b/src/main/java/com/android/tools/r8/graph/AppServices.java
@@ -103,21 +103,28 @@
               + "`";
       return true;
     }
-    if (featureImplementations.size() > 1
-        || !featureImplementations.containsKey(FeatureSplit.BASE)) {
+    if (featureImplementations.keySet().stream().anyMatch(feature -> !feature.isBase())) {
       return true;
     }
+    // All service implementations are in one of the base splits.
+    assert featureImplementations.size() <= 2;
     // Check if service is defined feature
     DexProgramClass serviceClass = appView.definitionForProgramType(serviceType);
     if (serviceClass != null
         && classToFeatureSplitMap.isInFeature(serviceClass, appView.getSyntheticItems())) {
       return true;
     }
-    for (DexType implementationType : featureImplementations.get(FeatureSplit.BASE)) {
-      DexProgramClass implementationClass = appView.definitionForProgramType(implementationType);
-      if (implementationClass != null
-          && classToFeatureSplitMap.isInFeature(implementationClass, appView.getSyntheticItems())) {
-        return true;
+    for (Entry<FeatureSplit, List<DexType>> entry : featureImplementations.entrySet()) {
+      FeatureSplit feature = entry.getKey();
+      assert feature.isBase();
+      List<DexType> implementationTypes = entry.getValue();
+      for (DexType implementationType : implementationTypes) {
+        DexProgramClass implementationClass = appView.definitionForProgramType(implementationType);
+        if (implementationClass != null
+            && classToFeatureSplitMap.isInFeature(
+                implementationClass, appView.getSyntheticItems())) {
+          return true;
+        }
       }
     }
     return false;
@@ -216,6 +223,7 @@
 
     public AppServices build() {
       for (DataResourceProvider provider : appView.appInfo().app().dataResourceProviders) {
+        // TODO(b/208677025): This should use BASE_STARTUP for startup classes.
         readServices(provider, FeatureSplit.BASE);
       }
       if (options.featureSplitConfiguration != null) {
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index e21fbf4..303eaf8e 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -33,6 +33,7 @@
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagator;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.KeepClassInfo;
+import com.android.tools.r8.shaking.KeepFieldInfo;
 import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.shaking.KeepMethodInfo;
 import com.android.tools.r8.shaking.LibraryModeledPredicate;
@@ -213,6 +214,10 @@
     return simpleInliningConstraintFactory;
   }
 
+  public DexApplication app() {
+    return appInfo().app();
+  }
+
   public T appInfo() {
     assert !appInfo.hasClassHierarchy() || enableWholeProgramOptimizations();
     return appInfo;
@@ -533,6 +538,10 @@
     return getKeepInfo().getClassInfo(clazz);
   }
 
+  public KeepFieldInfo getKeepInfo(ProgramField field) {
+    return getKeepInfo().getFieldInfo(field);
+  }
+
   public KeepMethodInfo getKeepInfo(ProgramMethod method) {
     return getKeepInfo().getMethodInfo(method);
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexApplication.java b/src/main/java/com/android/tools/r8/graph/DexApplication.java
index 309a768..d0a336a 100644
--- a/src/main/java/com/android/tools/r8/graph/DexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DexApplication.java
@@ -22,7 +22,7 @@
 import java.util.List;
 import java.util.function.Predicate;
 
-public abstract class DexApplication {
+public abstract class DexApplication implements DexDefinitionSupplier {
 
   public final ImmutableList<DataResourceProvider> dataResourceProviders;
 
@@ -56,6 +56,11 @@
 
   public abstract Builder<?> builder();
 
+  @Override
+  public DexItemFactory dexItemFactory() {
+    return dexItemFactory;
+  }
+
   public DexDefinitionSupplier getDefinitionsSupplier(
       SyntheticDefinitionsProvider syntheticDefinitionsProvider) {
     DexApplication self = this;
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index e359150..6cef0f6 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -318,7 +318,7 @@
   }
 
   public void forEachFieldMatching(
-      Predicate<DexEncodedField> predicate, Consumer<DexEncodedField> consumer) {
+      Predicate<? super DexEncodedField> predicate, Consumer<? super DexEncodedField> consumer) {
     fields(predicate).forEach(consumer);
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java b/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
index 8091db7..71822f6 100644
--- a/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
+++ b/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
@@ -261,6 +261,11 @@
           factory.createSetOutlineCallerFrame(
               nextPosition.getOutlineCallee(), nextPosition.getOutlinePositions()));
     }
+    addDefaultEventWithAdvancePcIfNecessary(lineDelta, pcDelta, events, factory);
+  }
+
+  public static void addDefaultEventWithAdvancePcIfNecessary(
+      int lineDelta, int pcDelta, List<DexDebugEvent> events, DexItemFactory factory) {
     if (lineDelta < Constants.DBG_LINE_BASE
         || lineDelta - Constants.DBG_LINE_BASE >= Constants.DBG_LINE_RANGE) {
       events.add(factory.createAdvanceLine(lineDelta));
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 2bbb51b..2e09eec 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -196,7 +196,12 @@
   }
 
   public void forEachProgramField(Consumer<? super ProgramField> consumer) {
-    forEachField(field -> consumer.accept(new ProgramField(this, field)));
+    forEachProgramFieldMatching(alwaysTrue(), consumer);
+  }
+
+  public void forEachProgramFieldMatching(
+      Predicate<? super DexEncodedField> predicate, Consumer<? super ProgramField> consumer) {
+    forEachFieldMatching(predicate, field -> consumer.accept(new ProgramField(this, field)));
   }
 
   public void forEachProgramInstanceField(Consumer<? super ProgramField> consumer) {
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 b3e8f74..8315b20 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -7,6 +7,8 @@
 
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.references.ClassReference;
@@ -54,8 +56,21 @@
     return Reference.classFromDescriptor(toDescriptorString());
   }
 
+  public DynamicTypeWithUpperBound toDynamicType(AppView<AppInfoWithLiveness> appView) {
+    return toDynamicType(appView, Nullability.maybeNull());
+  }
+
+  public DynamicTypeWithUpperBound toDynamicType(
+      AppView<AppInfoWithLiveness> appView, Nullability nullability) {
+    return DynamicType.create(appView, toTypeElement(appView, nullability));
+  }
+
   public TypeElement toTypeElement(AppView<?> appView) {
-    return TypeElement.fromDexType(this, Nullability.maybeNull(), appView);
+    return toTypeElement(appView, Nullability.maybeNull());
+  }
+
+  public TypeElement toTypeElement(AppView<?> appView, Nullability nullability) {
+    return TypeElement.fromDexType(this, nullability, appView);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
index 5328885..0a60b01 100644
--- a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
+++ b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.utils.IteratorUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Ordering;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry;
 import it.unimi.dsi.fastutil.ints.Int2ObjectRBTreeMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectSortedMap;
@@ -49,6 +50,12 @@
           }
 
           @Override
+          public ArgumentInfo rewrittenWithLens(
+              AppView<AppInfoWithLiveness> appView, GraphLens graphLens) {
+            return this;
+          }
+
+          @Override
           public boolean equals(Object obj) {
             return obj == this;
           }
@@ -91,6 +98,9 @@
     // ArgumentInfo are combined with `this` first, and the `info` argument second.
     public abstract ArgumentInfo combine(ArgumentInfo info);
 
+    public abstract ArgumentInfo rewrittenWithLens(
+        AppView<AppInfoWithLiveness> appView, GraphLens graphLens);
+
     @Override
     public abstract boolean equals(Object obj);
 
@@ -166,6 +176,18 @@
     }
 
     @Override
+    public RemovedArgumentInfo rewrittenWithLens(
+        AppView<AppInfoWithLiveness> appView, GraphLens graphLens) {
+      SingleValue rewrittenSingleValue =
+          hasSingleValue() ? singleValue.rewrittenWithLens(appView, graphLens) : null;
+      DexType rewrittenType = graphLens.lookupType(type);
+      if (rewrittenSingleValue != singleValue || rewrittenType != type) {
+        return new RemovedArgumentInfo(rewrittenSingleValue, rewrittenType);
+      }
+      return this;
+    }
+
+    @Override
     public boolean equals(Object obj) {
       if (obj == null || getClass() != obj.getClass()) {
         return false;
@@ -253,6 +275,19 @@
     }
 
     @Override
+    public RewrittenTypeInfo rewrittenWithLens(
+        AppView<AppInfoWithLiveness> appView, GraphLens graphLens) {
+      DexType rewrittenNewType = graphLens.lookupType(newType);
+      SingleValue rewrittenSingleValue =
+          hasSingleValue() ? getSingleValue().rewrittenWithLens(appView, graphLens) : null;
+      if (rewrittenNewType != newType || rewrittenSingleValue != singleValue) {
+        // The old type is intentionally not rewritten.
+        return new RewrittenTypeInfo(oldType, rewrittenNewType, rewrittenSingleValue);
+      }
+      return this;
+    }
+
+    @Override
     public boolean equals(Object obj) {
       if (obj == null || getClass() != obj.getClass()) {
         return false;
@@ -368,6 +403,28 @@
       return argumentInfos.size();
     }
 
+    public ArgumentInfoCollection rewrittenWithLens(
+        AppView<AppInfoWithLiveness> appView, GraphLens graphLens) {
+      Int2ObjectSortedMap<ArgumentInfo> rewrittenArgumentInfos = new Int2ObjectRBTreeMap<>();
+      for (Int2ObjectMap.Entry<ArgumentInfo> entry : argumentInfos.int2ObjectEntrySet()) {
+        ArgumentInfo argumentInfo = entry.getValue();
+        ArgumentInfo rewrittenArgumentInfo = argumentInfo.rewrittenWithLens(appView, graphLens);
+        if (rewrittenArgumentInfo != argumentInfo) {
+          rewrittenArgumentInfos.put(entry.getIntKey(), rewrittenArgumentInfo);
+        }
+      }
+      if (!rewrittenArgumentInfos.isEmpty()) {
+        for (Int2ObjectMap.Entry<ArgumentInfo> entry : argumentInfos.int2ObjectEntrySet()) {
+          int key = entry.getIntKey();
+          if (!rewrittenArgumentInfos.containsKey(key)) {
+            rewrittenArgumentInfos.put(key, entry.getValue());
+          }
+        }
+        return new ArgumentInfoCollection(rewrittenArgumentInfos);
+      }
+      return this;
+    }
+
     @Override
     public boolean equals(Object obj) {
       if (obj == null || getClass() != obj.getClass()) {
@@ -694,6 +751,20 @@
     return dexItemFactory.createProto(newReturnType, newParameters);
   }
 
+  public RewrittenPrototypeDescription rewrittenWithLens(
+      AppView<AppInfoWithLiveness> appView, GraphLens graphLens) {
+    ArgumentInfoCollection newArgumentInfoCollection =
+        argumentInfoCollection.rewrittenWithLens(appView, graphLens);
+    RewrittenTypeInfo newRewrittenReturnInfo =
+        hasRewrittenReturnInfo() ? rewrittenReturnInfo.rewrittenWithLens(appView, graphLens) : null;
+    if (newArgumentInfoCollection != argumentInfoCollection
+        || newRewrittenReturnInfo != rewrittenReturnInfo) {
+      return new RewrittenPrototypeDescription(
+          extraParameters, newRewrittenReturnInfo, newArgumentInfoCollection);
+    }
+    return this;
+  }
+
   public RewrittenPrototypeDescription withRewrittenReturnInfo(
       RewrittenTypeInfo newRewrittenReturnInfo) {
     if (Objects.equals(rewrittenReturnInfo, newRewrittenReturnInfo)) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
index 150f206..e5a1aec 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
@@ -85,8 +85,7 @@
               resolutionResult.asSuccessfulResolution().getResolutionPair().asProgramField();
           if (field != null) {
             if (fieldAssignmentTracker != null) {
-              fieldAssignmentTracker.recordFieldAccess(
-                  fieldInstruction, field.getDefinition(), code.context());
+              fieldAssignmentTracker.recordFieldAccess(fieldInstruction, field, code.context());
             }
             if (fieldBitAccessAnalysis != null) {
               fieldBitAccessAnalysis.recordFieldAccess(
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
index 70c8519..714535c 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
@@ -4,19 +4,31 @@
 
 package com.android.tools.r8.ir.analysis.fieldaccess;
 
-import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.FieldAccessInfo;
 import com.android.tools.r8.graph.FieldAccessInfoCollection;
 import com.android.tools.r8.graph.ObjectAllocationInfoCollection;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerUtils;
+import com.android.tools.r8.ir.analysis.fieldaccess.state.ConcreteArrayTypeFieldState;
+import com.android.tools.r8.ir.analysis.fieldaccess.state.ConcreteClassTypeFieldState;
+import com.android.tools.r8.ir.analysis.fieldaccess.state.ConcretePrimitiveTypeFieldState;
+import com.android.tools.r8.ir.analysis.fieldaccess.state.FieldState;
+import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
+import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
 import com.android.tools.r8.ir.analysis.value.BottomValue;
 import com.android.tools.r8.ir.analysis.value.NonConstantNumberValue;
 import com.android.tools.r8.ir.analysis.value.SingleValue;
@@ -30,9 +42,10 @@
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldArgumentInitializationInfo;
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfo;
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoCollection;
+import com.android.tools.r8.optimize.argumentpropagation.utils.WideningUtils;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepFieldInfo;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
 import java.util.ArrayList;
@@ -40,13 +53,14 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 
 public class FieldAssignmentTracker {
 
+  private final AbstractValueFactory abstractValueFactory;
   private final AppView<AppInfoWithLiveness> appView;
+  private final DexItemFactory dexItemFactory;
 
   // A field access graph with edges from methods to the fields that they access. Edges are removed
   // from the graph as we process methods, such that we can conclude that all field writes have been
@@ -58,14 +72,17 @@
   // sites have been seen when a class no longer has any incoming edges.
   private final ObjectAllocationGraph objectAllocationGraph;
 
-  // The set of fields that may store a non-zero value.
-  private final Set<DexEncodedField> nonZeroFields = Sets.newConcurrentHashSet();
+  // Information about the fields in the program. If a field is not a key in the map then no writes
+  // has been seen to the field.
+  private final Map<DexEncodedField, FieldState> fieldStates = new ConcurrentHashMap<>();
 
   private final Map<DexProgramClass, Map<DexEncodedField, AbstractValue>>
       abstractInstanceFieldValues = new ConcurrentHashMap<>();
 
   FieldAssignmentTracker(AppView<AppInfoWithLiveness> appView) {
+    this.abstractValueFactory = appView.abstractValueFactory();
     this.appView = appView;
+    this.dexItemFactory = appView.dexItemFactory();
     this.fieldAccessGraph = new FieldAccessGraph();
     this.objectAllocationGraph = new ObjectAllocationGraph();
   }
@@ -109,33 +126,114 @@
           }
           abstractInstanceFieldValues.put(clazz, abstractInstanceFieldValuesForClass);
         });
-  }
-
-  private boolean isAlwaysZero(DexEncodedField field) {
-    return !appView.appInfo().isPinned(field.getReference()) && !nonZeroFields.contains(field);
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      clazz.forEachProgramField(
+          field -> {
+            FieldAccessInfo accessInfo = fieldAccessInfos.get(field.getReference());
+            KeepFieldInfo keepInfo = appView.getKeepInfo(field);
+            if (keepInfo.isPinned(appView.options()) || accessInfo.isWrittenFromMethodHandle()) {
+              fieldStates.put(field.getDefinition(), FieldState.unknown());
+            }
+          });
+    }
   }
 
   void acceptClassInitializerDefaultsResult(
       ClassInitializerDefaultsResult classInitializerDefaultsResult) {
     classInitializerDefaultsResult.forEachOptimizedField(
         (field, value) -> {
-          if (!value.isDefault(field.getReference().type)) {
-            nonZeroFields.add(field);
+          DexType fieldType = field.getType();
+          if (value.isDefault(field.getType())) {
+            return;
           }
+          assert fieldType.isClassType() || fieldType.isPrimitiveType();
+          fieldStates.compute(
+              field,
+              (f, fieldState) -> {
+                if (fieldState == null) {
+                  AbstractValue abstractValue = value.toAbstractValue(abstractValueFactory);
+                  if (fieldType.isClassType()) {
+                    assert abstractValue.isSingleStringValue()
+                        || abstractValue.isSingleDexItemBasedStringValue();
+                    if (fieldType == dexItemFactory.stringType) {
+                      return ConcreteClassTypeFieldState.create(
+                          abstractValue, DynamicType.definitelyNotNull());
+                    } else {
+                      ClassTypeElement nonNullableStringType =
+                          dexItemFactory
+                              .stringType
+                              .toTypeElement(appView, definitelyNotNull())
+                              .asClassType();
+                      return ConcreteClassTypeFieldState.create(
+                          abstractValue, DynamicType.createExact(nonNullableStringType));
+                    }
+                  } else {
+                    assert fieldType.isPrimitiveType();
+                    return ConcretePrimitiveTypeFieldState.create(abstractValue);
+                  }
+                }
+                // If the field is already assigned outside the class initializer then just give up.
+                return FieldState.unknown();
+              });
         });
   }
 
-  void recordFieldAccess(
-      FieldInstruction instruction, DexEncodedField field, ProgramMethod context) {
+  void recordFieldAccess(FieldInstruction instruction, ProgramField field, ProgramMethod context) {
     if (instruction.isFieldPut()) {
       recordFieldPut(field, instruction.value(), context);
     }
   }
 
-  private void recordFieldPut(DexEncodedField field, Value value, ProgramMethod context) {
-    if (!value.isZero()) {
-      nonZeroFields.add(field);
-    }
+  private void recordFieldPut(ProgramField field, Value value, ProgramMethod context) {
+    // For now only attempt to prove that fields are definitely null. In order to prove a single
+    // value for fields that are not definitely null, we need to prove that the given field is never
+    // read before it is written.
+    AbstractValue abstractValue =
+        value.isZero() ? abstractValueFactory.createZeroValue() : AbstractValue.unknown();
+    fieldStates.compute(
+        field.getDefinition(),
+        (f, fieldState) -> {
+          if (fieldState == null || fieldState.isBottom()) {
+            DexType fieldType = field.getType();
+            if (fieldType.isArrayType()) {
+              return ConcreteArrayTypeFieldState.create(abstractValue);
+            }
+            if (fieldType.isPrimitiveType()) {
+              return ConcretePrimitiveTypeFieldState.create(abstractValue);
+            }
+            assert fieldType.isClassType();
+            DynamicType dynamicType =
+                fieldType.isArrayType()
+                    ? DynamicType.unknown()
+                    : WideningUtils.widenDynamicNonReceiverType(
+                        appView,
+                        value.getDynamicType(appView).withNullability(Nullability.maybeNull()),
+                        field.getType());
+            return ConcreteClassTypeFieldState.create(abstractValue, dynamicType);
+          }
+
+          if (fieldState.isUnknown()) {
+            return fieldState;
+          }
+
+          assert fieldState.isConcrete();
+
+          if (fieldState.isArray()) {
+            ConcreteArrayTypeFieldState arrayFieldState = fieldState.asArray();
+            return arrayFieldState.mutableJoin(appView, abstractValue);
+          }
+
+          if (fieldState.isPrimitive()) {
+            ConcretePrimitiveTypeFieldState primitiveFieldState = fieldState.asPrimitive();
+            return primitiveFieldState.mutableJoin(abstractValue, abstractValueFactory);
+          }
+
+          assert fieldState.isClass();
+
+          ConcreteClassTypeFieldState classFieldState = fieldState.asClass();
+          return classFieldState.mutableJoin(
+              appView, abstractValue, value.getDynamicType(appView), field);
+        });
   }
 
   void recordAllocationSite(NewInstance instruction, DexProgramClass clazz, ProgramMethod context) {
@@ -146,7 +244,7 @@
       return;
     }
 
-    InvokeDirect invoke = instruction.getUniqueConstructorInvoke(appView.dexItemFactory());
+    InvokeDirect invoke = instruction.getUniqueConstructorInvoke(dexItemFactory);
     if (invoke == null) {
       // We just lost track.
       abstractInstanceFieldValues.remove(clazz);
@@ -238,27 +336,40 @@
   }
 
   private void recordAllFieldPutsProcessed(
-      DexEncodedField field, ProgramMethod context, OptimizationFeedbackDelayed feedback) {
-    DexProgramClass clazz = asProgramClassOrNull(appView.definitionForHolder(field, context));
-    if (clazz == null) {
-      assert false;
-      return;
+      ProgramField field, ProgramMethod context, OptimizationFeedbackDelayed feedback) {
+    FieldState fieldState = fieldStates.getOrDefault(field.getDefinition(), FieldState.bottom());
+    AbstractValue abstractValue = fieldState.getAbstractValue(appView.abstractValueFactory());
+    if (abstractValue.isNonTrivial()) {
+      feedback.recordFieldHasAbstractValue(field.getDefinition(), appView, abstractValue);
     }
 
-    if (isAlwaysZero(field)) {
-      feedback.recordFieldHasAbstractValue(
-          field, appView, appView.abstractValueFactory().createSingleNumberValue(0));
+    if (fieldState.isClass() && field.getOptimizationInfo().getDynamicType().isUnknown()) {
+      ConcreteClassTypeFieldState classFieldState = fieldState.asClass();
+      DynamicType dynamicType = classFieldState.getDynamicType();
+      if (!dynamicType.isUnknown()) {
+        assert WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, field.getType())
+            == dynamicType;
+        if (dynamicType.isNotNullType()) {
+          feedback.markFieldHasDynamicType(field.getDefinition(), dynamicType);
+        } else {
+          DynamicTypeWithUpperBound staticType = field.getType().toDynamicType(appView);
+          if (dynamicType.asDynamicTypeWithUpperBound().strictlyLessThan(staticType, appView)) {
+            feedback.markFieldHasDynamicType(field.getDefinition(), dynamicType);
+          }
+        }
+      }
     }
 
-    if (!field.isStatic()) {
-      recordAllInstanceFieldPutsProcessed(clazz, field, feedback);
+    if (!field.getAccessFlags().isStatic()) {
+      recordAllInstanceFieldPutsProcessed(field, feedback);
     }
   }
 
   private void recordAllInstanceFieldPutsProcessed(
-      DexProgramClass clazz, DexEncodedField field, OptimizationFeedbackDelayed feedback) {
+      ProgramField field, OptimizationFeedbackDelayed feedback) {
     if (appView.appInfo().isInstanceFieldWrittenOnlyInInstanceInitializers(field)) {
       AbstractValue abstractValue = BottomValue.getInstance();
+      DexProgramClass clazz = field.getHolder();
       for (DexEncodedMethod method : clazz.directMethods(DexEncodedMethod::isInstanceInitializer)) {
         InstanceFieldInitializationInfo fieldInitializationInfo =
             method
@@ -290,7 +401,7 @@
       assert !abstractValue.isBottom();
 
       if (!abstractValue.isUnknown()) {
-        feedback.recordFieldHasAbstractValue(field, appView, abstractValue);
+        feedback.recordFieldHasAbstractValue(field.getDefinition(), appView, abstractValue);
       }
     }
   }
@@ -334,8 +445,7 @@
   static class FieldAccessGraph {
 
     // The fields written by each method.
-    private final Map<DexEncodedMethod, List<DexEncodedField>> fieldWrites =
-        new IdentityHashMap<>();
+    private final Map<DexEncodedMethod, List<ProgramField>> fieldWrites = new IdentityHashMap<>();
 
     // The number of writes that have not yet been processed per field.
     private final Reference2IntMap<DexEncodedField> pendingFieldWrites =
@@ -348,8 +458,7 @@
           appView.appInfo().getFieldAccessInfoCollection();
       fieldAccessInfoCollection.forEach(
           info -> {
-            DexEncodedField field =
-                appView.appInfo().resolveField(info.getField()).getResolvedField();
+            ProgramField field = appView.appInfo().resolveField(info.getField()).getProgramField();
             if (field == null) {
               return;
             }
@@ -359,18 +468,18 @@
                       fieldWrites
                           .computeIfAbsent(context.getDefinition(), ignore -> new ArrayList<>())
                           .add(field));
-              pendingFieldWrites.put(field, info.getNumberOfWriteContexts());
+              pendingFieldWrites.put(field.getDefinition(), info.getNumberOfWriteContexts());
             }
           });
     }
 
-    void markProcessed(ProgramMethod method, Consumer<DexEncodedField> allWritesSeenConsumer) {
-      List<DexEncodedField> fieldWritesInMethod = fieldWrites.get(method.getDefinition());
+    void markProcessed(ProgramMethod method, Consumer<ProgramField> allWritesSeenConsumer) {
+      List<ProgramField> fieldWritesInMethod = fieldWrites.get(method.getDefinition());
       if (fieldWritesInMethod != null) {
-        for (DexEncodedField field : fieldWritesInMethod) {
-          int numberOfPendingFieldWrites = pendingFieldWrites.removeInt(field) - 1;
+        for (ProgramField field : fieldWritesInMethod) {
+          int numberOfPendingFieldWrites = pendingFieldWrites.removeInt(field.getDefinition()) - 1;
           if (numberOfPendingFieldWrites > 0) {
-            pendingFieldWrites.put(field, numberOfPendingFieldWrites);
+            pendingFieldWrites.put(field.getDefinition(), numberOfPendingFieldWrites);
           } else {
             allWritesSeenConsumer.accept(field);
           }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/BottomFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/BottomFieldState.java
new file mode 100644
index 0000000..c3474af
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/BottomFieldState.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+
+/** Used to represent the state for fields that have never been assigned in the program. */
+public class BottomFieldState extends FieldState {
+
+  private static final BottomFieldState INSTANCE = new BottomFieldState();
+
+  private BottomFieldState() {}
+
+  public static BottomFieldState getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public AbstractValue getAbstractValue(AbstractValueFactory abstractValueFactory) {
+    return abstractValueFactory.createNullValue();
+  }
+
+  @Override
+  public boolean isBottom() {
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java
new file mode 100644
index 0000000..1b82558
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+/**
+ * The information that we track for fields with an array type.
+ *
+ * <p>Since we don't gain much from tracking the dynamic types of arrays, this is only tracking the
+ * abstract value.
+ */
+public class ConcreteArrayTypeFieldState extends ConcreteReferenceTypeFieldState {
+
+  ConcreteArrayTypeFieldState(AbstractValue abstractValue) {
+    super(abstractValue);
+  }
+
+  public static FieldState create(AbstractValue abstractValue) {
+    return abstractValue.isUnknown()
+        ? FieldState.unknown()
+        : new ConcreteArrayTypeFieldState(abstractValue);
+  }
+
+  @Override
+  public boolean isArray() {
+    return true;
+  }
+
+  @Override
+  public ConcreteArrayTypeFieldState asArray() {
+    return this;
+  }
+
+  public FieldState mutableJoin(AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue) {
+    this.abstractValue =
+        this.abstractValue.joinReference(abstractValue, appView.abstractValueFactory());
+    return isEffectivelyUnknown() ? unknown() : this;
+  }
+
+  private boolean isEffectivelyUnknown() {
+    return abstractValue.isUnknown();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java
new file mode 100644
index 0000000..7cd6f2e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java
@@ -0,0 +1,62 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.optimize.argumentpropagation.utils.WideningUtils;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+/** The information that we track for fields whose type is a class type. */
+public class ConcreteClassTypeFieldState extends ConcreteReferenceTypeFieldState {
+
+  private DynamicType dynamicType;
+
+  ConcreteClassTypeFieldState(AbstractValue abstractValue, DynamicType dynamicType) {
+    super(abstractValue);
+    this.dynamicType = dynamicType;
+  }
+
+  public static FieldState create(AbstractValue abstractValue, DynamicType dynamicType) {
+    return abstractValue.isUnknown() && dynamicType.isUnknown()
+        ? FieldState.unknown()
+        : new ConcreteClassTypeFieldState(abstractValue, dynamicType);
+  }
+
+  public DynamicType getDynamicType() {
+    return dynamicType;
+  }
+
+  @Override
+  public boolean isClass() {
+    return true;
+  }
+
+  @Override
+  public ConcreteClassTypeFieldState asClass() {
+    return this;
+  }
+
+  public FieldState mutableJoin(
+      AppView<AppInfoWithLiveness> appView,
+      AbstractValue abstractValue,
+      DynamicType dynamicType,
+      ProgramField field) {
+    this.abstractValue =
+        this.abstractValue.joinReference(abstractValue, appView.abstractValueFactory());
+    this.dynamicType =
+        field.getType().isArrayType()
+            ? DynamicType.unknown()
+            : WideningUtils.widenDynamicNonReceiverType(
+                appView, this.dynamicType.join(appView, dynamicType), field.getType());
+    return isEffectivelyUnknown() ? unknown() : this;
+  }
+
+  private boolean isEffectivelyUnknown() {
+    return abstractValue.isUnknown() && dynamicType.isUnknown();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteFieldState.java
new file mode 100644
index 0000000..25ddbb9
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteFieldState.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+/** A shared base class for non-trivial field information (neither bottom nor top). */
+public abstract class ConcreteFieldState extends FieldState {
+
+  @Override
+  public boolean isConcrete() {
+    return true;
+  }
+
+  @Override
+  public ConcreteFieldState asConcrete() {
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java
new file mode 100644
index 0000000..c2eb778
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java
@@ -0,0 +1,52 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+
+/** The information that we track for fields whose type is a primitive type. */
+public class ConcretePrimitiveTypeFieldState extends ConcreteFieldState {
+
+  private AbstractValue abstractValue;
+
+  ConcretePrimitiveTypeFieldState(AbstractValue abstractValue) {
+    this.abstractValue = abstractValue;
+  }
+
+  public static FieldState create(AbstractValue abstractValue) {
+    return abstractValue.isUnknown()
+        ? FieldState.unknown()
+        : new ConcretePrimitiveTypeFieldState(abstractValue);
+  }
+
+  @Override
+  public AbstractValue getAbstractValue(AbstractValueFactory abstractValueFactory) {
+    return abstractValue;
+  }
+
+  @Override
+  public boolean isPrimitive() {
+    return true;
+  }
+
+  @Override
+  public ConcretePrimitiveTypeFieldState asPrimitive() {
+    return this;
+  }
+
+  public FieldState mutableJoin(
+      AbstractValue abstractValue, AbstractValueFactory abstractValueFactory) {
+    if (abstractValue.isUnknown()) {
+      return FieldState.unknown();
+    }
+    this.abstractValue = this.abstractValue.joinPrimitive(abstractValue, abstractValueFactory);
+    return isEffectivelyUnknown() ? unknown() : this;
+  }
+
+  private boolean isEffectivelyUnknown() {
+    return abstractValue.isUnknown();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteReferenceTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteReferenceTypeFieldState.java
new file mode 100644
index 0000000..64d0674
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteReferenceTypeFieldState.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+
+/** The information that we track for fields whose type is a reference type. */
+public abstract class ConcreteReferenceTypeFieldState extends ConcreteFieldState {
+
+  protected AbstractValue abstractValue;
+
+  ConcreteReferenceTypeFieldState(AbstractValue abstractValue) {
+    this.abstractValue = abstractValue;
+  }
+
+  @Override
+  public AbstractValue getAbstractValue(AbstractValueFactory abstractValueFactory) {
+    return abstractValue;
+  }
+
+  @Override
+  public boolean isReference() {
+    return true;
+  }
+
+  @Override
+  public ConcreteReferenceTypeFieldState asReference() {
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/FieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/FieldState.java
new file mode 100644
index 0000000..6e0b203
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/FieldState.java
@@ -0,0 +1,70 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+
+/** An abstraction of the runtime values that may flow into each field. */
+public abstract class FieldState {
+
+  public static BottomFieldState bottom() {
+    return BottomFieldState.getInstance();
+  }
+
+  public static UnknownFieldState unknown() {
+    return UnknownFieldState.getInstance();
+  }
+
+  public abstract AbstractValue getAbstractValue(AbstractValueFactory abstractValueFactory);
+
+  public boolean isArray() {
+    return false;
+  }
+
+  public ConcreteArrayTypeFieldState asArray() {
+    return null;
+  }
+
+  public boolean isBottom() {
+    return false;
+  }
+
+  public boolean isClass() {
+    return false;
+  }
+
+  public ConcreteClassTypeFieldState asClass() {
+    return null;
+  }
+
+  public boolean isConcrete() {
+    return false;
+  }
+
+  public ConcreteFieldState asConcrete() {
+    return null;
+  }
+
+  public boolean isPrimitive() {
+    return false;
+  }
+
+  public ConcretePrimitiveTypeFieldState asPrimitive() {
+    return null;
+  }
+
+  public boolean isReference() {
+    return false;
+  }
+
+  public ConcreteReferenceTypeFieldState asReference() {
+    return null;
+  }
+
+  public boolean isUnknown() {
+    return false;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/UnknownFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/UnknownFieldState.java
new file mode 100644
index 0000000..e408f09
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/UnknownFieldState.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.state;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+
+/** Represents that nothing is known about the values that may flow into a given field. */
+public class UnknownFieldState extends FieldState {
+
+  private static final UnknownFieldState INSTANCE = new UnknownFieldState();
+
+  private UnknownFieldState() {}
+
+  public static UnknownFieldState getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public AbstractValue getAbstractValue(AbstractValueFactory abstractValueFactory) {
+    return AbstractValue.unknown();
+  }
+
+  @Override
+  public boolean isUnknown() {
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index 0303ba7..30c3b67 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -14,9 +14,8 @@
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.DexValue.DexValueNull;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
 import com.android.tools.r8.ir.analysis.value.NullOrAbstractValue;
@@ -147,26 +146,17 @@
     // Abstract value.
     feedback.recordFieldHasAbstractValue(field, appView, abstractValue);
 
-    // Dynamic upper bound type.
-    TypeElement fieldType =
-        TypeElement.fromDexType(field.getReference().type, Nullability.maybeNull(), appView);
-    TypeElement dynamicUpperBoundType = value.getDynamicUpperBoundType(appView);
-    if (dynamicUpperBoundType.strictlyLessThan(fieldType, appView)) {
-      if (maybeNull && dynamicUpperBoundType.isDefinitelyNotNull()) {
-        assert dynamicUpperBoundType.isReferenceType();
-        dynamicUpperBoundType = dynamicUpperBoundType.asReferenceType().asMaybeNull();
+    // Dynamic type.
+    if (field.getType().isReferenceType()) {
+      DynamicTypeWithUpperBound staticType = field.getType().toDynamicType(appView);
+      DynamicTypeWithUpperBound dynamicType = value.getDynamicType(appView);
+      if (dynamicType.strictlyLessThan(staticType, appView)) {
+        if (maybeNull && dynamicType.getNullability().isDefinitelyNotNull()) {
+          assert dynamicType.getDynamicUpperBoundType().isReferenceType();
+          dynamicType = dynamicType.withNullability(Nullability.maybeNull());
+        }
+        feedback.markFieldHasDynamicType(field, dynamicType);
       }
-      feedback.markFieldHasDynamicUpperBoundType(field, dynamicUpperBoundType);
-    }
-
-    // Dynamic lower bound type.
-    ClassTypeElement dynamicLowerBoundType = value.getDynamicLowerBoundType(appView);
-    if (dynamicLowerBoundType != null) {
-      assert dynamicLowerBoundType.lessThanOrEqual(dynamicUpperBoundType, appView);
-      if (maybeNull && dynamicLowerBoundType.isDefinitelyNotNull()) {
-        dynamicLowerBoundType = dynamicLowerBoundType.asMaybeNull().asClassType();
-      }
-      feedback.markFieldHasDynamicLowerBoundType(field, dynamicLowerBoundType);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicType.java b/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicType.java
index 1a32390..1b9bb1e 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicType.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicType.java
@@ -6,9 +6,11 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import java.util.Objects;
+import java.util.Set;
 
 /**
  * Represents the runtime type of a reference value. This type may be more precise than the value's
@@ -17,20 +19,9 @@
  * <p>If a lower bound is known on the runtime type (e.g., {@code new A()}), then {@link
  * DynamicTypeWithLowerBound} is used.
  */
-public class DynamicType {
+public abstract class DynamicType {
 
-  private static final DynamicType BOTTOM = new DynamicType(TypeElement.getBottom());
-  private static final DynamicType NULL_TYPE = new DynamicType(TypeElement.getNull());
-  private static final DynamicType UNKNOWN = new DynamicType(TypeElement.getTop());
-
-  private final TypeElement dynamicUpperBoundType;
-
-  DynamicType(TypeElement dynamicUpperBoundType) {
-    assert dynamicUpperBoundType != null;
-    this.dynamicUpperBoundType = dynamicUpperBoundType;
-  }
-
-  public static DynamicType create(
+  public static DynamicTypeWithUpperBound create(
       AppView<AppInfoWithLiveness> appView, TypeElement dynamicUpperBoundType) {
     ClassTypeElement dynamicLowerBoundType = null;
     if (dynamicUpperBoundType.isClassType()) {
@@ -44,7 +35,7 @@
     return create(appView, dynamicUpperBoundType, dynamicLowerBoundType);
   }
 
-  public static DynamicType create(
+  public static DynamicTypeWithUpperBound create(
       AppView<AppInfoWithLiveness> appView,
       TypeElement dynamicUpperBoundType,
       ClassTypeElement dynamicLowerBoundType) {
@@ -67,14 +58,15 @@
           appView, dynamicUpperBoundType.asClassType(), dynamicLowerBoundType);
     }
     assert verifyNotEffectivelyFinalClassType(appView, dynamicUpperBoundType);
-    return new DynamicType(dynamicUpperBoundType);
+    return new DynamicTypeWithUpperBound(dynamicUpperBoundType);
   }
 
-  public static DynamicType createExact(ClassTypeElement exactDynamicType) {
+  public static ExactDynamicType createExact(ClassTypeElement exactDynamicType) {
     return new ExactDynamicType(exactDynamicType);
   }
 
-  public static DynamicType create(AppView<AppInfoWithLiveness> appView, Value value) {
+  public static DynamicTypeWithUpperBound create(
+      AppView<AppInfoWithLiveness> appView, Value value) {
     assert value.getType().isReferenceType();
     TypeElement dynamicUpperBoundType = value.getDynamicUpperBoundType(appView);
     ClassTypeElement dynamicLowerBoundType =
@@ -83,22 +75,46 @@
     return create(appView, dynamicUpperBoundType, dynamicLowerBoundType);
   }
 
-  public static DynamicType bottom() {
-    return BOTTOM;
+  public static DynamicTypeWithUpperBound bottom() {
+    return DynamicTypeWithUpperBound.BOTTOM;
   }
 
-  public static DynamicType definitelyNull() {
-    return NULL_TYPE;
+  public static DynamicTypeWithUpperBound definitelyNull() {
+    return DynamicTypeWithUpperBound.NULL_TYPE;
   }
 
-  public static DynamicType unknown() {
-    return UNKNOWN;
+  public static NotNullDynamicType definitelyNotNull() {
+    return NotNullDynamicType.get();
   }
 
-  public TypeElement getDynamicUpperBoundType() {
-    return dynamicUpperBoundType;
+  public static DynamicTypeWithUpperBound unknown() {
+    return DynamicTypeWithUpperBound.UNKNOWN;
   }
 
+  public static DynamicType join(
+      AppView<AppInfoWithLiveness> appView, Iterable<DynamicType> dynamicTypes) {
+    DynamicType result = bottom();
+    for (DynamicType dynamicType : dynamicTypes) {
+      result = result.join(appView, dynamicType);
+    }
+    return result;
+  }
+
+  public boolean hasDynamicUpperBoundType() {
+    return false;
+  }
+
+  /**
+   * Returns the dynamic upper bound type if this is an instance of {@link
+   * DynamicTypeWithUpperBound}.
+   *
+   * <p>The {@link NotNullDynamicType} does not have an upper bound type. This therefore takes the
+   * static type corresponding to the dynamic type as an argument, and returns the given static type
+   * with non null information attached to it when this dynamic type is the {@link
+   * NotNullDynamicType}.
+   */
+  public abstract TypeElement getDynamicUpperBoundType(TypeElement staticType);
+
   public boolean hasDynamicLowerBoundType() {
     return false;
   }
@@ -107,20 +123,36 @@
     return null;
   }
 
-  public Nullability getNullability() {
-    return getDynamicUpperBoundType().nullability();
-  }
+  public abstract ClassTypeElement getExactClassType();
+
+  public abstract Nullability getNullability();
 
   public boolean isBottom() {
-    return getDynamicUpperBoundType().isBottom();
+    return false;
+  }
+
+  public boolean isDynamicTypeWithUpperBound() {
+    return false;
+  }
+
+  public DynamicTypeWithUpperBound asDynamicTypeWithUpperBound() {
+    return null;
+  }
+
+  public boolean isExactClassType() {
+    return getExactClassType() != null;
   }
 
   public boolean isNullType() {
-    return getDynamicUpperBoundType().isNullType();
+    return false;
+  }
+
+  public boolean isNotNullType() {
+    return false;
   }
 
   public boolean isUnknown() {
-    return getDynamicUpperBoundType().isTop();
+    return false;
   }
 
   public DynamicType join(AppView<AppInfoWithLiveness> appView, DynamicType dynamicType) {
@@ -133,57 +165,27 @@
     if (isUnknown() || dynamicType.isUnknown()) {
       return unknown();
     }
-    TypeElement upperBoundType =
-        getDynamicUpperBoundType().join(dynamicType.getDynamicUpperBoundType(), appView);
-    ClassTypeElement lowerBoundType = meetDynamicLowerBound(appView, dynamicType);
-    if (upperBoundType.equals(getDynamicUpperBoundType())
-        && Objects.equals(lowerBoundType, getDynamicLowerBoundType())) {
-      return this;
+    if (isNotNullType() || dynamicType.isNotNullType()) {
+      if (getNullability().isNullable() || dynamicType.getNullability().isNullable()) {
+        return unknown();
+      }
+      return definitelyNotNull();
     }
-    return create(appView, upperBoundType, lowerBoundType);
+    assert isDynamicTypeWithUpperBound();
+    assert dynamicType.isDynamicTypeWithUpperBound();
+    return asDynamicTypeWithUpperBound().join(appView, dynamicType.asDynamicTypeWithUpperBound());
   }
 
-  private ClassTypeElement meetDynamicLowerBound(
-      AppView<AppInfoWithLiveness> appView, DynamicType dynamicType) {
-    if (isNullType()) {
-      if (dynamicType.hasDynamicLowerBoundType()) {
-        return dynamicType.getDynamicLowerBoundType().joinNullability(Nullability.definitelyNull());
-      }
-      return null;
-    }
-    if (dynamicType.isNullType()) {
-      if (hasDynamicLowerBoundType()) {
-        return getDynamicLowerBoundType().joinNullability(Nullability.definitelyNull());
-      }
-      return null;
-    }
-    if (!hasDynamicLowerBoundType() || !dynamicType.hasDynamicLowerBoundType()) {
-      return null;
-    }
-    ClassTypeElement lowerBoundType = getDynamicLowerBoundType();
-    ClassTypeElement otherLowerBoundType = dynamicType.getDynamicLowerBoundType();
-    if (lowerBoundType.lessThanOrEqualUpToNullability(otherLowerBoundType, appView)) {
-      return lowerBoundType.joinNullability(otherLowerBoundType.nullability());
-    }
-    if (otherLowerBoundType.lessThanOrEqualUpToNullability(lowerBoundType, appView)) {
-      return otherLowerBoundType.joinNullability(lowerBoundType.nullability());
-    }
-    return null;
-  }
+  public abstract DynamicType rewrittenWithLens(
+      AppView<AppInfoWithLiveness> appView, GraphLens graphLens, Set<DexType> prunedTypes);
+
+  public abstract DynamicType withNullability(Nullability nullability);
 
   @Override
-  public boolean equals(Object other) {
-    if (other == null || getClass() != other.getClass()) {
-      return false;
-    }
-    DynamicType dynamicType = (DynamicType) other;
-    return dynamicUpperBoundType.equals(dynamicType.dynamicUpperBoundType);
-  }
+  public abstract boolean equals(Object other);
 
   @Override
-  public int hashCode() {
-    return dynamicUpperBoundType.hashCode();
-  }
+  public abstract int hashCode();
 
   private static boolean verifyNotEffectivelyFinalClassType(
       AppView<AppInfoWithLiveness> appView, TypeElement type) {
@@ -194,17 +196,4 @@
     }
     return true;
   }
-
-  public DynamicType withNullability(Nullability nullability) {
-    assert !hasDynamicLowerBoundType();
-    if (!getDynamicUpperBoundType().isReferenceType()) {
-      return this;
-    }
-    ReferenceTypeElement dynamicUpperBoundReferenceType =
-        getDynamicUpperBoundType().asReferenceType();
-    if (dynamicUpperBoundReferenceType.nullability() == nullability) {
-      return this;
-    }
-    return new DynamicType(dynamicUpperBoundReferenceType.getOrCreateVariant(nullability));
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithLowerBound.java b/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithLowerBound.java
index e4190bc..9448ebb 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithLowerBound.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithLowerBound.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.Objects;
 
-public class DynamicTypeWithLowerBound extends DynamicType {
+public class DynamicTypeWithLowerBound extends DynamicTypeWithUpperBound {
 
   private final ClassTypeElement dynamicLowerBoundType;
 
@@ -16,6 +16,7 @@
       ClassTypeElement dynamicUpperBoundType, ClassTypeElement dynamicLowerBoundType) {
     super(dynamicUpperBoundType);
     assert !dynamicUpperBoundType.equals(dynamicLowerBoundType);
+    assert dynamicUpperBoundType.nullability() == dynamicLowerBoundType.nullability();
     this.dynamicLowerBoundType = dynamicLowerBoundType;
   }
 
@@ -64,7 +65,7 @@
   }
 
   @Override
-  public DynamicType withNullability(Nullability nullability) {
+  public DynamicTypeWithLowerBound withNullability(Nullability nullability) {
     if (getDynamicUpperBoundType().nullability() == nullability) {
       return this;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithUpperBound.java b/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithUpperBound.java
new file mode 100644
index 0000000..fa985fa
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/DynamicTypeWithUpperBound.java
@@ -0,0 +1,283 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.type;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Represents the runtime type of a reference value. This type may be more precise than the value's
+ * statically declared type.
+ *
+ * <p>If a lower bound is known on the runtime type (e.g., {@code new A()}), then {@link
+ * DynamicTypeWithLowerBound} is used.
+ */
+public class DynamicTypeWithUpperBound extends DynamicType {
+
+  static final DynamicTypeWithUpperBound BOTTOM =
+      new DynamicTypeWithUpperBound(TypeElement.getBottom());
+  static final DynamicTypeWithUpperBound NULL_TYPE =
+      new DynamicTypeWithUpperBound(TypeElement.getNull());
+  static final DynamicTypeWithUpperBound UNKNOWN =
+      new DynamicTypeWithUpperBound(TypeElement.getTop());
+
+  private final TypeElement dynamicUpperBoundType;
+
+  DynamicTypeWithUpperBound(TypeElement dynamicUpperBoundType) {
+    assert dynamicUpperBoundType != null;
+    this.dynamicUpperBoundType = dynamicUpperBoundType;
+  }
+
+  public static DynamicTypeWithUpperBound create(
+      AppView<AppInfoWithLiveness> appView, TypeElement dynamicUpperBoundType) {
+    ClassTypeElement dynamicLowerBoundType =
+        isEffectivelyFinal(appView, dynamicUpperBoundType)
+            ? dynamicUpperBoundType.asClassType()
+            : null;
+    return create(appView, dynamicUpperBoundType, dynamicLowerBoundType);
+  }
+
+  public static DynamicTypeWithUpperBound create(
+      AppView<AppInfoWithLiveness> appView,
+      TypeElement dynamicUpperBoundType,
+      ClassTypeElement dynamicLowerBoundType) {
+    if (dynamicUpperBoundType.isBottom()) {
+      return bottom();
+    }
+    if (dynamicUpperBoundType.isNullType()) {
+      return definitelyNull();
+    }
+    if (dynamicUpperBoundType.isTop()) {
+      return unknown();
+    }
+    if (dynamicLowerBoundType != null) {
+      assert dynamicUpperBoundType.isClassType();
+      assert dynamicUpperBoundType.nullability() == dynamicLowerBoundType.nullability();
+      if (dynamicUpperBoundType.equals(dynamicLowerBoundType)) {
+        return createExact(dynamicLowerBoundType);
+      }
+      return DynamicTypeWithLowerBound.create(
+          appView, dynamicUpperBoundType.asClassType(), dynamicLowerBoundType);
+    }
+    assert verifyNotEffectivelyFinalClassType(appView, dynamicUpperBoundType);
+    return new DynamicTypeWithUpperBound(dynamicUpperBoundType);
+  }
+
+  public static DynamicTypeWithUpperBound create(
+      AppView<AppInfoWithLiveness> appView, Value value) {
+    assert value.getType().isReferenceType();
+    TypeElement dynamicUpperBoundType = value.getDynamicUpperBoundType(appView);
+    ClassTypeElement dynamicLowerBoundType =
+        value.getDynamicLowerBoundType(
+            appView, dynamicUpperBoundType, dynamicUpperBoundType.nullability());
+    return create(appView, dynamicUpperBoundType, dynamicLowerBoundType);
+  }
+
+  private static boolean isEffectivelyFinal(AppView<?> appView, TypeElement type) {
+    if (type.isClassType()) {
+      ClassTypeElement classType = type.asClassType();
+      DexClass clazz = appView.definitionFor(classType.getClassType());
+      return clazz != null && clazz.isEffectivelyFinal(appView);
+    }
+    return false;
+  }
+
+  @Override
+  public boolean hasDynamicUpperBoundType() {
+    return true;
+  }
+
+  @Override
+  public TypeElement getDynamicUpperBoundType(TypeElement staticType) {
+    return getDynamicUpperBoundType();
+  }
+
+  public TypeElement getDynamicUpperBoundType() {
+    return dynamicUpperBoundType;
+  }
+
+  @Override
+  public boolean hasDynamicLowerBoundType() {
+    return false;
+  }
+
+  @Override
+  public ClassTypeElement getDynamicLowerBoundType() {
+    return null;
+  }
+
+  @Override
+  public boolean isExactClassType() {
+    return getExactClassType() != null;
+  }
+
+  @Override
+  public ClassTypeElement getExactClassType() {
+    return hasDynamicLowerBoundType()
+            && getDynamicLowerBoundType().equalUpToNullability(getDynamicUpperBoundType())
+        ? getDynamicLowerBoundType()
+        : null;
+  }
+
+  @Override
+  public Nullability getNullability() {
+    return dynamicUpperBoundType.nullability();
+  }
+
+  @Override
+  public boolean isBottom() {
+    return dynamicUpperBoundType.isBottom();
+  }
+
+  @Override
+  public boolean isDynamicTypeWithUpperBound() {
+    return true;
+  }
+
+  @Override
+  public DynamicTypeWithUpperBound asDynamicTypeWithUpperBound() {
+    return this;
+  }
+
+  @Override
+  public boolean isNullType() {
+    return dynamicUpperBoundType.isNullType();
+  }
+
+  @Override
+  public boolean isUnknown() {
+    return dynamicUpperBoundType.isTop();
+  }
+
+  public DynamicType join(
+      AppView<AppInfoWithLiveness> appView, DynamicTypeWithUpperBound dynamicType) {
+    TypeElement upperBoundType =
+        getDynamicUpperBoundType().join(dynamicType.getDynamicUpperBoundType(), appView);
+    ClassTypeElement lowerBoundType =
+        isEffectivelyFinal(appView, upperBoundType)
+            ? upperBoundType.asClassType()
+            : meetDynamicLowerBound(appView, dynamicType);
+    if (upperBoundType.equals(getDynamicUpperBoundType())
+        && Objects.equals(lowerBoundType, getDynamicLowerBoundType())) {
+      return this;
+    }
+    return create(appView, upperBoundType, lowerBoundType);
+  }
+
+  private ClassTypeElement meetDynamicLowerBound(
+      AppView<AppInfoWithLiveness> appView, DynamicType dynamicType) {
+    if (isNullType()) {
+      if (dynamicType.hasDynamicLowerBoundType()) {
+        return dynamicType.getDynamicLowerBoundType().joinNullability(Nullability.definitelyNull());
+      }
+      return null;
+    }
+    if (dynamicType.isNullType()) {
+      if (hasDynamicLowerBoundType()) {
+        return getDynamicLowerBoundType().joinNullability(Nullability.definitelyNull());
+      }
+      return null;
+    }
+    if (!hasDynamicLowerBoundType() || !dynamicType.hasDynamicLowerBoundType()) {
+      return null;
+    }
+    ClassTypeElement lowerBoundType = getDynamicLowerBoundType();
+    ClassTypeElement otherLowerBoundType = dynamicType.getDynamicLowerBoundType();
+    if (lowerBoundType.lessThanOrEqualUpToNullability(otherLowerBoundType, appView)) {
+      return lowerBoundType.joinNullability(otherLowerBoundType.nullability());
+    }
+    if (otherLowerBoundType.lessThanOrEqualUpToNullability(lowerBoundType, appView)) {
+      return otherLowerBoundType.joinNullability(lowerBoundType.nullability());
+    }
+    return null;
+  }
+
+  @Override
+  public DynamicType rewrittenWithLens(
+      AppView<AppInfoWithLiveness> appView, GraphLens graphLens, Set<DexType> prunedTypes) {
+    if (isBottom() || isNullType() || isUnknown()) {
+      return this;
+    }
+    TypeElement rewrittenDynamicUpperBoundType =
+        dynamicUpperBoundType.rewrittenWithLens(appView, graphLens, prunedTypes);
+    ClassTypeElement rewrittenDynamicLowerBoundClassType = null;
+    if (hasDynamicLowerBoundType()) {
+      TypeElement rewrittenDynamicLowerBoundType =
+          getDynamicLowerBoundType().rewrittenWithLens(appView, graphLens, prunedTypes);
+      if (rewrittenDynamicLowerBoundType.isClassType()) {
+        rewrittenDynamicLowerBoundClassType = rewrittenDynamicLowerBoundType.asClassType();
+      }
+    }
+    return rewrittenDynamicLowerBoundClassType != null
+        ? create(appView, rewrittenDynamicUpperBoundType, rewrittenDynamicLowerBoundClassType)
+        : create(appView, rewrittenDynamicUpperBoundType);
+  }
+
+  public boolean strictlyLessThan(TypeElement type, AppView<AppInfoWithLiveness> appView) {
+    DynamicTypeWithUpperBound dynamicType = create(appView, type);
+    return strictlyLessThan(dynamicType, appView);
+  }
+
+  public boolean strictlyLessThan(DynamicTypeWithUpperBound dynamicType, AppView<?> appView) {
+    if (equals(dynamicType)) {
+      return false;
+    }
+    if (getDynamicUpperBoundType().equals(dynamicType.getDynamicUpperBoundType())) {
+      if (!dynamicType.hasDynamicLowerBoundType()) {
+        return hasDynamicLowerBoundType();
+      }
+      return hasDynamicLowerBoundType()
+          && getDynamicLowerBoundType()
+              .strictlyLessThan(dynamicType.getDynamicLowerBoundType(), appView);
+    }
+    return getDynamicUpperBoundType()
+        .strictlyLessThan(dynamicType.getDynamicUpperBoundType(), appView);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other == null || getClass() != other.getClass()) {
+      return false;
+    }
+    DynamicTypeWithUpperBound dynamicType = (DynamicTypeWithUpperBound) other;
+    return dynamicUpperBoundType.equals(dynamicType.dynamicUpperBoundType);
+  }
+
+  @Override
+  public int hashCode() {
+    return dynamicUpperBoundType.hashCode();
+  }
+
+  private static boolean verifyNotEffectivelyFinalClassType(
+      AppView<AppInfoWithLiveness> appView, TypeElement type) {
+    if (type.isClassType()) {
+      ClassTypeElement classType = type.asClassType();
+      DexClass clazz = appView.definitionFor(classType.getClassType());
+      assert clazz == null || !clazz.isEffectivelyFinal(appView);
+    }
+    return true;
+  }
+
+  @Override
+  public DynamicTypeWithUpperBound withNullability(Nullability nullability) {
+    assert !hasDynamicLowerBoundType();
+    if (!getDynamicUpperBoundType().isReferenceType()) {
+      return this;
+    }
+    ReferenceTypeElement dynamicUpperBoundReferenceType =
+        getDynamicUpperBoundType().asReferenceType();
+    if (dynamicUpperBoundReferenceType.nullability() == nullability) {
+      return this;
+    }
+    return new DynamicTypeWithUpperBound(
+        dynamicUpperBoundReferenceType.getOrCreateVariant(nullability));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ExactDynamicType.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ExactDynamicType.java
index d66cfcc..1ab6c53 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/ExactDynamicType.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ExactDynamicType.java
@@ -4,25 +4,60 @@
 
 package com.android.tools.r8.ir.analysis.type;
 
-public class ExactDynamicType extends DynamicType {
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Set;
+
+public class ExactDynamicType extends DynamicTypeWithUpperBound {
 
   ExactDynamicType(ClassTypeElement exactDynamicType) {
     super(exactDynamicType);
   }
 
   @Override
+  public ClassTypeElement getDynamicUpperBoundType() {
+    return getExactClassType();
+  }
+
+  @Override
+  public ClassTypeElement getDynamicLowerBoundType() {
+    return getExactClassType();
+  }
+
+  @Override
+  public ClassTypeElement getExactClassType() {
+    return super.getDynamicUpperBoundType().asClassType();
+  }
+
+  @Override
   public boolean hasDynamicLowerBoundType() {
     return true;
   }
 
   @Override
-  public ClassTypeElement getDynamicUpperBoundType() {
-    return super.getDynamicUpperBoundType().asClassType();
+  public boolean isExactClassType() {
+    return true;
   }
 
   @Override
-  public ClassTypeElement getDynamicLowerBoundType() {
-    return getDynamicUpperBoundType();
+  public DynamicType rewrittenWithLens(
+      AppView<AppInfoWithLiveness> appView, GraphLens graphLens, Set<DexType> prunedTypes) {
+    TypeElement rewrittenType =
+        getExactClassType().rewrittenWithLens(appView, graphLens, prunedTypes);
+    assert rewrittenType.isClassType() || rewrittenType.isPrimitiveType();
+    return rewrittenType.isClassType()
+        ? new ExactDynamicType(rewrittenType.asClassType())
+        : unknown();
+  }
+
+  @Override
+  public ExactDynamicType withNullability(Nullability nullability) {
+    if (getNullability() == nullability) {
+      return this;
+    }
+    return new ExactDynamicType(getExactClassType().getOrCreateVariant(nullability));
   }
 
   @Override
@@ -31,19 +66,11 @@
       return false;
     }
     ExactDynamicType dynamicType = (ExactDynamicType) other;
-    return getDynamicUpperBoundType().equals(dynamicType.getDynamicUpperBoundType());
+    return getExactClassType().equals(dynamicType.getExactClassType());
   }
 
   @Override
   public int hashCode() {
-    return getDynamicLowerBoundType().hashCode();
-  }
-
-  @Override
-  public DynamicType withNullability(Nullability nullability) {
-    if (getDynamicUpperBoundType().nullability() == nullability) {
-      return this;
-    }
-    return new ExactDynamicType(getDynamicUpperBoundType().getOrCreateVariant(nullability));
+    return getExactClassType().hashCode();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/NotNullDynamicType.java b/src/main/java/com/android/tools/r8/ir/analysis/type/NotNullDynamicType.java
new file mode 100644
index 0000000..37ed14a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/NotNullDynamicType.java
@@ -0,0 +1,73 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.type;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Set;
+
+/**
+ * A dynamic type that encodes that a given value is guaranteed to be non null.
+ *
+ * <p>This dynamic type is a singleton and does not have an upper bound type. If this dynamic type
+ * is used in a context where there is a corresponding static type, then the dynamic upper bound
+ * type is the static type with non null information attached. See also {@link
+ * #getDynamicUpperBoundType(TypeElement)}.
+ */
+public class NotNullDynamicType extends DynamicType {
+
+  private static final NotNullDynamicType INSTANCE = new NotNullDynamicType();
+
+  private NotNullDynamicType() {}
+
+  public static NotNullDynamicType get() {
+    return INSTANCE;
+  }
+
+  @Override
+  public ReferenceTypeElement getDynamicUpperBoundType(TypeElement staticType) {
+    assert staticType.isReferenceType();
+    return staticType.asReferenceType().getOrCreateVariant(Nullability.definitelyNotNull());
+  }
+
+  @Override
+  public ClassTypeElement getExactClassType() {
+    return null;
+  }
+
+  @Override
+  public Nullability getNullability() {
+    return Nullability.definitelyNotNull();
+  }
+
+  @Override
+  public boolean isNotNullType() {
+    return true;
+  }
+
+  @Override
+  public NotNullDynamicType rewrittenWithLens(
+      AppView<AppInfoWithLiveness> appView, GraphLens graphLens, Set<DexType> prunedTypes) {
+    return this;
+  }
+
+  @Override
+  public DynamicType withNullability(Nullability nullability) {
+    assert !nullability.isBottom();
+    return nullability.isDefinitelyNotNull() ? this : unknown();
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    return this == other;
+  }
+
+  @Override
+  public int hashCode() {
+    return System.identityHashCode(this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
index 854ea6d..850b669 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
@@ -180,6 +180,14 @@
     return join(other, factory, type.isReferenceType(), false);
   }
 
+  public AbstractValue joinPrimitive(AbstractValue other, AbstractValueFactory factory) {
+    return join(other, factory, false, false);
+  }
+
+  public AbstractValue joinReference(AbstractValue other, AbstractValueFactory factory) {
+    return join(other, factory, true, false);
+  }
+
   // TODO(b/196321452): Clean this up, in particular, replace the "allow" parameters by a
   //  configuration object.
   public AbstractValue join(
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleFieldValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleFieldValue.java
index b499b81..0e746d4 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleFieldValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleFieldValue.java
@@ -143,7 +143,11 @@
         return factory.createSingleNumberValue(enumDataMap.getUnboxedValue(field));
       }
     }
-    return factory.createSingleFieldValue(
-        lens.lookupField(field), getObjectState().rewrittenWithLens(appView, lens));
+    DexField rewrittenField = lens.lookupField(field);
+    ObjectState rewrittenObjectState = getObjectState().rewrittenWithLens(appView, lens);
+    if (rewrittenField != field || rewrittenObjectState != getObjectState()) {
+      return factory.createSingleFieldValue(rewrittenField, rewrittenObjectState);
+    }
+    return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Assume.java b/src/main/java/com/android/tools/r8/ir/code/Assume.java
index f25c73b..e0a6238 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Assume.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Assume.java
@@ -10,7 +10,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.VerifyTypesHelper;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
@@ -53,19 +53,12 @@
   }
 
   public static Assume createAssumeDynamicTypeInstruction(
-      TypeElement dynamicUpperBoundType,
-      ClassTypeElement dynamicLowerBoundType,
+      DynamicTypeWithUpperBound dynamicType,
       Value dest,
       Value src,
       Instruction origin,
       AppView<?> appView) {
-    return new Assume(
-        new DynamicTypeAssumption(dynamicUpperBoundType, dynamicLowerBoundType),
-        null,
-        dest,
-        src,
-        origin,
-        appView);
+    return new Assume(new DynamicTypeAssumption(dynamicType), null, dest, src, origin, appView);
   }
 
   @Override
@@ -142,7 +135,7 @@
       return false;
     }
     if (hasDynamicTypeAssumption()) {
-      outType = dynamicTypeAssumption.getDynamicUpperBoundType();
+      outType = dynamicTypeAssumption.getDynamicType().getDynamicUpperBoundType();
     }
     if (appView.appInfo().hasLiveness()) {
       if (outType.isClassType()
@@ -261,6 +254,8 @@
       assert inType.isNullType() || outType.equals(inType.asReferenceType().asMeetWithNotNull())
           : "At " + this + System.lineSeparator() + outType + " != " + inType;
     } else {
+      assert hasDynamicTypeAssumption();
+      assert !src().isConstNumber();
       assert outType.equals(inType)
           : "At " + this + System.lineSeparator() + outType + " != " + inType;
     }
@@ -279,13 +274,14 @@
       builder.append("; not null");
     }
     if (hasDynamicTypeAssumption()) {
+      DynamicTypeWithUpperBound dynamicType = dynamicTypeAssumption.getDynamicType();
       if (hasOutValue()) {
-        if (!dynamicTypeAssumption.dynamicUpperBoundType.equalUpToNullability(outValue.getType())) {
-          builder.append("; upper bound: ").append(dynamicTypeAssumption.dynamicUpperBoundType);
+        if (!dynamicType.getDynamicUpperBoundType().equalUpToNullability(outValue.getType())) {
+          builder.append("; upper bound: ").append(dynamicType.getDynamicUpperBoundType());
         }
       }
-      if (dynamicTypeAssumption.dynamicLowerBoundType != null) {
-        builder.append("; lower bound: ").append(dynamicTypeAssumption.dynamicLowerBoundType);
+      if (dynamicType.hasDynamicLowerBoundType()) {
+        builder.append("; lower bound: ").append(dynamicType.getDynamicLowerBoundType());
       }
     }
     return builder.toString();
@@ -293,27 +289,23 @@
 
   public static class DynamicTypeAssumption {
 
-    private final TypeElement dynamicUpperBoundType;
-    private final ClassTypeElement dynamicLowerBoundType;
+    private final DynamicTypeWithUpperBound dynamicType;
 
-    public DynamicTypeAssumption(
-        TypeElement dynamicUpperBoundType, ClassTypeElement dynamicLowerBoundType) {
-      this.dynamicUpperBoundType = dynamicUpperBoundType;
-      this.dynamicLowerBoundType = dynamicLowerBoundType;
+    public DynamicTypeAssumption(DynamicTypeWithUpperBound dynamicType) {
+      assert dynamicType != null;
+      this.dynamicType = dynamicType;
     }
 
-    public TypeElement getDynamicUpperBoundType() {
-      return dynamicUpperBoundType;
-    }
-
-    public ClassTypeElement getDynamicLowerBoundType() {
-      return dynamicLowerBoundType;
+    public DynamicTypeWithUpperBound getDynamicType() {
+      return dynamicType;
     }
 
     public boolean verifyCorrectnessOfValues(Value dest, Value src, AppView<?> appView) {
-      assert !dynamicUpperBoundType.isBottom();
-      assert !dynamicUpperBoundType.isTop();
-      assert dynamicUpperBoundType.lessThanOrEqualUpToNullability(src.getType(), appView);
+      assert !dynamicType.isBottom();
+      assert !dynamicType.isUnknown();
+      assert dynamicType
+          .getDynamicUpperBoundType()
+          .lessThanOrEqualUpToNullability(src.getType(), appView);
       return true;
     }
 
@@ -326,13 +318,12 @@
         return false;
       }
       DynamicTypeAssumption assumption = (DynamicTypeAssumption) other;
-      return dynamicUpperBoundType == assumption.dynamicUpperBoundType
-          && dynamicLowerBoundType == assumption.dynamicLowerBoundType;
+      return dynamicType.equals(assumption.dynamicType);
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(dynamicUpperBoundType, dynamicLowerBoundType);
+      return dynamicType.hashCode();
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
index 38e86e1..36ec641 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
@@ -132,7 +132,9 @@
       if (receiverLowerBoundType != null) {
         DexType refinedReceiverType =
             TypeAnalysis.getRefinedReceiverType(appViewWithLiveness, this);
-        assert receiverLowerBoundType.getClassType() == refinedReceiverType
+        assert appViewWithLiveness
+                    .appInfo()
+                    .isSubtype(receiverLowerBoundType.getClassType(), refinedReceiverType)
                 || appView.options().testing.allowTypeErrors
                 || receiver.getDynamicUpperBoundType(appViewWithLiveness).isNullType()
                 || receiverLowerBoundType.isBasedOnMissingClass(appViewWithLiveness)
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index 27713d8..cc59793 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -23,6 +23,7 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -1093,7 +1094,7 @@
     return type;
   }
 
-  public DynamicType getDynamicType(AppView<AppInfoWithLiveness> appView) {
+  public DynamicTypeWithUpperBound getDynamicType(AppView<AppInfoWithLiveness> appView) {
     return DynamicType.create(appView, this);
   }
 
@@ -1124,7 +1125,12 @@
       // If there is an alias of the receiver, which is defined by an Assume instruction that
       // carries a dynamic type, then use the dynamic type as the refined receiver type.
       lattice =
-          aliasedValue.definition.asAssume().getDynamicTypeAssumption().getDynamicUpperBoundType();
+          aliasedValue
+              .definition
+              .asAssume()
+              .getDynamicTypeAssumption()
+              .getDynamicType()
+              .getDynamicUpperBoundType();
 
       // For precision, verify that the dynamic type is at least as precise as the static type.
       assert lattice.lessThanOrEqualUpToNullability(type, appView) : type + " < " + lattice;
@@ -1190,6 +1196,7 @@
               .getDefinition()
               .asAssume()
               .getDynamicTypeAssumption()
+              .getDynamicType()
               .getDynamicLowerBoundType();
       if (aliasedValueType != null) {
         aliasedValueType = aliasedValueType.meetNullability(getType().nullability());
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
index c6070c5..b5e3b1e 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
@@ -6,8 +6,7 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 
@@ -19,9 +18,7 @@
 
   void markFieldAsPropagated(DexEncodedField field);
 
-  void markFieldHasDynamicLowerBoundType(DexEncodedField field, ClassTypeElement type);
-
-  void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeElement type);
+  void markFieldHasDynamicType(DexEncodedField field, DynamicType dynamicType);
 
   void markFieldBitsRead(DexEncodedField field, int bitsRead);
 
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 37ce381..047894d 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
@@ -114,7 +114,6 @@
 import com.google.common.base.Suppliers;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
@@ -819,20 +818,9 @@
 
     // Assure that no more optimization feedback left after post processing.
     assert feedback.noUpdatesLeft();
-    assert checkLegacySyntheticsAreInBuilder(appView, builder);
     return builder.build();
   }
 
-  private boolean checkLegacySyntheticsAreInBuilder(
-      AppView<AppInfoWithLiveness> appView, Builder<?> builder) {
-    Collection<DexProgramClass> inAppInfo =
-        appView.appInfo().getSyntheticItems().getLegacyPendingClasses();
-    Collection<DexProgramClass> inBuilder = builder.getSynthesizedClasses();
-    assert inAppInfo.containsAll(inBuilder);
-    assert inBuilder.containsAll(inAppInfo);
-    return true;
-  }
-
   private void waveStart(ProgramMethodSet wave) {
     onWaveDoneActions = Collections.synchronizedList(new ArrayList<>());
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index dafd559..5794f8d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -479,7 +479,8 @@
               InstancePut instancePut = current.asInstancePut();
               DexField field = instancePut.getField();
               FieldLookupResult lookup = graphLens.lookupFieldResult(field);
-              insertCastForFieldAssignmentIfNeeded(code, blocks, iterator, instancePut, lookup);
+              iterator =
+                  insertCastForFieldAssignmentIfNeeded(code, blocks, iterator, instancePut, lookup);
 
               DexField rewrittenField = rewriteFieldReference(lookup, method);
               DexMethod replacementMethod =
@@ -550,7 +551,8 @@
               StaticPut staticPut = current.asStaticPut();
               DexField field = staticPut.getField();
               FieldLookupResult lookup = graphLens.lookupFieldResult(field);
-              insertCastForFieldAssignmentIfNeeded(code, blocks, iterator, staticPut, lookup);
+              iterator =
+                  insertCastForFieldAssignmentIfNeeded(code, blocks, iterator, staticPut, lookup);
 
               DexField actualField = rewriteFieldReference(lookup, method);
               DexMethod replacementMethod =
@@ -752,7 +754,7 @@
     assert code.hasNoMergedClasses(appView);
   }
 
-  private void insertCastForFieldAssignmentIfNeeded(
+  private InstructionListIterator insertCastForFieldAssignmentIfNeeded(
       IRCode code,
       ListIterator<BasicBlock> blocks,
       InstructionListIterator iterator,
@@ -774,6 +776,7 @@
       Instruction next = iterator.next();
       assert next == fieldPut;
     }
+    return iterator;
   }
 
   private DexField rewriteFieldReference(FieldLookupResult lookup, ProgramMethod context) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
index 6cf694a..8b229f9 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
@@ -9,8 +9,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.classinliner.constraint.ClassInlinerMethodConstraint;
@@ -38,10 +37,12 @@
   void methodReturnsAbstractValue(
       DexEncodedMethod method, AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue);
 
-  void methodReturnsObjectWithUpperBoundType(
-      DexEncodedMethod method, AppView<?> appView, TypeElement type);
+  default void setDynamicReturnType(
+      ProgramMethod method, AppView<?> appView, DynamicType dynamicType) {
+    setDynamicReturnType(method.getDefinition(), appView, dynamicType);
+  }
 
-  void methodReturnsObjectWithLowerBoundType(DexEncodedMethod method, ClassTypeElement type);
+  void setDynamicReturnType(DexEncodedMethod method, AppView<?> appView, DynamicType dynamicType);
 
   void methodMayNotHaveSideEffects(DexEncodedMethod method);
 
@@ -92,9 +93,7 @@
 
   void unsetClassInlinerMethodConstraint(ProgramMethod method);
 
-  void unsetDynamicLowerBoundReturnType(ProgramMethod method);
-
-  void unsetDynamicUpperBoundReturnType(ProgramMethod method);
+  void unsetDynamicReturnType(ProgramMethod method);
 
   void unsetEnumUnboxerMethodClassification(ProgramMethod method);
 
@@ -135,8 +134,7 @@
       unsetCheckNullReceiverBeforeAnySideEffect(method);
       unsetClassInitializerMayBePostponed(method);
       unsetClassInlinerMethodConstraint(method);
-      unsetDynamicLowerBoundReturnType(method);
-      unsetDynamicUpperBoundReturnType(method);
+      unsetDynamicReturnType(method);
       unsetEnumUnboxerMethodClassification(method);
       unsetForceInline(method);
       unsetInitializedClassesOnNormalExit(method);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java b/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
index efc31d3..30ea9f8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
@@ -12,7 +12,9 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
+import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.Assume;
@@ -217,10 +219,9 @@
       return false;
     }
 
-    TypeElement dynamicUpperBoundType =
-        TypeElement.fromDexType(invoke.getInvokedMethod().holder, definitelyNotNull(), appView);
-    assumedValuesBuilder.addAssumedValueKnownToDominateAllUsers(
-        invoke, outValue, dynamicUpperBoundType, null);
+    DynamicTypeWithUpperBound dynamicType =
+        invoke.getInvokedMethod().getHolderType().toDynamicType(appView, definitelyNotNull());
+    assumedValuesBuilder.addAssumedValueKnownToDominateAllUsers(invoke, outValue, dynamicType);
     return true;
   }
 
@@ -257,10 +258,7 @@
     if (invoke.hasUsedOutValue()) {
       needsAssumeInstruction =
           computeAssumedValuesForOutValue(
-              invoke,
-              optimizationInfo.getDynamicUpperBoundTypeOrElse(invoke.getOutType()),
-              optimizationInfo.getDynamicLowerBoundType(),
-              assumedValuesBuilder);
+              invoke, optimizationInfo.getDynamicType(), assumedValuesBuilder);
     }
 
     // Case (3), parameters that are not null after the invocation.
@@ -306,35 +304,38 @@
 
     FieldOptimizationInfo optimizationInfo = field.getDefinition().getOptimizationInfo();
     return computeAssumedValuesForOutValue(
-        fieldGet,
-        optimizationInfo.getDynamicUpperBoundTypeOrElse(fieldGet.getOutType()),
-        optimizationInfo.getDynamicLowerBoundType(),
-        assumedValuesBuilder);
+        fieldGet, optimizationInfo.getDynamicType(), assumedValuesBuilder);
   }
 
   private boolean computeAssumedValuesForOutValue(
       Instruction instruction,
-      TypeElement dynamicUpperBoundType,
-      ClassTypeElement dynamicLowerBoundType,
+      DynamicType dynamicType,
       AssumedValues.Builder assumedValuesBuilder) {
     Value outValue = instruction.outValue();
-
     // Do not insert dynamic type information if it does not refine the static type.
-    boolean isRedundant =
-        !dynamicUpperBoundType.strictlyLessThan(outValue.getType(), appView)
-            && dynamicLowerBoundType == null;
-    if (isRedundant) {
+    if (dynamicType.isUnknown()) {
       return false;
     }
 
-    // Do not insert dynamic type information if the dynamic type only refines the nullability.
-    if (dynamicUpperBoundType.equalUpToNullability(outValue.getType())
-        && dynamicLowerBoundType == null) {
-      assert dynamicUpperBoundType.isDefinitelyNotNull();
+    // Insert an assume-not-null instruction if the dynamic type only refines the nullability.
+    if (dynamicType.isNotNullType()) {
+      assumedValuesBuilder.addNonNullValueKnownToDominateAllUsers(instruction, outValue);
+      return true;
+    }
+
+    DynamicTypeWithUpperBound dynamicTypeWithUpperBound = dynamicType.asDynamicTypeWithUpperBound();
+    DynamicTypeWithUpperBound staticType = DynamicType.create(appView, outValue.getType());
+    if (!dynamicTypeWithUpperBound.strictlyLessThan(staticType, appView)) {
+      return false;
+    }
+
+    if (!dynamicTypeWithUpperBound.getNullability().isMaybeNull()
+        && dynamicTypeWithUpperBound.withNullability(Nullability.maybeNull()).equals(staticType)) {
+      assert dynamicTypeWithUpperBound.getNullability().isDefinitelyNotNull();
       assumedValuesBuilder.addNonNullValueKnownToDominateAllUsers(instruction, outValue);
     } else {
       assumedValuesBuilder.addAssumedValueKnownToDominateAllUsers(
-          instruction, outValue, dynamicUpperBoundType, dynamicLowerBoundType);
+          instruction, outValue, dynamicTypeWithUpperBound);
     }
     return true;
   }
@@ -707,21 +708,17 @@
       this.dynamicTypeAssumption = dynamicTypeAssumption;
     }
 
-    void setDynamicTypeAssumption(
-        TypeElement dynamicUpperBoundType, ClassTypeElement dynamicLowerBoundType) {
-      dynamicTypeAssumption =
-          new DynamicTypeAssumption(dynamicUpperBoundType, dynamicLowerBoundType);
-      if (dynamicUpperBoundType.isDefinitelyNotNull()) {
-        setNotNull();
-      }
-      if (dynamicLowerBoundType != null && dynamicLowerBoundType.isDefinitelyNotNull()) {
+    void setDynamicTypeAssumption(DynamicTypeWithUpperBound dynamicType) {
+      assert dynamicType != null;
+      dynamicTypeAssumption = new DynamicTypeAssumption(dynamicType);
+      if (dynamicType.getDynamicUpperBoundType().isDefinitelyNotNull()) {
         setNotNull();
       }
     }
 
     boolean isNull() {
       return dynamicTypeAssumption != null
-          && dynamicTypeAssumption.getDynamicUpperBoundType().isDefinitelyNull();
+          && dynamicTypeAssumption.getDynamicType().getNullability().isDefinitelyNull();
     }
 
     boolean isNonNull() {
@@ -874,17 +871,12 @@
       }
 
       void addAssumedValueKnownToDominateAllUsers(
-          Instruction instruction,
-          Value assumedValue,
-          TypeElement dynamicUpperBoundType,
-          ClassTypeElement dynamicLowerBoundType) {
+          Instruction instruction, Value assumedValue, DynamicTypeWithUpperBound dynamicType) {
         updateAssumedValueInfo(
             instruction,
             assumedValue,
             AssumedDominance.everything(),
-            assumedValueInfo ->
-                assumedValueInfo.setDynamicTypeAssumption(
-                    dynamicUpperBoundType, dynamicLowerBoundType));
+            assumedValueInfo -> assumedValueInfo.setDynamicTypeAssumption(dynamicType));
       }
 
       void addNonNullValueKnownToDominateAllUsers(Instruction instruction, Value nonNullValue) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/AssumeRemover.java b/src/main/java/com/android/tools/r8/ir/optimize/AssumeRemover.java
index 85ac5b8..70057fc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/AssumeRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/AssumeRemover.java
@@ -33,14 +33,19 @@
   private final AppView<?> appView;
   private final IRCode code;
 
-  private final Set<Value> affectedValues = Sets.newIdentityHashSet();
+  private final Set<Value> affectedValues;
   private final Set<Assume> assumeInstructionsToRemove = Sets.newIdentityHashSet();
 
   private boolean mayHaveIntroducedTrivialPhi = false;
 
   public AssumeRemover(AppView<?> appView, IRCode code) {
+    this(appView, code, Sets.newIdentityHashSet());
+  }
+
+  public AssumeRemover(AppView<?> appView, IRCode code, Set<Value> affectedValues) {
     this.appView = appView;
     this.code = code;
+    this.affectedValues = affectedValues;
   }
 
   public Set<Value> getAffectedValues() {
@@ -57,7 +62,7 @@
         Assume assumeInstruction = user.asAssume();
         assumeInstruction.unsetDynamicTypeAssumption();
         if (!assumeInstruction.hasNonNullAssumption()) {
-          assumeInstruction.unsetDynamicTypeAssumption();
+          markForRemoval(assumeInstruction);
         }
       }
     }
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 dae6f04..a10c4d7 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
@@ -30,6 +30,8 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerUtils;
 import com.android.tools.r8.ir.analysis.equivalence.BasicBlockBehavioralSubsumption;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
+import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -1655,16 +1657,13 @@
                     value.isDefinedByInstructionSatisfying(
                         Instruction::isAssumeWithDynamicTypeAssumption));
         if (aliasedValue != null) {
-          TypeElement dynamicType =
-              aliasedValue
-                  .definition
-                  .asAssume()
-                  .getDynamicTypeAssumption()
-                  .getDynamicUpperBoundType();
-          if (dynamicType.isDefinitelyNull()) {
+          DynamicTypeWithUpperBound dynamicType =
+              aliasedValue.getDefinition().asAssume().getDynamicTypeAssumption().getDynamicType();
+          Nullability nullability = dynamicType.getNullability();
+          if (nullability.isDefinitelyNull()) {
             result = InstanceOfResult.FALSE;
-          } else if (dynamicType.lessThanOrEqual(instanceOfType, appView)
-              && (!inType.isNullable() || !dynamicType.isNullable())) {
+          } else if (dynamicType.getDynamicUpperBoundType().lessThanOrEqual(instanceOfType, appView)
+              && (!inType.isNullable() || !nullability.isNullable())) {
             result = InstanceOfResult.TRUE;
           }
         }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index 8007b17..d612c5f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -161,7 +161,8 @@
 
     SyntheticItems syntheticItems = appView.getSyntheticItems();
     ClassToFeatureSplitMap classToFeatureSplitMap = appView.appInfo().getClassToFeatureSplitMap();
-    if (!classToFeatureSplitMap.isInSameFeatureOrBothInBase(singleTarget, method, syntheticItems)) {
+    if (!classToFeatureSplitMap.isInSameFeatureOrBothInSameBase(
+        singleTarget, method, syntheticItems)) {
       // Still allow inlining if we inline from the base into a feature.
       if (!classToFeatureSplitMap.isInBase(singleTarget.getHolder(), syntheticItems)) {
         whyAreYouNotInliningReporter.reportInliningAcrossFeatureSplit();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java
index 9b738b6..10988dc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java
@@ -5,9 +5,8 @@
 package com.android.tools.r8.ir.optimize;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.JumpInstruction;
@@ -29,41 +28,16 @@
    *
    * <p>If the method has no normal exits, then null is returned.
    */
-  public TypeElement computeDynamicReturnType(DexEncodedMethod method, IRCode code) {
-    assert method.getReference().proto.returnType.isReferenceType();
-    List<TypeElement> returnedTypes = new ArrayList<>();
-    for (BasicBlock block : code.blocks) {
+  public DynamicType computeDynamicReturnType(ProgramMethod method, IRCode code) {
+    assert method.getReturnType().isReferenceType();
+    List<DynamicType> returnedTypes = new ArrayList<>();
+    for (BasicBlock block : code.getBlocks()) {
       JumpInstruction exitInstruction = block.exit();
       if (exitInstruction.isReturn()) {
         Value returnValue = exitInstruction.asReturn().returnValue();
-        returnedTypes.add(returnValue.getDynamicUpperBoundType(appView));
+        returnedTypes.add(returnValue.getDynamicType(appView));
       }
     }
-    return returnedTypes.isEmpty() ? null : TypeElement.join(returnedTypes, appView);
-  }
-
-  public ClassTypeElement computeDynamicLowerBoundType(DexEncodedMethod method, IRCode code) {
-    assert method.getReference().proto.returnType.isReferenceType();
-    ClassTypeElement result = null;
-    for (BasicBlock block : code.blocks) {
-      JumpInstruction exitInstruction = block.exit();
-      if (exitInstruction.isReturn()) {
-        Value returnValue = exitInstruction.asReturn().returnValue();
-        ClassTypeElement dynamicLowerBoundType = returnValue.getDynamicLowerBoundType(appView);
-        if (dynamicLowerBoundType == null) {
-          return null;
-        }
-        if (result == null) {
-          result = dynamicLowerBoundType;
-        } else if (dynamicLowerBoundType.equalUpToNullability(result)) {
-          if (dynamicLowerBoundType.nullability() != result.nullability()) {
-            result = dynamicLowerBoundType.join(result, appView).asClassType();
-          }
-        } else {
-          return null;
-        }
-      }
-    }
-    return result;
+    return DynamicType.join(appView, returnedTypes);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index 510331b..b4a067e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -1108,8 +1108,7 @@
       }
     }
     assert inlineeStack.isEmpty();
-    assumeRemover.removeMarkedInstructions(blocksToRemove);
-    assumeRemover.finish();
+    assumeRemover.removeMarkedInstructions(blocksToRemove).finish();
     classInitializationAnalysis.finish();
     code.removeBlocks(blocksToRemove);
     code.removeAllDeadAndTrivialPhis();
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 206c455..755f334 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
@@ -411,7 +411,7 @@
       // Verify that the optimization info is consistent with the static value.
       assert definition.getOptimizationInfo().getAbstractValue().isUnknown()
           || !definition.hasExplicitStaticValue()
-          || abstractValue == definition.getOptimizationInfo().getAbstractValue();
+          || abstractValue.equals(definition.getOptimizationInfo().getAbstractValue());
     } else {
       // This is guaranteed to read the default value of the field.
       abstractValue = appView.abstractValueFactory().createSingleNumberValue(0);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
index afb7003..b3f74c5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
@@ -16,7 +16,6 @@
 import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
-import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.value.SingleFieldValue;
 import com.android.tools.r8.ir.analysis.value.SingleValue;
 import com.android.tools.r8.ir.analysis.value.objectstate.ObjectState;
@@ -189,6 +188,7 @@
       }
     }
 
+    AssumeRemover assumeRemover = new AssumeRemover(appView, code, affectedValues);
     for (BasicBlock head : code.topologicallySortedBlocks()) {
       if (head.hasUniquePredecessor() && head.getUniquePredecessor().hasUniqueNormalSuccessor()) {
         // Already visited.
@@ -211,14 +211,16 @@
             }
 
             if (instruction.isInstanceGet()) {
-              handleInstanceGet(it, instruction.asInstanceGet(), field);
+              handleInstanceGet(it, instruction.asInstanceGet(), field, assumeRemover);
             } else if (instruction.isInstancePut()) {
               handleInstancePut(instruction.asInstancePut(), field);
             } else if (instruction.isStaticGet()) {
-              handleStaticGet(it, instruction.asStaticGet(), field);
+              handleStaticGet(it, instruction.asStaticGet(), field, assumeRemover);
             } else if (instruction.isStaticPut()) {
               handleStaticPut(instruction.asStaticPut(), field);
             }
+          } else if (instruction.isAssume()) {
+            assumeRemover.removeIfMarked(instruction.asAssume(), it);
           } else if (instruction.isInitClass()) {
             handleInitClass(it, instruction.asInitClass());
           } else if (instruction.isMonitor()) {
@@ -288,9 +290,7 @@
       activeStates.recordActiveStateOnBlockExit(end, activeState);
     }
     processInstructionsToRemove();
-    if (!affectedValues.isEmpty()) {
-      new TypeAnalysis(appView).narrowing(affectedValues);
-    }
+    assumeRemover.removeMarkedInstructions().finish();
     assert code.isConsistentSSA();
   }
 
@@ -398,7 +398,10 @@
   }
 
   private void handleInstanceGet(
-      InstructionListIterator it, InstanceGet instanceGet, DexClassAndField field) {
+      InstructionListIterator it,
+      InstanceGet instanceGet,
+      DexClassAndField field,
+      AssumeRemover assumeRemover) {
     if (instanceGet.outValue().hasLocalInfo()) {
       clearMostRecentInstanceFieldWrite(instanceGet, field);
       return;
@@ -408,6 +411,7 @@
     FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
     FieldValue replacement = activeState.getInstanceFieldValue(fieldAndObject);
     if (replacement != null) {
+      assumeRemover.markAssumeDynamicTypeUsersForRemoval(instanceGet.outValue());
       replacement.eliminateRedundantRead(it, instanceGet);
       return;
     }
@@ -464,7 +468,10 @@
   }
 
   private void handleStaticGet(
-      InstructionListIterator instructionIterator, StaticGet staticGet, DexClassAndField field) {
+      InstructionListIterator instructionIterator,
+      StaticGet staticGet,
+      DexClassAndField field,
+      AssumeRemover assumeRemover) {
     if (staticGet.outValue().hasLocalInfo()) {
       killNonFinalActiveFields(staticGet);
       clearMostRecentStaticFieldWrite(staticGet, field);
@@ -473,6 +480,7 @@
 
     FieldValue replacement = activeState.getStaticFieldValue(field.getReference());
     if (replacement != null) {
+      assumeRemover.markAssumeDynamicTypeUsersForRemoval(staticGet.outValue());
       replacement.eliminateRedundantRead(instructionIterator, staticGet);
       return;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index c3c2307..442cb96 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -14,12 +14,12 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionOrPhi;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.ir.optimize.AssumeRemover;
 import com.android.tools.r8.ir.optimize.CodeRewriter;
 import com.android.tools.r8.ir.optimize.Inliner;
 import com.android.tools.r8.ir.optimize.InliningOracle;
@@ -209,8 +209,10 @@
 
         // Inline the class instance.
         Set<Value> affectedValues = Sets.newIdentityHashSet();
+        AssumeRemover assumeRemover = new AssumeRemover(appView, code, affectedValues);
         try {
-          anyInlinedMethods |= processor.processInlining(code, affectedValues, inliningIRProvider);
+          anyInlinedMethods |=
+              processor.processInlining(code, affectedValues, assumeRemover, inliningIRProvider);
         } catch (IllegalClassInlinerStateException e) {
           // We introduced a user that we cannot handle in the class inliner as a result of force
           // inlining. Abort gracefully from class inlining without removing the instance.
@@ -224,10 +226,9 @@
         }
 
         // Restore normality.
+        assumeRemover.removeMarkedInstructions();
         code.removeAllDeadAndTrivialPhis(affectedValues);
-        if (!affectedValues.isEmpty()) {
-          new TypeAnalysis(appView).narrowing(affectedValues);
-        }
+        assumeRemover.finish();
         assert code.isConsistentSSA();
         rootsIterator.remove();
         repeat = true;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 82322c7..aede4f7 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
@@ -25,6 +25,7 @@
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -48,6 +49,7 @@
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.ir.optimize.AssumeRemover;
 import com.android.tools.r8.ir.optimize.Inliner;
 import com.android.tools.r8.ir.optimize.Inliner.InliningInfo;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
@@ -178,13 +180,12 @@
     }
     DexEncodedField field = fieldResolutionResult.getResolvedField();
     FieldOptimizationInfo optimizationInfo = field.getOptimizationInfo();
-    ClassTypeElement dynamicLowerBoundType = optimizationInfo.getDynamicLowerBoundType();
-    if (dynamicLowerBoundType == null
-        || !dynamicLowerBoundType.equals(optimizationInfo.getDynamicUpperBoundType())) {
+    DynamicType dynamicType = optimizationInfo.getDynamicType();
+    if (!dynamicType.isExactClassType()) {
       return EligibilityStatus.NOT_ELIGIBLE;
     }
     eligibleClass =
-        asProgramClassOrNull(appView.definitionFor(dynamicLowerBoundType.getClassType()));
+        asProgramClassOrNull(appView.definitionFor(dynamicType.getExactClassType().getClassType()));
     if (eligibleClass == null) {
       return EligibilityStatus.NOT_ELIGIBLE;
     }
@@ -376,6 +377,7 @@
   boolean processInlining(
       IRCode code,
       Set<Value> affectedValues,
+      AssumeRemover assumeRemover,
       InliningIRProvider inliningIRProvider)
       throws IllegalClassInlinerStateException {
     // Verify that `eligibleInstance` is not aliased.
@@ -386,7 +388,7 @@
 
     rebindIndirectEligibleInstanceUsersFromPhis();
     removeMiscUsages(code, affectedValues);
-    removeFieldReads(code);
+    removeFieldReads(code, assumeRemover);
     removeFieldWrites();
     removeInstruction(root);
     return anyInlinedMethods;
@@ -666,24 +668,26 @@
   }
 
   // Replace field reads with appropriate values, insert phis when needed.
-  private void removeFieldReads(IRCode code) {
+  private void removeFieldReads(IRCode code, AssumeRemover assumeRemover) {
     Set<Value> affectedValues = Sets.newIdentityHashSet();
     if (root.isNewInstance()) {
-      removeFieldReadsFromNewInstance(code, affectedValues);
+      removeFieldReadsFromNewInstance(code, affectedValues, assumeRemover);
     } else {
       assert root.isStaticGet();
-      removeFieldReadsFromStaticGet(code, affectedValues);
+      removeFieldReadsFromStaticGet(code, affectedValues, assumeRemover);
     }
     if (!affectedValues.isEmpty()) {
       new TypeAnalysis(appView).narrowing(affectedValues);
     }
   }
 
-  private void removeFieldReadsFromNewInstance(IRCode code, Set<Value> affectedValues) {
+  private void removeFieldReadsFromNewInstance(
+      IRCode code, Set<Value> affectedValues, AssumeRemover assumeRemover) {
     TreeSet<InstanceGet> uniqueInstanceGetUsersWithDeterministicOrder =
         new TreeSet<>(Comparator.comparingInt(x -> x.outValue().getNumber()));
     for (Instruction user : eligibleInstance.uniqueUsers()) {
       if (user.isInstanceGet()) {
+        assumeRemover.markAssumeDynamicTypeUsersForRemoval(user.outValue());
         if (user.hasUsedOutValue()) {
           uniqueInstanceGetUsersWithDeterministicOrder.add(user.asInstanceGet());
         } else {
@@ -738,7 +742,8 @@
     removeInstruction(fieldRead);
   }
 
-  private void removeFieldReadsFromStaticGet(IRCode code, Set<Value> affectedValues) {
+  private void removeFieldReadsFromStaticGet(
+      IRCode code, Set<Value> affectedValues, AssumeRemover assumeRemover) {
     Set<BasicBlock> seen = Sets.newIdentityHashSet();
     Set<Instruction> users = eligibleInstance.uniqueUsers();
     for (Instruction user : users) {
@@ -759,6 +764,7 @@
         }
 
         if (instruction.isInstanceGet()) {
+          assumeRemover.markAssumeDynamicTypeUsersForRemoval(instruction.outValue());
           if (instruction.hasUsedOutValue()) {
             replaceFieldReadFromStaticGet(
                 code, instructionIterator, user.asInstanceGet(), affectedValues);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java
index ff79200..95a4b63 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumValueOptimizer.java
@@ -140,7 +140,7 @@
 
         // Since the value is a single field value, the type should be exact.
         assert abstractValue.isSingleFieldValue();
-        ClassTypeElement enumFieldType = optimizationInfo.getExactClassType(appView);
+        ClassTypeElement enumFieldType = optimizationInfo.getDynamicType().getExactClassType();
         if (enumFieldType == null) {
           assert false : "Expected to have an exact dynamic type for enum instance";
           continue;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/CallSiteOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/CallSiteOptimizationInfo.java
index 3a9c9c0..6356bbf 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/CallSiteOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/CallSiteOptimizationInfo.java
@@ -3,24 +3,17 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.optimize.info;
 
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
 
-// A flat lattice structure:
-//   BOTTOM, TOP, and a lattice element that holds accumulated argument info.
+// A flat lattice structure: TOP and a lattice element that holds accumulated argument info.
 public abstract class CallSiteOptimizationInfo {
 
   public static TopCallSiteOptimizationInfo top() {
     return TopCallSiteOptimizationInfo.getInstance();
   }
 
-  public boolean isTop() {
-    return false;
-  }
-
   public boolean isConcreteCallSiteOptimizationInfo() {
     return false;
   }
@@ -29,33 +22,11 @@
     return null;
   }
 
-  public CallSiteOptimizationInfo join(
-      CallSiteOptimizationInfo other, AppView<?> appView, DexEncodedMethod method) {
-    if (other.isTop()) {
-      return other;
-    }
-    if (isTop()) {
-      return this;
-    }
-    assert isConcreteCallSiteOptimizationInfo() && other.isConcreteCallSiteOptimizationInfo();
-    return asConcreteCallSiteOptimizationInfo()
-        .join(other.asConcreteCallSiteOptimizationInfo(), appView, method);
-  }
-
-  public boolean hasUsefulOptimizationInfo(AppView<?> appView, DexEncodedMethod method) {
-    return false;
-  }
-
-
   // The index exactly matches with in values of invocation, i.e., even including receiver.
-  public TypeElement getDynamicUpperBoundType(int argIndex) {
+  public DynamicType getDynamicType(int argIndex) {
     return null;
   }
 
-  // TODO(b/139246447): dynamic lower bound type?
-
-  // TODO(b/69963623): we need to re-run unused argument removal?
-
   // The index exactly matches with in values of invocation, i.e., even including receiver.
   public AbstractValue getAbstractArgumentValue(int argIndex) {
     return UnknownValue.getInstance();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
index 230b15b..2ee5a6e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
@@ -3,31 +3,25 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.optimize.info;
 
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
 import static com.android.tools.r8.utils.MapUtils.canonicalizeEmptyMap;
 import static java.util.Objects.requireNonNull;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription.ArgumentInfoCollection;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
-import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteMonomorphicMethodState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteParameterState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ParameterState;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
-import java.util.List;
 
 // Accumulated optimization info from call sites.
 public class ConcreteCallSiteOptimizationInfo extends CallSiteOptimizationInfo {
@@ -35,7 +29,7 @@
   // inValues() size == DexMethod.arity + (isStatic ? 0 : 1) // receiver
   // That is, this information takes into account the receiver as well.
   private final int size;
-  private final Int2ReferenceMap<TypeElement> dynamicUpperBoundTypes;
+  private final Int2ReferenceMap<DynamicType> dynamicTypes;
   private final Int2ReferenceMap<AbstractValue> constants;
 
   private ConcreteCallSiteOptimizationInfo(int size) {
@@ -44,29 +38,24 @@
 
   private ConcreteCallSiteOptimizationInfo(
       int size,
-      Int2ReferenceMap<TypeElement> dynamicUpperBoundTypes,
+      Int2ReferenceMap<DynamicType> dynamicTypes,
       Int2ReferenceMap<AbstractValue> constants) {
     assert size > 0;
+    assert constants.values().stream().noneMatch(AbstractValue::isUnknown);
+    assert dynamicTypes.values().stream().noneMatch(DynamicType::isUnknown);
     this.size = size;
-    this.dynamicUpperBoundTypes = requireNonNull(dynamicUpperBoundTypes);
+    this.dynamicTypes = requireNonNull(dynamicTypes);
     this.constants = requireNonNull(constants);
   }
 
   private static CallSiteOptimizationInfo create(
       int size,
-      Int2ReferenceMap<TypeElement> dynamicUpperBoundTypes,
+      Int2ReferenceMap<DynamicType> dynamicTypes,
       Int2ReferenceMap<AbstractValue> constants) {
-    return constants.isEmpty() && dynamicUpperBoundTypes.isEmpty()
+    return constants.isEmpty() && dynamicTypes.isEmpty()
         ? top()
         : new ConcreteCallSiteOptimizationInfo(
-            size, canonicalizeEmptyMap(dynamicUpperBoundTypes), canonicalizeEmptyMap(constants));
-  }
-
-  public CallSiteOptimizationInfo fixupAfterExtraNullParameters(int extraNullParameters) {
-    return extraNullParameters > 0
-        ? new ConcreteCallSiteOptimizationInfo(
-            size + extraNullParameters, dynamicUpperBoundTypes, constants)
-        : this;
+            size, canonicalizeEmptyMap(dynamicTypes), canonicalizeEmptyMap(constants));
   }
 
   public CallSiteOptimizationInfo fixupAfterParametersChanged(
@@ -79,7 +68,7 @@
     if (parameterChanges.isEmpty()) {
       if (prototypeChanges.hasExtraParameters()) {
         return new ConcreteCallSiteOptimizationInfo(
-            size + prototypeChanges.numberOfExtraParameters(), dynamicUpperBoundTypes, constants);
+            size + prototypeChanges.numberOfExtraParameters(), dynamicTypes, constants);
       }
       return this;
     }
@@ -94,7 +83,7 @@
 
     Int2ReferenceMap<AbstractValue> rewrittenConstants =
         new Int2ReferenceArrayMap<>(newSizeAfterParameterRemoval);
-    Int2ReferenceMap<TypeElement> rewrittenDynamicUpperBoundTypes =
+    Int2ReferenceMap<DynamicType> rewrittenDynamicTypes =
         new Int2ReferenceArrayMap<>(newSizeAfterParameterRemoval);
     for (int parameterIndex = 0, rewrittenParameterIndex = 0;
         parameterIndex < size;
@@ -105,107 +94,23 @@
         if (!abstractValue.isUnknown()) {
           rewrittenConstants.put(rewrittenParameterIndex, abstractValue);
         }
-        TypeElement dynamicUpperBoundType = dynamicUpperBoundTypes.get(parameterIndex);
-        if (dynamicUpperBoundType != null) {
-          rewrittenDynamicUpperBoundTypes.put(rewrittenParameterIndex, dynamicUpperBoundType);
+        DynamicType dynamicType = dynamicTypes.get(parameterIndex);
+        if (dynamicType != null) {
+          rewrittenDynamicTypes.put(rewrittenParameterIndex, dynamicType);
         }
         rewrittenParameterIndex++;
       }
     }
     return ConcreteCallSiteOptimizationInfo.create(
         newSizeAfterParameterRemoval + prototypeChanges.numberOfExtraParameters(),
-        rewrittenDynamicUpperBoundTypes,
+        rewrittenDynamicTypes,
         rewrittenConstants);
   }
 
-  CallSiteOptimizationInfo join(
-      ConcreteCallSiteOptimizationInfo other, AppView<?> appView, DexEncodedMethod method) {
-    assert size == other.size;
-    assert size == method.getNumberOfArguments();
-    ConcreteCallSiteOptimizationInfo result = new ConcreteCallSiteOptimizationInfo(size);
-    for (int i = 0; i < result.size; i++) {
-      AbstractValue abstractValue =
-          getAbstractArgumentValue(i)
-              .join(
-                  other.getAbstractArgumentValue(i),
-                  appView.abstractValueFactory(),
-                  method.getArgumentType(i));
-      if (abstractValue.isNonTrivial()) {
-        result.constants.put(i, abstractValue);
-      }
-
-      TypeElement thisUpperBoundType = getDynamicUpperBoundType(i);
-      if (thisUpperBoundType == null) {
-        // This means the corresponding argument is primitive. The counterpart should be too.
-        assert other.getDynamicUpperBoundType(i) == null;
-        continue;
-      }
-      assert thisUpperBoundType.isReferenceType();
-      TypeElement otherUpperBoundType = other.getDynamicUpperBoundType(i);
-      assert otherUpperBoundType != null && otherUpperBoundType.isReferenceType();
-      result.dynamicUpperBoundTypes.put(
-          i, thisUpperBoundType.join(otherUpperBoundType, appView));
-    }
-    if (result.hasUsefulOptimizationInfo(appView, method)) {
-      return result;
-    }
-    // As soon as we know the argument collection so far does not have any useful optimization info,
-    // move to TOP so that further collection can be simply skipped.
-    return top();
-  }
-
-  private TypeElement[] getStaticTypes(AppView<?> appView, DexEncodedMethod method) {
-    int argOffset = method.getFirstNonReceiverArgumentIndex();
-    int size = method.getReference().getArity() + argOffset;
-    TypeElement[] staticTypes = new TypeElement[size];
-    if (!method.isStatic()) {
-      staticTypes[0] =
-          TypeElement.fromDexType(method.getHolderType(), definitelyNotNull(), appView);
-    }
-    for (int i = 0; i < method.getReference().getArity(); i++) {
-      staticTypes[i + argOffset] =
-          TypeElement.fromDexType(method.getParameter(i), maybeNull(), appView);
-    }
-    return staticTypes;
-  }
-
   @Override
-  public boolean hasUsefulOptimizationInfo(AppView<?> appView, DexEncodedMethod method) {
-    TypeElement[] staticTypes = getStaticTypes(appView, method);
-    for (int i = 0; i < size; i++) {
-      AbstractValue abstractValue = getAbstractArgumentValue(i);
-      if (abstractValue.isNonTrivial()) {
-        return true;
-      }
-
-      if (!staticTypes[i].isReferenceType()) {
-        continue;
-      }
-      TypeElement dynamicUpperBoundType = getDynamicUpperBoundType(i);
-      if (dynamicUpperBoundType == null) {
-        continue;
-      }
-      // To avoid the full join of type lattices below, separately check if the nullability of
-      // arguments is improved, and if so, we can eagerly conclude that we've collected useful
-      // call site information for this method.
-      Nullability nullability = dynamicUpperBoundType.nullability();
-      if (nullability.isDefinitelyNull()) {
-        return true;
-      }
-      // TODO(b/139246447): Similar to nullability, if dynamic lower bound type is available,
-      //   we stop here and regard that call sites of this method have useful info.
-      // In general, though, we're looking for (strictly) better dynamic types for arguments.
-      if (dynamicUpperBoundType.strictlyLessThan(staticTypes[i], appView)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @Override
-  public TypeElement getDynamicUpperBoundType(int argIndex) {
+  public DynamicType getDynamicType(int argIndex) {
     assert 0 <= argIndex && argIndex < size;
-    return dynamicUpperBoundTypes.getOrDefault(argIndex, null);
+    return dynamicTypes.getOrDefault(argIndex, DynamicType.unknown());
   }
 
   @Override
@@ -214,47 +119,6 @@
     return constants.getOrDefault(argIndex, UnknownValue.getInstance());
   }
 
-  public static CallSiteOptimizationInfo fromArguments(
-      AppView<AppInfoWithLiveness> appView,
-      DexMethod invokedMethod,
-      List<Value> arguments,
-      ProgramMethod context) {
-    ConcreteCallSiteOptimizationInfo newCallSiteInfo =
-        new ConcreteCallSiteOptimizationInfo(arguments.size());
-    boolean hasReceiver = arguments.size() > invokedMethod.getArity();
-    boolean isTop = true;
-    for (int i = 0; i < newCallSiteInfo.size; i++) {
-      Value arg = arguments.get(i);
-
-      // Constant propagation.
-        Value aliasedValue = arg.getAliasedValue();
-        if (!aliasedValue.isPhi()) {
-          AbstractValue abstractValue = aliasedValue.definition.getAbstractValue(appView, context);
-          if (abstractValue.isNonTrivial()) {
-            newCallSiteInfo.constants.put(i, abstractValue);
-            isTop = false;
-          }
-      }
-
-      // Type propagation.
-      if (arg.getType().isReferenceType()) {
-        TypeElement staticType =
-            TypeElement.fromDexType(
-                hasReceiver ? invokedMethod.holder : invokedMethod.proto.getParameter(i),
-                maybeNull(),
-                appView);
-        TypeElement dynamicUpperBoundType = arg.getDynamicUpperBoundType(appView);
-        if (dynamicUpperBoundType != staticType) {
-          newCallSiteInfo.dynamicUpperBoundTypes.put(i, dynamicUpperBoundType);
-          isTop = false;
-        } else {
-          newCallSiteInfo.dynamicUpperBoundTypes.put(i, staticType);
-        }
-      }
-    }
-    return isTop ? CallSiteOptimizationInfo.top() : newCallSiteInfo;
-  }
-
   public static CallSiteOptimizationInfo fromMethodState(
       AppView<AppInfoWithLiveness> appView,
       ProgramMethod method,
@@ -280,7 +144,7 @@
       // Type propagation.
       DexType staticType = method.getDefinition().getArgumentType(argumentIndex);
       if (staticType.isReferenceType()) {
-        TypeElement staticTypeElement = staticType.toTypeElement(appView);
+        DynamicTypeWithUpperBound staticTypeElement = staticType.toDynamicType(appView);
         if (staticType.isArrayType()) {
           Nullability nullability = concreteParameterState.asArrayParameter().getNullability();
           if (nullability.isDefinitelyNull()) {
@@ -288,8 +152,8 @@
                   argumentIndex, appView.abstractValueFactory().createNullValue());
             isTop = false;
           } else if (nullability.isDefinitelyNotNull()) {
-            newCallSiteInfo.dynamicUpperBoundTypes.put(
-                argumentIndex, staticTypeElement.asArrayType().asDefinitelyNotNull());
+            newCallSiteInfo.dynamicTypes.put(
+                argumentIndex, staticTypeElement.withNullability(Nullability.definitelyNotNull()));
             isTop = false;
           } else {
             // The nullability should never be unknown, since we should use the unknown method state
@@ -300,8 +164,7 @@
         } else if (staticType.isClassType()) {
           DynamicType dynamicType = concreteParameterState.asReferenceParameter().getDynamicType();
           if (!dynamicType.isUnknown()) {
-            newCallSiteInfo.dynamicUpperBoundTypes.put(
-                argumentIndex, dynamicType.getDynamicUpperBoundType());
+            newCallSiteInfo.dynamicTypes.put(argumentIndex, dynamicType);
             isTop = false;
           }
         }
@@ -326,18 +189,17 @@
       return false;
     }
     ConcreteCallSiteOptimizationInfo otherInfo = (ConcreteCallSiteOptimizationInfo) other;
-    return dynamicUpperBoundTypes.equals(otherInfo.dynamicUpperBoundTypes)
-        && constants.equals(otherInfo.constants);
+    return dynamicTypes.equals(otherInfo.dynamicTypes) && constants.equals(otherInfo.constants);
   }
 
   @Override
   public int hashCode() {
-    return System.identityHashCode(dynamicUpperBoundTypes) * 7 + System.identityHashCode(constants);
+    return System.identityHashCode(dynamicTypes) * 7 + System.identityHashCode(constants);
   }
 
   @Override
   public String toString() {
-    return dynamicUpperBoundTypes.toString()
+    return dynamicTypes.toString()
         + (constants == null ? "" : (System.lineSeparator() + constants));
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java
index c790a02..2e3d1ce 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java
@@ -4,8 +4,7 @@
 
 package com.android.tools.r8.ir.optimize.info;
 
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
 
@@ -35,13 +34,8 @@
   }
 
   @Override
-  public ClassTypeElement getDynamicLowerBoundType() {
-    return null;
-  }
-
-  @Override
-  public TypeElement getDynamicUpperBoundType() {
-    return null;
+  public DynamicType getDynamicType() {
+    return DynamicType.unknown();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
index 7bc6c1c..1ce6568 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
@@ -7,8 +7,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.inlining.NeverSimpleInliningConstraint;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
 import com.android.tools.r8.ir.code.InvokeDirect;
@@ -32,8 +31,6 @@
   static int UNKNOWN_RETURNED_ARGUMENT = -1;
   static boolean UNKNOWN_NEVER_RETURNS_NORMALLY = false;
   static AbstractValue UNKNOWN_ABSTRACT_RETURN_VALUE = UnknownValue.getInstance();
-  static TypeElement UNKNOWN_TYPE = null;
-  static ClassTypeElement UNKNOWN_CLASS_TYPE = null;
   static boolean UNKNOWN_CHECKS_NULL_RECEIVER_BEFORE_ANY_SIDE_EFFECT = false;
   static boolean UNKNOWN_TRIGGERS_CLASS_INIT_BEFORE_ANY_SIDE_EFFECT = false;
   static boolean UNKNOWN_INITIALIZER_ENABLING_JAVA_ASSERTIONS = false;
@@ -74,13 +71,8 @@
   }
 
   @Override
-  public TypeElement getDynamicUpperBoundType() {
-    return UNKNOWN_TYPE;
-  }
-
-  @Override
-  public ClassTypeElement getDynamicLowerBoundType() {
-    return UNKNOWN_CLASS_TYPE;
+  public DynamicType getDynamicType() {
+    return DynamicType.unknown();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java
index 8f42838..6493a7d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java
@@ -4,13 +4,8 @@
 
 package com.android.tools.r8.ir.optimize.info;
 
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
 
 public abstract class FieldOptimizationInfo
     implements MemberOptimizationInfo<MutableFieldOptimizationInfo> {
@@ -25,32 +20,7 @@
    */
   public abstract int getReadBits();
 
-  public abstract ClassTypeElement getDynamicLowerBoundType();
-
-  public abstract TypeElement getDynamicUpperBoundType();
-
-  public ClassTypeElement getExactClassType(AppView<AppInfoWithLiveness> appView) {
-    ClassTypeElement dynamicLowerBoundType = getDynamicLowerBoundType();
-    TypeElement dynamicUpperBoundType = getDynamicUpperBoundType();
-    if (dynamicUpperBoundType == null || !dynamicUpperBoundType.isClassType()) {
-      return null;
-    }
-    DexType upperType = dynamicUpperBoundType.asClassType().getClassType();
-    if (dynamicLowerBoundType != null && upperType == dynamicLowerBoundType.getClassType()) {
-      return dynamicLowerBoundType;
-    }
-    DexClass upperClass = appView.definitionFor(upperType);
-    if (upperClass != null && upperClass.isEffectivelyFinal(appView)) {
-      assert dynamicLowerBoundType == null;
-      return ClassTypeElement.create(upperType, dynamicUpperBoundType.nullability(), appView);
-    }
-    return null;
-  }
-
-  public final TypeElement getDynamicUpperBoundTypeOrElse(TypeElement orElse) {
-    TypeElement dynamicUpperBoundType = getDynamicUpperBoundType();
-    return dynamicUpperBoundType != null ? dynamicUpperBoundType : orElse;
-  }
+  public abstract DynamicType getDynamicType();
 
   public abstract boolean isDead();
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
index 3de6a7a..b2d7be0 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
@@ -6,8 +6,7 @@
 
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.InvokeMethod;
@@ -38,14 +37,7 @@
 
   public abstract EnumUnboxerMethodClassification getEnumUnboxerMethodClassification();
 
-  public abstract TypeElement getDynamicUpperBoundType();
-
-  public final TypeElement getDynamicUpperBoundTypeOrElse(TypeElement orElse) {
-    TypeElement dynamicUpperBoundType = getDynamicUpperBoundType();
-    return dynamicUpperBoundType != null ? dynamicUpperBoundType : orElse;
-  }
-
-  public abstract ClassTypeElement getDynamicLowerBoundType();
+  public abstract DynamicType getDynamicType();
 
   public final boolean hasNonNullParamOrThrow() {
     return getNonNullParamOrThrow() != null;
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 d994add..a0c4eb2 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
@@ -61,9 +61,8 @@
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraintAnalysis;
 import com.android.tools.r8.ir.analysis.sideeffect.ClassInitializerSideEffectAnalysis;
 import com.android.tools.r8.ir.analysis.sideeffect.ClassInitializerSideEffectAnalysis.ClassInitializerSideEffect;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.Nullability;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.StatefulObjectValue;
 import com.android.tools.r8.ir.analysis.value.objectstate.ObjectState;
@@ -151,7 +150,7 @@
     }
     computeEnumUnboxerMethodClassification(method, code, feedback, methodProcessor, timing);
     computeSimpleInliningConstraint(method, code, feedback, timing);
-    computeDynamicReturnType(dynamicTypeOptimization, feedback, definition, code, timing);
+    computeDynamicReturnType(dynamicTypeOptimization, feedback, method, code, timing);
     if (options.enableInitializedClassesAnalysis) {
       computeInitializedClassesOnNormalExit(feedback, definition, code, timing);
     }
@@ -874,7 +873,7 @@
   private void computeDynamicReturnType(
       DynamicTypeOptimization dynamicTypeOptimization,
       OptimizationFeedback feedback,
-      DexEncodedMethod method,
+      ProgramMethod method,
       IRCode code,
       Timing timing) {
     timing.begin("Compute dynamic return type");
@@ -885,46 +884,39 @@
   private void computeDynamicReturnType(
       DynamicTypeOptimization dynamicTypeOptimization,
       OptimizationFeedback feedback,
-      DexEncodedMethod method,
+      ProgramMethod method,
       IRCode code) {
-    if (dynamicTypeOptimization != null) {
-      DexType staticReturnTypeRaw = method.getReference().proto.returnType;
-      if (!staticReturnTypeRaw.isReferenceType()) {
-        return;
-      }
-      TypeElement dynamicUpperBoundReturnType =
-          dynamicTypeOptimization.computeDynamicReturnType(method, code);
-      if (dynamicUpperBoundReturnType != null) {
-        if (dynamicUpperBoundReturnType.isReferenceType()
-            && dynamicUpperBoundReturnType.isDefinitelyNull()) {
-          feedback.methodReturnsAbstractValue(
-              method, appView, appView.abstractValueFactory().createSingleNumberValue(0));
-          feedback.methodReturnsObjectWithUpperBoundType(method, appView, TypeElement.getNull());
-        } else {
-          TypeElement staticReturnType =
-              TypeElement.fromDexType(staticReturnTypeRaw, Nullability.maybeNull(), appView);
-          // If the dynamic return type is not more precise than the static return type there is no
-          // need to record it.
-          if (dynamicUpperBoundReturnType.strictlyLessThan(staticReturnType, appView)) {
-            feedback.methodReturnsObjectWithUpperBoundType(
-                method, appView, dynamicUpperBoundReturnType);
-          }
-        }
-      }
+    if (dynamicTypeOptimization == null) {
+      return;
+    }
+    if (!method.getReturnType().isReferenceType()) {
+      return;
+    }
 
-      if (dynamicUpperBoundReturnType != null && dynamicUpperBoundReturnType.isNullType()) {
-        return;
-      }
+    DynamicType dynamicReturnType = dynamicTypeOptimization.computeDynamicReturnType(method, code);
+    if (dynamicReturnType.isBottom() || dynamicReturnType.isUnknown()) {
+      return;
+    }
 
-      ClassTypeElement dynamicLowerBoundReturnType =
-          dynamicTypeOptimization.computeDynamicLowerBoundType(method, code);
-      if (dynamicLowerBoundReturnType != null) {
-        assert dynamicUpperBoundReturnType == null
-            || dynamicUpperBoundReturnType
-                .nullability()
-                .lessThanOrEqual(dynamicLowerBoundReturnType.nullability());
-        feedback.methodReturnsObjectWithLowerBoundType(method, dynamicLowerBoundReturnType);
-      }
+    if (dynamicReturnType.isNullType()) {
+      feedback.methodReturnsAbstractValue(
+          method.getDefinition(), appView, appView.abstractValueFactory().createNullValue());
+      feedback.setDynamicReturnType(method, appView, dynamicReturnType);
+      return;
+    }
+
+    if (dynamicReturnType.isNotNullType()) {
+      feedback.setDynamicReturnType(method, appView, dynamicReturnType);
+      return;
+    }
+
+    // If the dynamic return type is not more precise than the static return type there is no
+    // need to record it.
+    DynamicTypeWithUpperBound staticReturnType = method.getReturnType().toDynamicType(appView);
+    if (dynamicReturnType
+        .asDynamicTypeWithUpperBound()
+        .strictlyLessThan(staticReturnType, appView)) {
+      feedback.setDynamicReturnType(method, appView, dynamicReturnType);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
index 9150ea0..c03d170 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
@@ -6,12 +6,10 @@
 
 import static java.util.Collections.emptySet;
 
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -34,38 +32,25 @@
   private AbstractValue abstractValue = UnknownValue.getInstance();
   private int flags;
   private int readBits = 0;
-  private ClassTypeElement dynamicLowerBoundType = null;
-  private TypeElement dynamicUpperBoundType = null;
+  private DynamicType dynamicType = DynamicType.unknown();
 
   public MutableFieldOptimizationInfo fixupClassTypeReferences(
-      AppView<? extends AppInfoWithClassHierarchy> appView, GraphLens lens) {
+      AppView<AppInfoWithLiveness> appView, GraphLens lens) {
     return fixupClassTypeReferences(appView, lens, emptySet());
   }
 
   public MutableFieldOptimizationInfo fixupClassTypeReferences(
-      AppView<? extends AppInfoWithClassHierarchy> appView,
-      GraphLens lens,
-      Set<DexType> prunedTypes) {
-    if (dynamicUpperBoundType != null) {
-      dynamicUpperBoundType = dynamicUpperBoundType.rewrittenWithLens(appView, lens, prunedTypes);
-    }
-    if (dynamicLowerBoundType != null) {
-      TypeElement dynamicLowerBoundType =
-          this.dynamicLowerBoundType.rewrittenWithLens(appView, lens);
-      if (dynamicLowerBoundType.isClassType()) {
-        this.dynamicLowerBoundType = dynamicLowerBoundType.asClassType();
-      } else {
-        assert dynamicLowerBoundType.isPrimitiveType();
-        this.dynamicLowerBoundType = null;
-        this.dynamicUpperBoundType = null;
-      }
-    }
+      AppView<AppInfoWithLiveness> appView, GraphLens lens, Set<DexType> prunedTypes) {
+    dynamicType = dynamicType.rewrittenWithLens(appView, lens, prunedTypes);
     return this;
   }
 
   public MutableFieldOptimizationInfo mutableCopy() {
     MutableFieldOptimizationInfo copy = new MutableFieldOptimizationInfo();
+    copy.abstractValue = abstractValue;
     copy.flags = flags;
+    copy.readBits = readBits;
+    copy.dynamicType = dynamicType;
     return copy;
   }
 
@@ -75,11 +60,12 @@
   }
 
   void setAbstractValue(AbstractValue abstractValue) {
+    assert getAbstractValue().isUnknown() || abstractValue.isNonTrivial();
     this.abstractValue = abstractValue;
   }
 
   public void fixupAbstractValue(AppView<AppInfoWithLiveness> appView, GraphLens lens) {
-    abstractValue = abstractValue.rewrittenWithLens(appView, lens);
+    setAbstractValue(abstractValue.rewrittenWithLens(appView, lens));
   }
 
   @Override
@@ -101,21 +87,12 @@
   }
 
   @Override
-  public ClassTypeElement getDynamicLowerBoundType() {
-    return dynamicLowerBoundType;
+  public DynamicType getDynamicType() {
+    return dynamicType;
   }
 
-  void setDynamicLowerBoundType(ClassTypeElement type) {
-    dynamicLowerBoundType = type;
-  }
-
-  @Override
-  public TypeElement getDynamicUpperBoundType() {
-    return dynamicUpperBoundType;
-  }
-
-  void setDynamicUpperBoundType(TypeElement type) {
-    dynamicUpperBoundType = type;
+  void setDynamicType(DynamicType dynamicType) {
+    this.dynamicType = dynamicType;
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java
index 7bda54d..968cc66 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableMethodOptimizationInfo.java
@@ -6,14 +6,14 @@
 
 import static java.util.Collections.emptySet;
 
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.ir.analysis.inlining.NeverSimpleInliningConstraint;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
@@ -45,9 +45,7 @@
       ClassInlinerMethodConstraint.alwaysFalse();
   private EnumUnboxerMethodClassification enumUnboxerMethodClassification =
       EnumUnboxerMethodClassification.unknown();
-  private TypeElement returnsObjectWithUpperBoundType = DefaultMethodOptimizationInfo.UNKNOWN_TYPE;
-  private ClassTypeElement returnsObjectWithLowerBoundType =
-      DefaultMethodOptimizationInfo.UNKNOWN_CLASS_TYPE;
+  private DynamicType dynamicType = DynamicType.unknown();
   private InlinePreference inlining = InlinePreference.Default;
   // Stores information about instance methods and constructors for
   // class inliner, null value indicates that the method is not eligible.
@@ -150,8 +148,7 @@
     initializedClassesOnNormalExit = template.initializedClassesOnNormalExit;
     returnedArgument = template.returnedArgument;
     abstractReturnValue = template.abstractReturnValue;
-    returnsObjectWithUpperBoundType = template.returnsObjectWithUpperBoundType;
-    returnsObjectWithLowerBoundType = template.returnsObjectWithLowerBoundType;
+    dynamicType = template.dynamicType;
     inlining = template.inlining;
     simpleInliningConstraint = template.simpleInliningConstraint;
     bridgeInfo = template.bridgeInfo;
@@ -177,29 +174,13 @@
   }
 
   public MutableMethodOptimizationInfo fixupClassTypeReferences(
-      AppView<? extends AppInfoWithClassHierarchy> appView, GraphLens lens) {
+      AppView<AppInfoWithLiveness> appView, GraphLens lens) {
     return fixupClassTypeReferences(appView, lens, emptySet());
   }
 
   public MutableMethodOptimizationInfo fixupClassTypeReferences(
-      AppView<? extends AppInfoWithClassHierarchy> appView,
-      GraphLens lens,
-      Set<DexType> prunedTypes) {
-    if (returnsObjectWithUpperBoundType != null) {
-      returnsObjectWithUpperBoundType =
-          returnsObjectWithUpperBoundType.rewrittenWithLens(appView, lens, prunedTypes);
-    }
-    if (returnsObjectWithLowerBoundType != null) {
-      TypeElement returnsObjectWithLowerBoundType =
-          this.returnsObjectWithLowerBoundType.rewrittenWithLens(appView, lens, prunedTypes);
-      if (returnsObjectWithLowerBoundType.isClassType()) {
-        this.returnsObjectWithLowerBoundType = returnsObjectWithLowerBoundType.asClassType();
-      } else {
-        assert returnsObjectWithLowerBoundType.isPrimitiveType();
-        this.returnsObjectWithUpperBoundType = DefaultMethodOptimizationInfo.UNKNOWN_TYPE;
-        this.returnsObjectWithLowerBoundType = DefaultMethodOptimizationInfo.UNKNOWN_CLASS_TYPE;
-      }
-    }
+      AppView<AppInfoWithLiveness> appView, GraphLens lens, Set<DexType> prunedTypes) {
+    dynamicType = dynamicType.rewrittenWithLens(appView, lens, prunedTypes);
     return this;
   }
 
@@ -321,13 +302,8 @@
   }
 
   @Override
-  public TypeElement getDynamicUpperBoundType() {
-    return returnsObjectWithUpperBoundType;
-  }
-
-  @Override
-  public ClassTypeElement getDynamicLowerBoundType() {
-    return returnsObjectWithLowerBoundType;
+  public DynamicType getDynamicType() {
+    return dynamicType;
   }
 
   @Override
@@ -626,8 +602,8 @@
     abstractReturnValue = UnknownValue.getInstance();
   }
 
-  void markReturnsObjectWithUpperBoundType(AppView<?> appView, TypeElement type) {
-    assert type != null;
+  void setDynamicType(AppView<?> appView, DynamicType newDynamicType, DexEncodedMethod method) {
+    assert newDynamicType != null;
     // We may get more precise type information if the method is reprocessed (e.g., due to
     // optimization info collected from all call sites), and hence the
     // `returnsObjectWithUpperBoundType` is allowed to become more precise.
@@ -635,31 +611,30 @@
     // Nullability could be less precise, though. For example, suppose a value is known to be
     // non-null after a safe invocation, hence recorded with the non-null variant. If that call is
     // inlined and the method is reprocessed, such non-null assumption cannot be made again.
-    assert returnsObjectWithUpperBoundType == DefaultMethodOptimizationInfo.UNKNOWN_TYPE
-            || type.lessThanOrEqualUpToNullability(returnsObjectWithUpperBoundType, appView)
-        : "upper bound type changed from " + returnsObjectWithUpperBoundType + " to " + type;
-    returnsObjectWithUpperBoundType = type;
-    if (type.isNullType()) {
-      returnsObjectWithLowerBoundType = null;
+    assert verifyDynamicType(appView, newDynamicType, method);
+    dynamicType = newDynamicType;
+  }
+
+  private boolean verifyDynamicType(
+      AppView<?> appView, DynamicType newDynamicType, DexEncodedMethod method) {
+    if (appView.enableWholeProgramOptimizations()) {
+      TypeElement staticReturnType = method.getReturnType().toTypeElement(appView);
+      TypeElement previousDynamicUpperBoundType =
+          dynamicType.getDynamicUpperBoundType(staticReturnType);
+      TypeElement newDynamicUpperBoundType =
+          newDynamicType.getDynamicUpperBoundType(staticReturnType);
+      assert newDynamicUpperBoundType.lessThanOrEqualUpToNullability(
+              previousDynamicUpperBoundType, appView)
+          : "upper bound type changed from "
+              + previousDynamicUpperBoundType
+              + " to "
+              + newDynamicUpperBoundType;
     }
+    return true;
   }
 
-  void unsetDynamicUpperBoundReturnType() {
-    returnsObjectWithUpperBoundType = null;
-  }
-
-  void markReturnsObjectWithLowerBoundType(ClassTypeElement type) {
-    assert type != null;
-    // Currently, we only have a lower bound type when we have _exact_ runtime type information.
-    // Thus, the type should never become more precise (although the nullability could).
-    assert returnsObjectWithLowerBoundType == DefaultMethodOptimizationInfo.UNKNOWN_CLASS_TYPE
-            || type.equalUpToNullability(returnsObjectWithLowerBoundType)
-        : "lower bound type changed from " + returnsObjectWithLowerBoundType + " to " + type;
-    returnsObjectWithLowerBoundType = type;
-  }
-
-  void unsetDynamicLowerBoundReturnType() {
-    returnsObjectWithLowerBoundType = null;
+  void unsetDynamicType() {
+    dynamicType = DynamicType.unknown();
   }
 
   // TODO(b/140214568): Should be package-private.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
index 23bedd0..5e9386c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
@@ -8,10 +8,10 @@
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.classinliner.constraint.ClassInlinerMethodConstraint;
@@ -41,6 +41,10 @@
       new IdentityHashMap<>();
   private final Map<DexEncodedMethod, ConstraintWithTarget> processed = new IdentityHashMap<>();
 
+  private MutableFieldOptimizationInfo getFieldOptimizationInfoForUpdating(ProgramField field) {
+    return getFieldOptimizationInfoForUpdating(field.getDefinition());
+  }
+
   private synchronized MutableFieldOptimizationInfo getFieldOptimizationInfoForUpdating(
       DexEncodedField field) {
     MutableFieldOptimizationInfo info = fieldOptimizationInfos.get(field);
@@ -133,13 +137,8 @@
   }
 
   @Override
-  public void markFieldHasDynamicLowerBoundType(DexEncodedField field, ClassTypeElement type) {
-    getFieldOptimizationInfoForUpdating(field).setDynamicLowerBoundType(type);
-  }
-
-  @Override
-  public void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeElement type) {
-    getFieldOptimizationInfoForUpdating(field).setDynamicUpperBoundType(type);
+  public void markFieldHasDynamicType(DexEncodedField field, DynamicType dynamicType) {
+    getFieldOptimizationInfoForUpdating(field).setDynamicType(dynamicType);
   }
 
   @Override
@@ -199,15 +198,9 @@
   }
 
   @Override
-  public synchronized void methodReturnsObjectWithUpperBoundType(
-      DexEncodedMethod method, AppView<?> appView, TypeElement type) {
-    getMethodOptimizationInfoForUpdating(method).markReturnsObjectWithUpperBoundType(appView, type);
-  }
-
-  @Override
-  public synchronized void methodReturnsObjectWithLowerBoundType(
-      DexEncodedMethod method, ClassTypeElement type) {
-    getMethodOptimizationInfoForUpdating(method).markReturnsObjectWithLowerBoundType(type);
+  public synchronized void setDynamicReturnType(
+      DexEncodedMethod method, AppView<?> appView, DynamicType dynamicType) {
+    getMethodOptimizationInfoForUpdating(method).setDynamicType(appView, dynamicType, method);
   }
 
   @Override
@@ -333,13 +326,8 @@
   }
 
   @Override
-  public synchronized void unsetDynamicLowerBoundReturnType(ProgramMethod method) {
-    getMethodOptimizationInfoForUpdating(method).unsetDynamicLowerBoundReturnType();
-  }
-
-  @Override
-  public synchronized void unsetDynamicUpperBoundReturnType(ProgramMethod method) {
-    getMethodOptimizationInfoForUpdating(method).unsetDynamicUpperBoundReturnType();
+  public synchronized void unsetDynamicReturnType(ProgramMethod method) {
+    getMethodOptimizationInfoForUpdating(method).unsetDynamicType();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
index 3bcd3fc..fd6d27e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
@@ -10,8 +10,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.classinliner.constraint.ClassInlinerMethodConstraint;
@@ -44,10 +43,7 @@
   public void markFieldAsPropagated(DexEncodedField field) {}
 
   @Override
-  public void markFieldHasDynamicLowerBoundType(DexEncodedField field, ClassTypeElement type) {}
-
-  @Override
-  public void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeElement type) {}
+  public void markFieldHasDynamicType(DexEncodedField field, DynamicType dynamicType) {}
 
   @Override
   public void markFieldBitsRead(DexEncodedField field, int bitsRead) {}
@@ -79,12 +75,8 @@
       DexEncodedMethod method, AppView<AppInfoWithLiveness> appView, AbstractValue value) {}
 
   @Override
-  public void methodReturnsObjectWithUpperBoundType(
-      DexEncodedMethod method, AppView<?> appView, TypeElement type) {}
-
-  @Override
-  public void methodReturnsObjectWithLowerBoundType(
-      DexEncodedMethod method, ClassTypeElement type) {}
+  public void setDynamicReturnType(
+      DexEncodedMethod method, AppView<?> appView, DynamicType dynamicType) {}
 
   @Override
   public void methodMayNotHaveSideEffects(DexEncodedMethod method) {}
@@ -160,10 +152,7 @@
   public void unsetClassInlinerMethodConstraint(ProgramMethod method) {}
 
   @Override
-  public void unsetDynamicLowerBoundReturnType(ProgramMethod method) {}
-
-  @Override
-  public void unsetDynamicUpperBoundReturnType(ProgramMethod method) {}
+  public void unsetDynamicReturnType(ProgramMethod method) {}
 
   @Override
   public void unsetEnumUnboxerMethodClassification(ProgramMethod method) {}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index 40a6cdd..5fd4800 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -10,8 +10,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.classinliner.constraint.ClassInlinerMethodConstraint;
@@ -51,12 +50,7 @@
   }
 
   @Override
-  public void markFieldHasDynamicLowerBoundType(DexEncodedField field, ClassTypeElement type) {
-    // Ignored.
-  }
-
-  @Override
-  public void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeElement type) {
+  public void markFieldHasDynamicType(DexEncodedField field, DynamicType dynamicType) {
     // Ignored.
   }
 
@@ -108,15 +102,9 @@
   }
 
   @Override
-  public void methodReturnsObjectWithUpperBoundType(
-      DexEncodedMethod method, AppView<?> appView, TypeElement type) {
-    method.getMutableOptimizationInfo().markReturnsObjectWithUpperBoundType(appView, type);
-  }
-
-  @Override
-  public void methodReturnsObjectWithLowerBoundType(
-      DexEncodedMethod method, ClassTypeElement type) {
-    // Ignored.
+  public void setDynamicReturnType(
+      DexEncodedMethod method, AppView<?> appView, DynamicType dynamicType) {
+    method.getMutableOptimizationInfo().setDynamicType(appView, dynamicType, method);
   }
 
   @Override
@@ -250,15 +238,8 @@
   }
 
   @Override
-  public void unsetDynamicLowerBoundReturnType(ProgramMethod method) {
-    withMutableMethodOptimizationInfo(
-        method, MutableMethodOptimizationInfo::unsetDynamicLowerBoundReturnType);
-  }
-
-  @Override
-  public void unsetDynamicUpperBoundReturnType(ProgramMethod method) {
-    withMutableMethodOptimizationInfo(
-        method, MutableMethodOptimizationInfo::unsetDynamicUpperBoundReturnType);
+  public void unsetDynamicReturnType(ProgramMethod method) {
+    withMutableMethodOptimizationInfo(method, MutableMethodOptimizationInfo::unsetDynamicType);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/TopCallSiteOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/TopCallSiteOptimizationInfo.java
index 241b934..aa2ef1f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/TopCallSiteOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/TopCallSiteOptimizationInfo.java
@@ -13,9 +13,4 @@
   static TopCallSiteOptimizationInfo getInstance() {
     return INSTANCE;
   }
-
-  @Override
-  public boolean isTop() {
-    return true;
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/field/InstanceFieldInitializationInfoCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/info/field/InstanceFieldInitializationInfoCollection.java
index ef40285..c5d846e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/field/InstanceFieldInitializationInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/field/InstanceFieldInitializationInfoCollection.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.ir.optimize.info.field;
 
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClassAndField;
 import com.android.tools.r8.graph.DexDefinitionSupplier;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexField;
@@ -37,6 +38,10 @@
 
   public abstract InstanceFieldInitializationInfo get(DexEncodedField field);
 
+  public final InstanceFieldInitializationInfo get(DexClassAndField field) {
+    return get(field.getDefinition());
+  }
+
   public abstract boolean isEmpty();
 
   public abstract InstanceFieldInitializationInfoCollection fixupAfterParametersChanged(
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
index 167a528..ee5dc08 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
@@ -10,7 +10,7 @@
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.code.Assume;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.BasicBlockIterator;
@@ -19,6 +19,7 @@
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.Set;
 
 public class EnumMethodOptimizer extends StatelessLibraryMethodModelCollection {
@@ -43,14 +44,18 @@
       DexClassAndMethod singleTarget,
       Set<Value> affectedValues,
       Set<BasicBlock> blocksToRemove) {
-    if (singleTarget.getReference() == appView.dexItemFactory().enumMembers.valueOf
+    if (appView.hasLiveness()
+        && singleTarget.getReference() == appView.dexItemFactory().enumMembers.valueOf
         && invoke.inValues().get(0).isConstClass()) {
-      insertAssumeDynamicType(code, instructionIterator, invoke);
+      insertAssumeDynamicType(appView.withLiveness(), code, instructionIterator, invoke);
     }
   }
 
   private void insertAssumeDynamicType(
-      IRCode code, InstructionListIterator instructionIterator, InvokeMethod invoke) {
+      AppView<AppInfoWithLiveness> appView,
+      IRCode code,
+      InstructionListIterator instructionIterator,
+      InvokeMethod invoke) {
     // TODO(b/152516470): Support unboxing enums with Enum#valueOf in try-catch.
     if (invoke.getBlock().hasCatchHandlers()) {
       return;
@@ -62,8 +67,6 @@
         || enumClass.superType != appView.dexItemFactory().enumType) {
       return;
     }
-    TypeElement dynamicUpperBoundType =
-        TypeElement.fromDexType(enumType, definitelyNotNull(), appView);
     Value outValue = invoke.outValue();
     if (outValue == null) {
       return;
@@ -73,9 +76,10 @@
     outValue.replaceUsers(specializedOutValue);
 
     // Insert AssumeDynamicType instruction.
+    DynamicTypeWithUpperBound dynamicType = enumType.toDynamicType(appView, definitelyNotNull());
     Assume assumeInstruction =
         Assume.createAssumeDynamicTypeInstruction(
-            dynamicUpperBoundType, null, specializedOutValue, outValue, invoke, appView);
+            dynamicType, specializedOutValue, outValue, invoke, appView);
     assumeInstruction.setPosition(appView.options().debug ? invoke.getPosition() : Position.none());
     instructionIterator.add(assumeInstruction);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java
index ca99313..0b41d07 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryOptimizationInfoInitializer.java
@@ -4,8 +4,6 @@
 
 package com.android.tools.r8.ir.optimize.library;
 
-import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
-
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
@@ -14,7 +12,7 @@
 import com.android.tools.r8.graph.DexItemFactory.EnumMembers;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
 import com.android.tools.r8.ir.analysis.value.objectstate.ObjectState;
 import com.android.tools.r8.ir.optimize.info.LibraryOptimizationInfoInitializerFeedback;
@@ -128,16 +126,9 @@
     for (DexMethod method : dexItemFactory.libraryMethodsReturningNonNull) {
       DexEncodedMethod definition = lookupMethod(method);
       if (definition != null) {
-        TypeElement staticType =
-            TypeElement.fromDexType(method.proto.returnType, maybeNull(), appView);
-        feedback.methodReturnsObjectWithUpperBoundType(
-            definition,
-            appView,
-            definition
-                .getOptimizationInfo()
-                .getDynamicUpperBoundTypeOrElse(staticType)
-                .asReferenceType()
-                .asDefinitelyNotNull());
+        assert definition.getOptimizationInfo().getDynamicType().isUnknown()
+            || definition.getOptimizationInfo().getDynamicType().isNotNullType();
+        feedback.setDynamicReturnType(definition, appView, DynamicType.definitelyNotNull());
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClassInfo.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClassInfo.java
index 9e7d703..bd8696b 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClassInfo.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClassInfo.java
@@ -54,6 +54,7 @@
   private final int[] metadataVersion;
   private final String inlineClassUnderlyingPropertyName;
   private final KotlinTypeInfo inlineClassUnderlyingType;
+  private final int jvmFlags;
 
   // List of tracked assignments of kotlin metadata.
   private final KotlinMetadataMembersTracker originalMembersWithKotlinInfo;
@@ -77,7 +78,8 @@
       int[] metadataVersion,
       String inlineClassUnderlyingPropertyName,
       KotlinTypeInfo inlineClassUnderlyingType,
-      KotlinMetadataMembersTracker originalMembersWithKotlinInfo) {
+      KotlinMetadataMembersTracker originalMembersWithKotlinInfo,
+      int jvmFlags) {
     this.flags = flags;
     this.name = name;
     this.nameCanBeSynthesizedFromClassOrAnonymousObjectOrigin =
@@ -98,6 +100,7 @@
     this.inlineClassUnderlyingPropertyName = inlineClassUnderlyingPropertyName;
     this.inlineClassUnderlyingType = inlineClassUnderlyingType;
     this.originalMembersWithKotlinInfo = originalMembersWithKotlinInfo;
+    this.jvmFlags = jvmFlags;
   }
 
   public static KotlinClassInfo create(
@@ -180,7 +183,8 @@
         metadataVersion,
         kmClass.getInlineClassUnderlyingPropertyName(),
         KotlinTypeInfo.create(kmClass.getInlineClassUnderlyingType(), factory, reporter),
-        originalMembersWithKotlinInfo);
+        originalMembersWithKotlinInfo,
+        JvmExtensionsKt.getJvmFlags(kmClass));
   }
 
   private static KotlinTypeReference getAnonymousObjectOrigin(
@@ -371,6 +375,7 @@
     }
     JvmClassExtensionVisitor extensionVisitor =
         (JvmClassExtensionVisitor) kmClass.visitExtensions(JvmClassExtensionVisitor.TYPE);
+    extensionVisitor.visitJvmFlags(jvmFlags);
     extensionVisitor.visitModuleName(moduleName);
     if (anonymousObjectOrigin != null) {
       rewritten |=
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataWriter.java b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataWriter.java
index ee9ea2c..1e4d633 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataWriter.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataWriter.java
@@ -303,6 +303,7 @@
 
   public static void appendKmClass(String indent, StringBuilder sb, KmClass kmClass) {
     appendKeyValue(indent, "flags", sb, kmClass.getFlags() + "");
+    appendKeyValue(indent, "jvmFlags", sb, JvmExtensionsKt.getJvmFlags(kmClass) + "");
     appendKeyValue(indent, "name", sb, kmClass.getName());
     appendKeyValue(
         indent,
@@ -518,13 +519,22 @@
               "setterSignature",
               sb,
               setterSignature != null ? setterSignature.asString() : "null");
-          JvmMethodSignature syntheticMethod =
+          JvmMethodSignature syntheticMethodForAnnotations =
               JvmExtensionsKt.getSyntheticMethodForAnnotations(kmProperty);
           appendKeyValue(
               newIndent,
               "syntheticMethodForAnnotations",
               sb,
-              syntheticMethod != null ? syntheticMethod.asString() : "null");
+              syntheticMethodForAnnotations != null
+                  ? syntheticMethodForAnnotations.asString()
+                  : "null");
+          JvmMethodSignature syntheticMethodForDelegate =
+              JvmExtensionsKt.getSyntheticMethodForAnnotations(kmProperty);
+          appendKeyValue(
+              newIndent,
+              "syntheticMethodForDelegate",
+              sb,
+              syntheticMethodForDelegate != null ? syntheticMethodForDelegate.asString() : "null");
         });
   }
 
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinPropertyInfo.java b/src/main/java/com/android/tools/r8/kotlin/KotlinPropertyInfo.java
index 9d0597d..39ab90c 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinPropertyInfo.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinPropertyInfo.java
@@ -58,6 +58,8 @@
 
   private final KotlinJvmMethodSignatureInfo syntheticMethodForAnnotations;
 
+  private final KotlinJvmMethodSignatureInfo syntheticMethodForDelegate;
+
   private KotlinPropertyInfo(
       int flags,
       int getterFlags,
@@ -72,7 +74,8 @@
       KotlinJvmFieldSignatureInfo fieldSignature,
       KotlinJvmMethodSignatureInfo getterSignature,
       KotlinJvmMethodSignatureInfo setterSignature,
-      KotlinJvmMethodSignatureInfo syntheticMethodForAnnotations) {
+      KotlinJvmMethodSignatureInfo syntheticMethodForAnnotations,
+      KotlinJvmMethodSignatureInfo syntheticMethodForDelegate) {
     this.flags = flags;
     this.getterFlags = getterFlags;
     this.setterFlags = setterFlags;
@@ -87,6 +90,7 @@
     this.getterSignature = getterSignature;
     this.setterSignature = setterSignature;
     this.syntheticMethodForAnnotations = syntheticMethodForAnnotations;
+    this.syntheticMethodForDelegate = syntheticMethodForDelegate;
   }
 
   public static KotlinPropertyInfo create(
@@ -108,7 +112,9 @@
         KotlinJvmMethodSignatureInfo.create(
             JvmExtensionsKt.getSetterSignature(kmProperty), factory),
         KotlinJvmMethodSignatureInfo.create(
-            JvmExtensionsKt.getSyntheticMethodForAnnotations(kmProperty), factory));
+            JvmExtensionsKt.getSyntheticMethodForAnnotations(kmProperty), factory),
+        KotlinJvmMethodSignatureInfo.create(
+            JvmExtensionsKt.getSyntheticMethodForDelegate(kmProperty), factory));
   }
 
   @Override
@@ -187,6 +193,11 @@
             syntheticMethodForAnnotations.rewrite(
                 extensionVisitor::visitSyntheticMethodForAnnotations, null, appView, namingLens);
       }
+      if (syntheticMethodForDelegate != null) {
+        rewritten |=
+            syntheticMethodForDelegate.rewrite(
+                extensionVisitor::visitSyntheticMethodForDelegate, null, appView, namingLens);
+      }
     }
     return rewritten;
   }
@@ -215,5 +226,8 @@
     if (syntheticMethodForAnnotations != null) {
       syntheticMethodForAnnotations.trace(definitionSupplier);
     }
+    if (syntheticMethodForDelegate != null) {
+      syntheticMethodForDelegate.trace(definitionSupplier);
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java b/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java
index 62bf247..e17606f 100644
--- a/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java
+++ b/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java
@@ -137,7 +137,8 @@
     FieldRebindingIdentityLens.Builder builder = FieldRebindingIdentityLens.builder();
     nonReboundFieldReferenceToDefinitionMap.forEach(
         (nonReboundFieldReference, reboundFieldReference) -> {
-          DexField rewrittenReboundFieldReference = lens.lookupField(reboundFieldReference);
+          DexField rewrittenReboundFieldReference =
+              lens.getRenamedFieldSignature(reboundFieldReference);
           DexField rewrittenNonReboundFieldReference =
               rewrittenReboundFieldReference.withHolder(
                   lens.lookupType(nonReboundFieldReference.getHolderType()), dexItemFactory);
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorApplicationFixer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorApplicationFixer.java
index 890cb48..897aaa8 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorApplicationFixer.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorApplicationFixer.java
@@ -4,11 +4,24 @@
 
 package com.android.tools.r8.optimize.argumentpropagation;
 
+import static com.android.tools.r8.ir.optimize.info.OptimizationFeedback.getSimpleFeedback;
+
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
 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.MethodCollection;
+import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.graph.TreeFixerBase;
+import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfoFixer;
+import com.android.tools.r8.ir.optimize.info.MutableFieldOptimizationInfo;
+import com.android.tools.r8.ir.optimize.info.MutableMethodOptimizationInfo;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedback.OptimizationInfoFixer;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
@@ -20,13 +33,14 @@
  * Takes as input a mapping from old method signatures to new method signatures (with parameters
  * removed), and rewrites all method definitions in the application to their new method signatures.
  */
-public class ArgumentPropagatorApplicationFixer {
+public class ArgumentPropagatorApplicationFixer extends TreeFixerBase {
 
   private final AppView<AppInfoWithLiveness> appView;
   private final ArgumentPropagatorGraphLens graphLens;
 
   public ArgumentPropagatorApplicationFixer(
       AppView<AppInfoWithLiveness> appView, ArgumentPropagatorGraphLens graphLens) {
+    super(appView);
     this.appView = appView;
     this.graphLens = graphLens;
   }
@@ -47,12 +61,25 @@
     ThreadUtils.processItems(affectedClasses, this::fixupClass, executorService);
     timing.end();
 
+    // Fixup optimization info.
+    timing.time("Fixup optimization info", () -> fixupOptimizationInfos(executorService));
+
     timing.begin("Rewrite AppView");
     appView.rewriteWithLens(graphLens);
     timing.end();
   }
 
   private void fixupClass(DexProgramClass clazz) {
+    fixupFields(clazz);
+    fixupMethods(clazz);
+  }
+
+  private void fixupFields(DexProgramClass clazz) {
+    clazz.setInstanceFields(fixupFields(clazz.instanceFields()));
+    clazz.setStaticFields(fixupFields(clazz.staticFields()));
+  }
+
+  private void fixupMethods(DexProgramClass clazz) {
     MethodCollection methodCollection = clazz.getMethodCollection();
     methodCollection.replaceMethods(
         method -> {
@@ -68,11 +95,77 @@
               builder -> {
                 RewrittenPrototypeDescription prototypeChanges =
                     graphLens.getPrototypeChanges(methodReferenceAfterParameterRemoval);
-                builder
-                    .apply(prototypeChanges.createParameterAnnotationsRemover(method))
-                    .fixupOptimizationInfo(
-                        appView, prototypeChanges.createMethodOptimizationInfoFixer());
+                builder.apply(prototypeChanges.createParameterAnnotationsRemover(method));
               });
         });
   }
+
+  private void fixupOptimizationInfos(ExecutorService executorService) throws ExecutionException {
+    PrunedItems prunedItems = PrunedItems.empty(appView.app());
+    getSimpleFeedback()
+        .fixupOptimizationInfos(
+            appView,
+            executorService,
+            new OptimizationInfoFixer() {
+              @Override
+              public void fixup(
+                  DexEncodedField field, MutableFieldOptimizationInfo optimizationInfo) {
+                optimizationInfo.fixupAbstractValue(appView, graphLens);
+              }
+
+              @Override
+              public void fixup(
+                  DexEncodedMethod method, MutableMethodOptimizationInfo optimizationInfo) {
+                // Fixup the return value in case the method returns a field that had its signature
+                // changed.
+                optimizationInfo
+                    .fixupAbstractReturnValue(appView, graphLens)
+                    .fixupInstanceInitializerInfo(appView, graphLens, prunedItems);
+
+                // Rewrite the optimization info to account for method signature changes.
+                if (graphLens.hasPrototypeChanges(method.getReference())) {
+                  RewrittenPrototypeDescription prototypeChanges =
+                      graphLens.getPrototypeChanges(method.getReference());
+                  MethodOptimizationInfoFixer fixer =
+                      prototypeChanges.createMethodOptimizationInfoFixer();
+                  optimizationInfo.fixup(appView, fixer);
+                }
+              }
+            });
+  }
+
+  @Override
+  public DexField fixupFieldReference(DexField field) {
+    return graphLens.internalGetNextFieldSignature(field);
+  }
+
+  @Override
+  public DexMethod fixupMethodReference(DexMethod method) {
+    throw new Unreachable();
+  }
+
+  @Override
+  public DexType fixupType(DexType type) {
+    throw new Unreachable();
+  }
+
+  @Override
+  public DexType mapClassType(DexType type) {
+    return type;
+  }
+
+  @Override
+  public void recordFieldChange(DexField from, DexField to) {
+    // Intentionally empty.
+  }
+
+  @Override
+  public void recordMethodChange(DexMethod from, DexMethod to) {
+    // Intentionally empty.
+  }
+
+  @Override
+  public void recordClassChange(DexType from, DexType to) {
+    throw new Unreachable();
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
index 96e08b6..eef092d 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -285,11 +286,11 @@
       ProgramMethod resolvedMethod,
       ProgramMethod context,
       ConcretePolymorphicMethodStateOrBottom existingMethodState) {
-    DynamicType dynamicReceiverType = invoke.getReceiver().getDynamicType(appView);
+    DynamicTypeWithUpperBound dynamicReceiverType = invoke.getReceiver().getDynamicType(appView);
     assert !dynamicReceiverType.getDynamicUpperBoundType().nullability().isDefinitelyNull();
 
     ProgramMethod singleTarget = invoke.lookupSingleProgramTarget(appView, context);
-    DynamicType bounds =
+    DynamicTypeWithUpperBound bounds =
         computeBoundsForPolymorphicMethodState(
             invoke, resolvedMethod, singleTarget, context, dynamicReceiverType);
     MethodState existingMethodStateForBounds =
@@ -319,13 +320,13 @@
     return ConcretePolymorphicMethodState.create(bounds, methodStateForBounds);
   }
 
-  private DynamicType computeBoundsForPolymorphicMethodState(
+  private DynamicTypeWithUpperBound computeBoundsForPolymorphicMethodState(
       InvokeMethodWithReceiver invoke,
       ProgramMethod resolvedMethod,
       ProgramMethod singleTarget,
       ProgramMethod context,
-      DynamicType dynamicReceiverType) {
-    DynamicType bounds =
+      DynamicTypeWithUpperBound dynamicReceiverType) {
+    DynamicTypeWithUpperBound bounds =
         singleTarget != null
             ? DynamicType.createExact(
                 singleTarget.getHolderType().toTypeElement(appView).asClassType())
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java
index a0f67e0..3ed1334 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.optimize.argumentpropagation;
 
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.NestedGraphLens;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription;
@@ -14,6 +15,7 @@
 import com.android.tools.r8.utils.collections.MutableBidirectionalOneToOneMap;
 import java.util.IdentityHashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 
 public class ArgumentPropagatorGraphLens extends NestedGraphLens {
 
@@ -21,9 +23,10 @@
 
   ArgumentPropagatorGraphLens(
       AppView<AppInfoWithLiveness> appView,
+      BidirectionalOneToOneMap<DexField, DexField> fieldMap,
       BidirectionalOneToOneMap<DexMethod, DexMethod> methodMap,
       Map<DexMethod, RewrittenPrototypeDescription> prototypeChanges) {
-    super(appView, EMPTY_FIELD_MAP, methodMap, EMPTY_TYPE_MAP);
+    super(appView, fieldMap, methodMap, EMPTY_TYPE_MAP);
     this.prototypeChanges = prototypeChanges;
   }
 
@@ -31,12 +34,30 @@
     return new Builder(appView);
   }
 
+  public boolean hasPrototypeChanges(DexMethod method) {
+    return method != internalGetPreviousMethodSignature(method);
+  }
+
   public RewrittenPrototypeDescription getPrototypeChanges(DexMethod method) {
-    assert method != internalGetPreviousMethodSignature(method);
+    assert hasPrototypeChanges(method);
     return prototypeChanges.getOrDefault(method, RewrittenPrototypeDescription.none());
   }
 
   @Override
+  protected FieldLookupResult internalDescribeLookupField(FieldLookupResult previous) {
+    FieldLookupResult lookupResult = super.internalDescribeLookupField(previous);
+    if (lookupResult.getReference().getType() != previous.getReference().getType()) {
+      return FieldLookupResult.builder(this)
+          .setReboundReference(lookupResult.getReboundReference())
+          .setReference(lookupResult.getReference())
+          .setReadCastType(lookupResult.getReadCastType())
+          .setWriteCastType(lookupResult.getReference().getType())
+          .build();
+    }
+    return lookupResult;
+  }
+
+  @Override
   protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
       RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
     DexMethod previous = internalGetPreviousMethodSignature(method);
@@ -58,6 +79,11 @@
   }
 
   @Override
+  public DexField internalGetNextFieldSignature(DexField field) {
+    return super.internalGetNextFieldSignature(field);
+  }
+
+  @Override
   public DexMethod internalGetNextMethodSignature(DexMethod method) {
     return super.internalGetNextMethodSignature(method);
   }
@@ -65,6 +91,8 @@
   public static class Builder {
 
     private final AppView<AppInfoWithLiveness> appView;
+    private final MutableBidirectionalOneToOneMap<DexField, DexField> newFieldSignatures =
+        new BidirectionalOneToOneHashMap<>();
     private final MutableBidirectionalOneToOneMap<DexMethod, DexMethod> newMethodSignatures =
         new BidirectionalOneToOneHashMap<>();
     private final Map<DexMethod, RewrittenPrototypeDescription> prototypeChanges =
@@ -75,16 +103,23 @@
     }
 
     public boolean isEmpty() {
-      return newMethodSignatures.isEmpty();
+      return newFieldSignatures.isEmpty() && newMethodSignatures.isEmpty();
     }
 
     public ArgumentPropagatorGraphLens.Builder mergeDisjoint(
         ArgumentPropagatorGraphLens.Builder partialGraphLensBuilder) {
+      newFieldSignatures.putAll(partialGraphLensBuilder.newFieldSignatures);
       newMethodSignatures.putAll(partialGraphLensBuilder.newMethodSignatures);
       prototypeChanges.putAll(partialGraphLensBuilder.prototypeChanges);
       return this;
     }
 
+    public Builder recordMove(DexField from, DexField to) {
+      assert from != to;
+      newFieldSignatures.put(from, to);
+      return this;
+    }
+
     public Builder recordMove(
         DexMethod from, DexMethod to, RewrittenPrototypeDescription prototypeChangesForMethod) {
       assert from != to;
@@ -99,9 +134,26 @@
     }
 
     public ArgumentPropagatorGraphLens build() {
-      return isEmpty()
-          ? null
-          : new ArgumentPropagatorGraphLens(appView, newMethodSignatures, prototypeChanges);
+      if (isEmpty()) {
+        return null;
+      }
+      ArgumentPropagatorGraphLens argumentPropagatorGraphLens =
+          new ArgumentPropagatorGraphLens(
+              appView, newFieldSignatures, newMethodSignatures, prototypeChanges);
+      fixupPrototypeChangesAfterFieldSignatureChanges(argumentPropagatorGraphLens);
+      return argumentPropagatorGraphLens;
+    }
+
+    private void fixupPrototypeChangesAfterFieldSignatureChanges(
+        ArgumentPropagatorGraphLens argumentPropagatorGraphLens) {
+      for (Entry<DexMethod, RewrittenPrototypeDescription> entry : prototypeChanges.entrySet()) {
+        RewrittenPrototypeDescription prototypeChangesForMethod = entry.getValue();
+        RewrittenPrototypeDescription rewrittenPrototypeChangesForMethod =
+            prototypeChangesForMethod.rewrittenWithLens(appView, argumentPropagatorGraphLens);
+        if (rewrittenPrototypeChangesForMethod != prototypeChangesForMethod) {
+          entry.setValue(rewrittenPrototypeChangesForMethod);
+        }
+      }
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorIROptimizer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorIROptimizer.java
index 892c282..f92af83 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorIROptimizer.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorIROptimizer.java
@@ -5,8 +5,9 @@
 package com.android.tools.r8.optimize.argumentpropagation;
 
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.SingleValue;
 import com.android.tools.r8.ir.code.Argument;
@@ -75,16 +76,15 @@
       // TODO(b/190154391): This should also materialize dynamic lower bound information.
       // TODO(b/190154391) This should also materialize the nullability of array arguments.
       if (argumentValue.getType().isReferenceType()) {
-        TypeElement dynamicUpperBoundType =
-            optimizationInfo.getDynamicUpperBoundType(argument.getIndex());
-        if (dynamicUpperBoundType == null || dynamicUpperBoundType.isTop()) {
+        DynamicType dynamicType = optimizationInfo.getDynamicType(argument.getIndex());
+        if (dynamicType.isUnknown()) {
           continue;
         }
-        if (dynamicUpperBoundType.isBottom()) {
+        if (dynamicType.isBottom()) {
           assert false;
           continue;
         }
-        if (dynamicUpperBoundType.isDefinitelyNull()) {
+        if (dynamicType.getNullability().isDefinitelyNull()) {
           ConstNumber nullInstruction = code.createConstNull();
           nullInstruction.setPosition(argument.getPosition());
           affectedValues.addAll(argumentValue.affectedValues());
@@ -92,21 +92,36 @@
           instructionsToAdd.add(nullInstruction);
           continue;
         }
+        if (dynamicType.isNotNullType()) {
+          if (!argumentValue.getType().isDefinitelyNotNull()) {
+            Value nonNullValue =
+                code.createValue(argumentValue.getType().asReferenceType().asMeetWithNotNull());
+            argumentValue.replaceUsers(nonNullValue, affectedValues);
+            Assume assumeNotNull =
+                Assume.createAssumeNonNullInstruction(
+                    nonNullValue, argumentValue, argument, appView);
+            assumeNotNull.setPosition(argument.getPosition());
+            assumeInstructions.add(assumeNotNull);
+          }
+          continue;
+        }
+        DynamicTypeWithUpperBound dynamicTypeWithUpperBound =
+            dynamicType.asDynamicTypeWithUpperBound();
         Value specializedArg;
-        if (dynamicUpperBoundType.strictlyLessThan(argumentValue.getType(), appView)) {
+        if (dynamicTypeWithUpperBound.strictlyLessThan(argumentValue.getType(), appView)) {
           specializedArg = code.createValue(argumentValue.getType());
           affectedValues.addAll(argumentValue.affectedValues());
           argumentValue.replaceUsers(specializedArg);
           Assume assumeType =
               Assume.createAssumeDynamicTypeInstruction(
-                  dynamicUpperBoundType, null, specializedArg, argumentValue, argument, appView);
+                  dynamicTypeWithUpperBound, specializedArg, argumentValue, argument, appView);
           assumeType.setPosition(argument.getPosition());
           assumeInstructions.add(assumeType);
         } else {
           specializedArg = argumentValue;
         }
         assert specializedArg != null && specializedArg.getType().isReferenceType();
-        if (dynamicUpperBoundType.isDefinitelyNotNull()) {
+        if (dynamicType.getNullability().isDefinitelyNotNull()) {
           // If we already knew `arg` is never null, e.g., receiver, skip adding non-null.
           if (!specializedArg.getType().isDefinitelyNotNull()) {
             Value nonNullArg =
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java
index 772a404..f3e9000 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java
@@ -10,8 +10,10 @@
 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.FieldResolutionResult;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistryWithResult;
 import com.android.tools.r8.ir.conversion.IRConverter;
@@ -187,21 +189,43 @@
     }
 
     @Override
+    public void registerInstanceFieldRead(DexField field) {
+      registerFieldAccess(field);
+    }
+
+    @Override
+    public void registerInstanceFieldWrite(DexField field) {
+      registerFieldAccess(field);
+    }
+
+    @Override
+    public void registerStaticFieldRead(DexField field) {
+      registerFieldAccess(field);
+    }
+
+    @Override
+    public void registerStaticFieldWrite(DexField field) {
+      registerFieldAccess(field);
+    }
+
+    private void registerFieldAccess(DexField field) {
+      FieldResolutionResult resolutionResult = appView.appInfo().resolveField(field);
+      if (resolutionResult.getProgramField() == null) {
+        return;
+      }
+
+      ProgramField resolvedField = resolutionResult.getProgramField();
+      DexField rewrittenFieldReference =
+          graphLens.internalGetNextFieldSignature(resolvedField.getReference());
+      if (rewrittenFieldReference != resolvedField.getReference()) {
+        markAffected();
+      }
+    }
+
+    @Override
     public void registerInitClass(DexType type) {}
 
     @Override
-    public void registerInstanceFieldRead(DexField field) {}
-
-    @Override
-    public void registerInstanceFieldWrite(DexField field) {}
-
-    @Override
-    public void registerStaticFieldRead(DexField field) {}
-
-    @Override
-    public void registerStaticFieldWrite(DexField field) {}
-
-    @Override
     public void registerTypeReference(DexType type) {}
   }
 }
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
index 81df33e..94da691 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
@@ -212,8 +212,9 @@
                       .asClassParameter()
                       .getDynamicType();
               DexType staticType = method.getArgumentType(index);
-              assert dynamicType
-                  == WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, staticType);
+              assert dynamicType.isUnknown()
+                  || !WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, staticType)
+                      .isUnknown();
               return true;
             });
 
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
index 8e7380d..6b94973 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
@@ -9,23 +9,32 @@
 import com.android.tools.r8.graph.AppView;
 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.DexMethodSignature;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.graph.ObjectAllocationInfoCollection;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription.ArgumentInfoCollection;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentInfo;
 import com.android.tools.r8.graph.RewrittenPrototypeDescription.RewrittenTypeInfo;
+import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.SingleValue;
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.ConcreteCallSiteOptimizationInfo;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorGraphLens.Builder;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepFieldInfo;
+import com.android.tools.r8.utils.AccessUtils;
 import com.android.tools.r8.utils.BooleanBox;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.IntBox;
@@ -197,10 +206,7 @@
       this.options = appView.options();
     }
 
-    // TODO(b/190154391): Remove unused parameters by simulating they are constant.
     // TODO(b/190154391): Strengthen the static type of parameters.
-    // TODO(b/190154391): If we learn that a method returns a constant, then consider changing its
-    //  return type to void.
     // TODO(b/69963623): If we optimize a method to be unconditionally throwing (because it has a
     //  bottom parameter), then for each caller that becomes unconditionally throwing, we could
     //  also enqueue the caller's callers for reprocessing. This would propagate the throwing
@@ -435,6 +441,15 @@
         DexMethodSignatureSet interfaceDispatchOutsideProgram,
         ArgumentPropagatorGraphLens.Builder partialGraphLensBuilder) {
       BooleanBox affected = new BooleanBox();
+      clazz.forEachProgramFieldMatching(
+          field -> field.getType().isClassType(),
+          field -> {
+            DexField newFieldSignature = getNewFieldSignature(field);
+            if (newFieldSignature != field.getReference()) {
+              partialGraphLensBuilder.recordMove(field.getReference(), newFieldSignature);
+              affected.set();
+            }
+          });
       DexMethodSignatureSet instanceInitializerSignatures = DexMethodSignatureSet.create();
       clazz.forEachProgramInstanceInitializer(instanceInitializerSignatures::add);
       clazz.forEachProgramMethod(
@@ -454,6 +469,71 @@
       return affected.get();
     }
 
+    private DexField getNewFieldSignature(ProgramField field) {
+      DynamicType dynamicType = field.getOptimizationInfo().getDynamicType();
+      if (dynamicType.isUnknown()) {
+        return field.getReference();
+      }
+
+      KeepFieldInfo keepInfo = appView.getKeepInfo(field);
+
+      // We don't have dynamic type information for fields that are kept.
+      assert !keepInfo.isPinned(options);
+
+      if (!keepInfo.isFieldTypeStrengtheningAllowed(options)) {
+        return field.getReference();
+      }
+
+      if (dynamicType.isNullType()) {
+        // Don't optimize always null fields; these will be optimized anyway.
+        return field.getReference();
+      }
+
+      if (dynamicType.isNotNullType()) {
+        // We don't have a more specific type.
+        return field.getReference();
+      }
+
+      DynamicTypeWithUpperBound dynamicTypeWithUpperBound =
+          dynamicType.asDynamicTypeWithUpperBound();
+      TypeElement dynamicUpperBoundType = dynamicTypeWithUpperBound.getDynamicUpperBoundType();
+      assert dynamicUpperBoundType.isReferenceType();
+
+      ClassTypeElement staticFieldType = field.getType().toTypeElement(appView).asClassType();
+      if (dynamicUpperBoundType.equalUpToNullability(staticFieldType)) {
+        // We don't have more precise type information.
+        return field.getReference();
+      }
+
+      if (!dynamicUpperBoundType.strictlyLessThan(staticFieldType, appView)) {
+        assert options.testing.allowTypeErrors;
+        return field.getReference();
+      }
+
+      DexType newStaticFieldType;
+      if (dynamicUpperBoundType.isClassType()) {
+        ClassTypeElement dynamicUpperBoundClassType = dynamicUpperBoundType.asClassType();
+        if (dynamicUpperBoundClassType.getClassType() == dexItemFactory.objectType) {
+          if (dynamicUpperBoundClassType.getInterfaces().hasSingleKnownInterface()) {
+            newStaticFieldType =
+                dynamicUpperBoundClassType.getInterfaces().getSingleKnownInterface();
+          } else {
+            return field.getReference();
+          }
+        } else {
+          newStaticFieldType = dynamicUpperBoundClassType.getClassType();
+        }
+      } else {
+        newStaticFieldType = dynamicUpperBoundType.asArrayType().toDexType(dexItemFactory);
+      }
+
+      if (!AccessUtils.isAccessibleInSameContextsAs(newStaticFieldType, field.getType(), appView)) {
+        return field.getReference();
+      }
+
+      return field.getReference().withType(newStaticFieldType, dexItemFactory);
+    }
+
     private DexMethod getNewMethodSignature(
         ProgramMethod method, RewrittenPrototypeDescription prototypeChanges) {
       DexMethodSignature methodSignatureWithoutPrototypeChanges = method.getMethodSignature();
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
index 9af5fb3..fab9f6f 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
@@ -67,7 +67,7 @@
 
   @Override
   public Nullability getNullability() {
-    return getDynamicType().getDynamicUpperBoundType().nullability();
+    return getDynamicType().getNullability();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePolymorphicMethodState.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePolymorphicMethodState.java
index d17ff72..d5fbf2b 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePolymorphicMethodState.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePolymorphicMethodState.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexMethodSignature;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.Collection;
 import java.util.HashMap;
@@ -18,24 +19,28 @@
 public class ConcretePolymorphicMethodState extends ConcreteMethodState
     implements ConcretePolymorphicMethodStateOrBottom, ConcretePolymorphicMethodStateOrUnknown {
 
-  private final Map<DynamicType, ConcreteMonomorphicMethodStateOrUnknown> receiverBoundsToState;
+  private final Map<DynamicTypeWithUpperBound, ConcreteMonomorphicMethodStateOrUnknown>
+      receiverBoundsToState;
 
   private ConcretePolymorphicMethodState(
-      Map<DynamicType, ConcreteMonomorphicMethodStateOrUnknown> receiverBoundsToState) {
+      Map<DynamicTypeWithUpperBound, ConcreteMonomorphicMethodStateOrUnknown>
+          receiverBoundsToState) {
     this.receiverBoundsToState = receiverBoundsToState;
     assert !isEffectivelyBottom();
     assert !isEffectivelyUnknown();
   }
 
   private ConcretePolymorphicMethodState(
-      DynamicType receiverBounds, ConcreteMonomorphicMethodStateOrUnknown methodState) {
+      DynamicTypeWithUpperBound receiverBounds,
+      ConcreteMonomorphicMethodStateOrUnknown methodState) {
     this.receiverBoundsToState = new HashMap<>(1);
     receiverBoundsToState.put(receiverBounds, methodState);
     assert !isEffectivelyUnknown();
   }
 
   public static ConcretePolymorphicMethodStateOrUnknown create(
-      DynamicType receiverBounds, ConcreteMonomorphicMethodStateOrUnknown methodState) {
+      DynamicTypeWithUpperBound receiverBounds,
+      ConcreteMonomorphicMethodStateOrUnknown methodState) {
     return receiverBounds.isUnknown() && methodState.isUnknown()
         ? MethodState.unknown()
         : new ConcretePolymorphicMethodState(receiverBounds, methodState);
@@ -44,7 +49,7 @@
   private ConcretePolymorphicMethodStateOrUnknown add(
       AppView<AppInfoWithLiveness> appView,
       DexMethodSignature methodSignature,
-      DynamicType bounds,
+      DynamicTypeWithUpperBound bounds,
       ConcreteMonomorphicMethodStateOrUnknown methodState,
       StateCloner cloner) {
     assert !isEffectivelyBottom();
@@ -90,11 +95,12 @@
   }
 
   public void forEach(
-      BiConsumer<? super DynamicType, ? super ConcreteMonomorphicMethodStateOrUnknown> consumer) {
+      BiConsumer<? super DynamicTypeWithUpperBound, ? super ConcreteMonomorphicMethodStateOrUnknown>
+          consumer) {
     receiverBoundsToState.forEach(consumer);
   }
 
-  public MethodState getMethodStateForBounds(DynamicType dynamicType) {
+  public MethodState getMethodStateForBounds(DynamicTypeWithUpperBound dynamicType) {
     ConcreteMonomorphicMethodStateOrUnknown methodStateForBounds =
         receiverBoundsToState.get(dynamicType);
     if (methodStateForBounds != null) {
@@ -115,7 +121,7 @@
   public MethodState mutableCopy() {
     assert !isEffectivelyBottom();
     assert !isEffectivelyUnknown();
-    Map<DynamicType, ConcreteMonomorphicMethodStateOrUnknown> receiverBoundsToState =
+    Map<DynamicTypeWithUpperBound, ConcreteMonomorphicMethodStateOrUnknown> receiverBoundsToState =
         new HashMap<>();
     forEach((bounds, methodState) -> receiverBoundsToState.put(bounds, methodState.mutableCopy()));
     return new ConcretePolymorphicMethodState(receiverBoundsToState);
@@ -123,16 +129,16 @@
 
   public MethodState mutableCopyWithRewrittenBounds(
       AppView<AppInfoWithLiveness> appView,
-      Function<DynamicType, DynamicType> boundsRewriter,
+      Function<DynamicTypeWithUpperBound, DynamicTypeWithUpperBound> boundsRewriter,
       DexMethodSignature methodSignature,
       StateCloner cloner) {
     assert !isEffectivelyBottom();
     assert !isEffectivelyUnknown();
-    Map<DynamicType, ConcreteMonomorphicMethodStateOrUnknown> rewrittenReceiverBoundsToState =
-        new HashMap<>();
-    for (Entry<DynamicType, ConcreteMonomorphicMethodStateOrUnknown> entry :
+    Map<DynamicTypeWithUpperBound, ConcreteMonomorphicMethodStateOrUnknown>
+        rewrittenReceiverBoundsToState = new HashMap<>();
+    for (Entry<DynamicTypeWithUpperBound, ConcreteMonomorphicMethodStateOrUnknown> entry :
         receiverBoundsToState.entrySet()) {
-      DynamicType rewrittenBounds = boundsRewriter.apply(entry.getKey());
+      DynamicTypeWithUpperBound rewrittenBounds = boundsRewriter.apply(entry.getKey());
       if (rewrittenBounds == null) {
         continue;
       }
@@ -160,7 +166,7 @@
     assert !isEffectivelyUnknown();
     assert !methodState.isEffectivelyBottom();
     assert !methodState.isEffectivelyUnknown();
-    for (Entry<DynamicType, ConcreteMonomorphicMethodStateOrUnknown> entry :
+    for (Entry<DynamicTypeWithUpperBound, ConcreteMonomorphicMethodStateOrUnknown> entry :
         methodState.receiverBoundsToState.entrySet()) {
       ConcretePolymorphicMethodStateOrUnknown result =
           add(appView, methodSignature, entry.getKey(), entry.getValue(), cloner);
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteReceiverParameterState.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteReceiverParameterState.java
index 74c9107..4da32d6 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteReceiverParameterState.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteReceiverParameterState.java
@@ -54,7 +54,7 @@
 
   @Override
   public Nullability getNullability() {
-    return getDynamicType().getDynamicUpperBoundType().nullability();
+    return getDynamicType().getNullability();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/VirtualDispatchMethodArgumentPropagator.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/VirtualDispatchMethodArgumentPropagator.java
index 36525f5..085d4a0 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/VirtualDispatchMethodArgumentPropagator.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/VirtualDispatchMethodArgumentPropagator.java
@@ -16,7 +16,7 @@
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteMethodState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcretePolymorphicMethodState;
@@ -46,7 +46,7 @@
 
     // Argument information for virtual methods that is currently inactive, but should be propagated
     // to all overrides below a given upper bound.
-    final Map<DynamicType, MethodStateCollectionBySignature> inactiveUntilUpperBound =
+    final Map<DynamicTypeWithUpperBound, MethodStateCollectionBySignature> inactiveUntilUpperBound =
         new HashMap<>();
 
     PropagationState(DexProgramClass clazz) {
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/utils/WideningUtils.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/utils/WideningUtils.java
index f30aa8e..8e657dd 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/utils/WideningUtils.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/utils/WideningUtils.java
@@ -11,7 +11,9 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 
 public class WideningUtils {
@@ -20,13 +22,11 @@
       AppView<AppInfoWithLiveness> appView,
       ProgramMethod resolvedMethod,
       DynamicType dynamicReceiverType) {
-    return shouldWidenDynamicType(
-            appView,
-            dynamicReceiverType,
-            resolvedMethod.getHolderType(),
-            Nullability.definitelyNotNull())
-        ? DynamicType.unknown()
-        : dynamicReceiverType;
+    return internalWidenDynamicClassType(
+        appView,
+        dynamicReceiverType,
+        resolvedMethod.getHolderType(),
+        Nullability.definitelyNotNull());
   }
 
   public static DynamicType widenDynamicNonReceiverType(
@@ -39,39 +39,38 @@
       DynamicType dynamicType,
       DexType staticType,
       Nullability staticNullability) {
-    return shouldWidenDynamicType(appView, dynamicType, staticType, staticNullability)
-        ? DynamicType.unknown()
-        : dynamicType;
+    return internalWidenDynamicClassType(appView, dynamicType, staticType, staticNullability);
   }
 
-  private static boolean shouldWidenDynamicType(
+  private static DynamicType internalWidenDynamicClassType(
       AppView<AppInfoWithLiveness> appView,
       DynamicType dynamicType,
       DexType staticType,
       Nullability staticNullability) {
     assert staticType.isClassType();
-    if (dynamicType.isUnknown()) {
-      return true;
-    }
     if (dynamicType.isBottom()
         || dynamicType.isNullType()
-        || dynamicType.getNullability().strictlyLessThan(staticNullability)) {
-      return false;
+        || dynamicType.isNotNullType()
+        || dynamicType.isUnknown()) {
+      return dynamicType;
     }
+    DynamicTypeWithUpperBound dynamicTypeWithUpperBound = dynamicType.asDynamicTypeWithUpperBound();
+    TypeElement dynamicUpperBoundType = dynamicTypeWithUpperBound.getDynamicUpperBoundType();
     ClassTypeElement staticTypeElement =
         staticType.toTypeElement(appView).asClassType().getOrCreateVariant(staticNullability);
-    if (!dynamicType.getDynamicUpperBoundType().equals(staticTypeElement)) {
-      return false;
+    if (dynamicType.getNullability().strictlyLessThan(staticNullability)) {
+      if (dynamicType.getNullability().isDefinitelyNotNull()
+          && dynamicUpperBoundType.equalUpToNullability(staticTypeElement)
+          && hasTrivialLowerBound(appView, dynamicType, staticType)) {
+        return DynamicType.definitelyNotNull();
+      }
+      return dynamicType;
+    }
+    if (!dynamicUpperBoundType.equals(staticTypeElement)) {
+      return dynamicType;
     }
     if (!dynamicType.hasDynamicLowerBoundType()) {
-      return true;
-    }
-
-    DexClass staticTypeClass = appView.definitionFor(staticType);
-    if (staticTypeClass == null || !staticTypeClass.isProgramClass()) {
-      // TODO(b/190154391): If this is a library class with no program subtypes, then we might as
-      //  well widen to 'unknown'.
-      return false;
+      return DynamicType.unknown();
     }
 
     // If the static type does not have any program subtypes, then widen the dynamic type to
@@ -80,6 +79,23 @@
     // Note that if the static type is pinned, it could have subtypes outside the set of program
     // classes, but in this case it is still unlikely that we can use the dynamic lower bound type
     // information for anything, so we intentionally also widen to 'unknown' in this case.
+    return isEffectivelyFinal(appView, staticType) ? DynamicType.unknown() : dynamicType;
+  }
+
+  private static boolean hasTrivialLowerBound(
+      AppView<AppInfoWithLiveness> appView, DynamicType dynamicType, DexType staticType) {
+    return !dynamicType.hasDynamicLowerBoundType() || isEffectivelyFinal(appView, staticType);
+  }
+
+  private static boolean isEffectivelyFinal(
+      AppView<AppInfoWithLiveness> appView, DexType staticType) {
+    DexClass staticTypeClass = appView.definitionFor(staticType);
+    if (staticTypeClass == null) {
+      return false;
+    }
+    if (!staticTypeClass.isProgramClass()) {
+      return staticTypeClass.isFinal();
+    }
     ObjectAllocationInfoCollection objectAllocationInfoCollection =
         appView.appInfo().getObjectAllocationInfoCollection();
     return !objectAllocationInfoCollection.hasInstantiatedStrictSubtype(
diff --git a/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java b/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
index 32654be..244257a 100644
--- a/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
+++ b/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.graph.DexAnnotation.AnnotatedKind;
 import com.android.tools.r8.graph.DexAnnotationElement;
 import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexDefinition;
 import com.android.tools.r8.graph.DexEncodedAnnotation;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
@@ -385,13 +384,6 @@
     }
   }
 
-  public static void clearAnnotations(AppView<?> appView) {
-    for (DexProgramClass clazz : appView.appInfo().classes()) {
-      clazz.clearAnnotations();
-      clazz.members().forEach(DexDefinition::clearAnnotations);
-    }
-  }
-
   public static class Builder {
 
     /**
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 61c9077..c34f7f3 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClassAndField;
 import com.android.tools.r8.graph.DexClassAndMember;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexClasspathClass;
@@ -978,10 +979,7 @@
   private boolean isInstantiatedDirectly(DexProgramClass clazz) {
     assert checkIfObsolete();
     DexType type = clazz.type;
-    return
-    // TODO(b/165224388): Synthetic classes should be represented in the allocation info.
-    getSyntheticItems().isLegacySyntheticClass(clazz)
-        || (!clazz.isInterface() && objectAllocationInfoCollection.isInstantiatedDirectly(clazz))
+    return (!clazz.isInterface() && objectAllocationInfoCollection.isInstantiatedDirectly(clazz))
         // TODO(b/145344105): Model annotations in the object allocation info.
         || (clazz.isAnnotation() && liveTypes.contains(type));
   }
@@ -1060,6 +1058,10 @@
         && !fieldAccessInfo.isWrittenOutside(method);
   }
 
+  public boolean isInstanceFieldWrittenOnlyInInstanceInitializers(DexClassAndField field) {
+    return isInstanceFieldWrittenOnlyInInstanceInitializers(field.getDefinition());
+  }
+
   public boolean isInstanceFieldWrittenOnlyInInstanceInitializers(DexEncodedField field) {
     assert checkIfObsolete();
     assert isFieldWritten(field) : "Expected field `" + field.toSourceString() + "` to be written";
@@ -1269,7 +1271,7 @@
         getClassToFeatureSplitMap().rewrittenWithLens(lens),
         getMainDexInfo().rewrittenWithLens(getSyntheticItems(), lens),
         deadProtoTypes,
-        getMissingClasses().commitSyntheticItems(committedItems),
+        getMissingClasses(),
         lens.rewriteReferences(liveTypes),
         lens.rewriteReferences(targetedMethods),
         lens.rewriteReferences(failedMethodResolutionTargets),
diff --git a/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java b/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java
index a5b539b..597a07d 100644
--- a/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java
@@ -181,6 +181,7 @@
 
   @Override
   public void registerExceptionGuard(DexType guard) {
+    setMaxApiReferenceLevel(guard);
     enqueuer.traceExceptionGuard(guard, getContext());
   }
 
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java
index 140b86b..312b61e 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java
@@ -74,6 +74,16 @@
       allowFieldTypeStrengthening = original.internalIsFieldTypeStrengtheningAllowed();
     }
 
+    @Override
+    public Builder makeTop() {
+      return super.makeTop().disallowFieldTypeStrengthening();
+    }
+
+    @Override
+    public Builder makeBottom() {
+      return super.makeBottom().allowFieldTypeStrengthening();
+    }
+
     public boolean isFieldTypeStrengtheningAllowed() {
       return allowFieldTypeStrengthening;
     }
@@ -112,6 +122,12 @@
     }
 
     @Override
+    boolean internalIsEqualTo(KeepFieldInfo other) {
+      return super.internalIsEqualTo(other)
+          && isFieldTypeStrengtheningAllowed() == other.internalIsFieldTypeStrengtheningAllowed();
+    }
+
+    @Override
     public KeepFieldInfo doBuild() {
       return new KeepFieldInfo(this);
     }
@@ -136,7 +152,10 @@
     @Override
     public Joiner merge(Joiner joiner) {
       // Should be extended to merge the fields of this class in case any are added.
-      return super.merge(joiner);
+      return super.merge(joiner)
+          .applyIf(
+              !joiner.builder.isFieldTypeStrengtheningAllowed(),
+              KeepFieldInfo.Joiner::disallowFieldTypeStrengthening);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index ac8f1fb..5e33712 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -21,7 +21,6 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramDerivedContext;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.synthesis.CommittedItems;
 import com.android.tools.r8.synthesis.SyntheticItems.SynthesizingContextOracle;
 import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.ImmutableSet;
@@ -51,13 +50,6 @@
     return new MissingClasses(Sets.newIdentityHashSet());
   }
 
-  public MissingClasses commitSyntheticItems(CommittedItems committedItems) {
-    return builder()
-        // TODO(b/175542052): Synthetic types should not be reported as missing in the first place.
-        .removeAlreadyMissingClasses(committedItems.getLegacySyntheticTypes())
-        .build();
-  }
-
   public void forEach(Consumer<DexType> missingClassConsumer) {
     missingClasses.forEach(missingClassConsumer);
   }
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index 9822a54..3155b54 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -387,7 +387,7 @@
 
     if (!appInfo
         .getClassToFeatureSplitMap()
-        .isInSameFeatureOrBothInBase(sourceClass, targetClass, appView.getSyntheticItems())) {
+        .isInSameFeatureOrBothInSameBase(sourceClass, targetClass, appView.getSyntheticItems())) {
       return false;
     }
     if (appView.appServices().allServiceTypes().contains(sourceClass.type)
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 f71c94e..1e4071f 100644
--- a/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
@@ -54,11 +54,6 @@
     return committedProgramTypes;
   }
 
-  @Deprecated
-  public Collection<DexType> getLegacySyntheticTypes() {
-    return committed.getLegacyTypes().keySet();
-  }
-
   @Override
   public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
     // All synthetic types are committed to the application so lookup is just the base lookup.
diff --git a/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java b/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
index fd7437e..6961fb0 100644
--- a/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
+++ b/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
@@ -34,7 +34,6 @@
     private final CommittedSyntheticsCollection parent;
     private Map<DexType, List<SyntheticProgramClassReference>> newNonLegacyClasses = null;
     private Map<DexType, List<SyntheticMethodReference>> newNonLegacyMethods = null;
-    private Map<DexType, List<LegacySyntheticReference>> newLegacyClasses = null;
     private ImmutableSet.Builder<DexType> newSyntheticInputs = null;
 
     public Builder(CommittedSyntheticsCollection parent) {
@@ -76,28 +75,6 @@
       return this;
     }
 
-    public Builder addLegacyClasses(Map<DexType, LegacySyntheticDefinition> classes) {
-      if (newLegacyClasses == null) {
-        newLegacyClasses = new IdentityHashMap<>();
-      }
-      classes.forEach(
-          (type, item) ->
-              newLegacyClasses
-                  .computeIfAbsent(type, ignore -> new ArrayList<>())
-                  .add(item.toReference()));
-      return this;
-    }
-
-    public Builder addLegacyClass(LegacySyntheticReference reference) {
-      if (newLegacyClasses == null) {
-        newLegacyClasses = new IdentityHashMap<>();
-      }
-      newLegacyClasses
-          .computeIfAbsent(reference.getHolder(), ignore -> new ArrayList<>())
-          .add(reference);
-      return this;
-    }
-
     public Builder addSyntheticInput(DexType syntheticInput) {
       if (newSyntheticInputs == null) {
         newSyntheticInputs = ImmutableSet.builder();
@@ -116,26 +93,21 @@
       if (newNonLegacyMethods != null) {
         newSyntheticInputs.addAll(newNonLegacyMethods.keySet());
       }
-      if (newLegacyClasses != null) {
-        newSyntheticInputs.addAll(newLegacyClasses.keySet());
-      }
       return this;
     }
 
     public CommittedSyntheticsCollection build() {
-      if (newNonLegacyClasses == null && newNonLegacyMethods == null && newLegacyClasses == null) {
+      if (newNonLegacyClasses == null && newNonLegacyMethods == null) {
         return parent;
       }
       ImmutableMap<DexType, List<SyntheticProgramClassReference>> allNonLegacyClasses =
           merge(newNonLegacyClasses, parent.nonLegacyClasses);
       ImmutableMap<DexType, List<SyntheticMethodReference>> allNonLegacyMethods =
           merge(newNonLegacyMethods, parent.nonLegacyMethods);
-      ImmutableMap<DexType, List<LegacySyntheticReference>> allLegacyClasses =
-          merge(newLegacyClasses, parent.legacyTypes);
       ImmutableSet<DexType> allSyntheticInputs =
           newSyntheticInputs == null ? parent.syntheticInputs : newSyntheticInputs.build();
       return new CommittedSyntheticsCollection(
-          allLegacyClasses, allNonLegacyMethods, allNonLegacyClasses, allSyntheticInputs);
+          allNonLegacyMethods, allNonLegacyClasses, allSyntheticInputs);
     }
   }
 
@@ -151,15 +123,7 @@
   }
 
   private static final CommittedSyntheticsCollection EMPTY =
-      new CommittedSyntheticsCollection(
-          ImmutableMap.of(), ImmutableMap.of(), ImmutableMap.of(), ImmutableSet.of());
-
-  /**
-   * Immutable set of synthetic types in the application (eg, committed).
-   *
-   * <p>TODO(b/158159959): Remove legacy support.
-   */
-  private final ImmutableMap<DexType, List<LegacySyntheticReference>> legacyTypes;
+      new CommittedSyntheticsCollection(ImmutableMap.of(), ImmutableMap.of(), ImmutableSet.of());
 
   /** Mapping from synthetic type to its synthetic method item description. */
   private final ImmutableMap<DexType, List<SyntheticMethodReference>> nonLegacyMethods;
@@ -171,11 +135,9 @@
   public final ImmutableSet<DexType> syntheticInputs;
 
   public CommittedSyntheticsCollection(
-      ImmutableMap<DexType, List<LegacySyntheticReference>> legacyTypes,
       ImmutableMap<DexType, List<SyntheticMethodReference>> nonLegacyMethods,
       ImmutableMap<DexType, List<SyntheticProgramClassReference>> nonLegacyClasses,
       ImmutableSet<DexType> syntheticInputs) {
-    this.legacyTypes = legacyTypes;
     this.nonLegacyMethods = nonLegacyMethods;
     this.nonLegacyClasses = nonLegacyClasses;
     this.syntheticInputs = syntheticInputs;
@@ -185,7 +147,6 @@
   private boolean verifySyntheticInputsSubsetOfSynthetics() {
     Set<DexType> synthetics =
         ImmutableSet.<DexType>builder()
-            .addAll(legacyTypes.keySet())
             .addAll(nonLegacyMethods.keySet())
             .addAll(nonLegacyClasses.keySet())
             .build();
@@ -206,14 +167,13 @@
   }
 
   boolean isEmpty() {
-    boolean empty =
-        legacyTypes.isEmpty() && nonLegacyMethods.isEmpty() && nonLegacyClasses.isEmpty();
+    boolean empty = nonLegacyMethods.isEmpty() && nonLegacyClasses.isEmpty();
     assert !empty || syntheticInputs.isEmpty();
     return empty;
   }
 
   boolean containsType(DexType type) {
-    return containsLegacyType(type) || containsNonLegacyType(type);
+    return containsNonLegacyType(type);
   }
 
   boolean containsTypeOfKind(DexType type, SyntheticKind kind) {
@@ -229,10 +189,6 @@
     return false;
   }
 
-  public boolean containsLegacyType(DexType type) {
-    return legacyTypes.containsKey(type);
-  }
-
   public boolean containsNonLegacyType(DexType type) {
     return nonLegacyMethods.containsKey(type) || nonLegacyClasses.containsKey(type);
   }
@@ -241,14 +197,6 @@
     return syntheticInputs.contains(type);
   }
 
-  public ImmutableMap<DexType, List<LegacySyntheticReference>> getLegacyTypes() {
-    return legacyTypes;
-  }
-
-  public List<LegacySyntheticReference> getLegacyTypes(DexType type) {
-    return legacyTypes.getOrDefault(type, emptyList());
-  }
-
   public ImmutableMap<DexType, List<SyntheticMethodReference>> getNonLegacyMethods() {
     return nonLegacyMethods;
   }
@@ -279,13 +227,6 @@
     }
     Builder builder = CommittedSyntheticsCollection.empty().builder();
     boolean changed = false;
-    for (LegacySyntheticReference reference : IterableUtils.flatten(legacyTypes.values())) {
-      if (removed.contains(reference.getHolder())) {
-        changed = true;
-      } else {
-        builder.addLegacyClass(reference);
-      }
-    }
     for (SyntheticMethodReference reference : IterableUtils.flatten(nonLegacyMethods.values())) {
       if (removed.contains(reference.getHolder())) {
         changed = true;
@@ -314,7 +255,6 @@
   CommittedSyntheticsCollection rewriteWithLens(NonIdentityGraphLens lens) {
     ImmutableSet.Builder<DexType> syntheticInputsBuilder = ImmutableSet.builder();
     return new CommittedSyntheticsCollection(
-        rewriteItems(legacyTypes, lens, syntheticInputsBuilder),
         rewriteItems(nonLegacyMethods, lens, syntheticInputsBuilder),
         rewriteItems(nonLegacyClasses, lens, syntheticInputsBuilder),
         syntheticInputsBuilder.build());
@@ -340,7 +280,6 @@
   }
 
   boolean verifyTypesAreInApp(DexApplication application) {
-    assert verifyTypesAreInApp(application, legacyTypes.keySet());
     assert verifyTypesAreInApp(application, nonLegacyMethods.keySet());
     assert verifyTypesAreInApp(application, nonLegacyClasses.keySet());
     assert verifyTypesAreInApp(application, syntheticInputs);
diff --git a/src/main/java/com/android/tools/r8/synthesis/LegacySyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/LegacySyntheticDefinition.java
deleted file mode 100644
index 3e50bf5..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/LegacySyntheticDefinition.java
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.synthesis;
-
-import com.android.tools.r8.FeatureSplit;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ProgramDefinition;
-import com.android.tools.r8.utils.IterableUtils;
-import com.google.common.collect.ImmutableSet;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class LegacySyntheticDefinition {
-  private final DexProgramClass clazz;
-  private final Map<DexType, FeatureSplit> contexts = new ConcurrentHashMap<>();
-
-  public LegacySyntheticDefinition(DexProgramClass clazz) {
-    this.clazz = clazz;
-  }
-
-  public void addContext(ProgramDefinition clazz, FeatureSplit featureSplit) {
-    DexType type = clazz.getContextType();
-    contexts.put(type, featureSplit);
-  }
-
-  public Set<DexType> getContexts() {
-    return contexts.keySet();
-  }
-
-  public LegacySyntheticReference toReference() {
-    return new LegacySyntheticReference(
-        clazz.getType(), ImmutableSet.copyOf(contexts.keySet()), getFeatureSplit());
-  }
-
-  public FeatureSplit getFeatureSplit() {
-    assert verifyConsistentFeatures();
-    if (contexts.isEmpty()) {
-      return FeatureSplit.BASE;
-    }
-    return IterableUtils.first(contexts.values());
-  }
-
-  private boolean verifyConsistentFeatures() {
-    HashSet<FeatureSplit> features = new HashSet<>(contexts.values());
-    assert features.size() < 2;
-    return true;
-  }
-
-  public DexProgramClass getDefinition() {
-    return clazz;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/synthesis/LegacySyntheticReference.java b/src/main/java/com/android/tools/r8/synthesis/LegacySyntheticReference.java
deleted file mode 100644
index 715e790..0000000
--- a/src/main/java/com/android/tools/r8/synthesis/LegacySyntheticReference.java
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.synthesis;
-
-import com.android.tools.r8.FeatureSplit;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
-import java.util.Set;
-
-public class LegacySyntheticReference implements Rewritable<LegacySyntheticReference> {
-  private final DexType type;
-  private final Set<DexType> contexts;
-  private final FeatureSplit featureSplit;
-
-  public LegacySyntheticReference(DexType type, Set<DexType> contexts, FeatureSplit featureSplit) {
-    this.type = type;
-    this.contexts = contexts;
-    this.featureSplit = featureSplit;
-  }
-
-  @Override
-  public DexType getHolder() {
-    return type;
-  }
-
-  public Set<DexType> getContexts() {
-    return contexts;
-  }
-
-  public FeatureSplit getFeatureSplit() {
-    return featureSplit;
-  }
-
-  @Override
-  public LegacySyntheticReference rewrite(NonIdentityGraphLens lens) {
-    DexType rewrittenType = lens.lookupType(type);
-    Set<DexType> rewrittenContexts = lens.rewriteTypes(getContexts());
-    if (type == rewrittenType && contexts.equals(rewrittenContexts)) {
-      return this;
-    }
-    return new LegacySyntheticReference(rewrittenType, rewrittenContexts, featureSplit);
-  }
-}
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 3bf8883..9fe1fb9 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -155,7 +155,7 @@
   public String toString() {
     return "SynthesizingContext{"
         + getSynthesizingContextType()
-        + (featureSplit != FeatureSplit.BASE ? ", feature:" + featureSplit : "")
+        + (!featureSplit.isBase() ? ", feature:" + featureSplit : "")
         + "}";
   }
 
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 0ce464d..9548f78 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -269,8 +269,7 @@
         new CommittedItems(
             SyntheticItems.INVALID_ID_AFTER_SYNTHETIC_FINALIZATION,
             application,
-            new CommittedSyntheticsCollection(
-                committed.getLegacyTypes(), finalMethods, finalClasses, finalInputSynthetics),
+            new CommittedSyntheticsCollection(finalMethods, finalClasses, finalInputSynthetics),
             ImmutableList.of()),
         syntheticFinalizationGraphLens,
         PrunedItems.builder().setPrunedApp(application).addRemovedClasses(prunedSynthetics).build(),
@@ -330,13 +329,6 @@
   private boolean verifyOneSyntheticPerSyntheticClass() {
     Set<DexType> seen = Sets.newIdentityHashSet();
     committed
-        .getLegacyTypes()
-        .forEach(
-            (type, references) -> {
-              assert seen.add(type);
-              assert references.size() == 1;
-            });
-    committed
         .getNonLegacyClasses()
         .forEach(
             (type, references) -> {
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 caf0f42..f8e241b 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -41,7 +41,6 @@
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
@@ -59,23 +58,17 @@
 
   /** 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, LegacySyntheticDefinition> legacyClasses = new ConcurrentHashMap<>();
 
     /** Thread safe collection of synthetic items not yet committed to the application. */
     private final ConcurrentHashMap<DexType, SyntheticDefinition<?, ?, ?>> nonLegacyDefinitions =
         new ConcurrentHashMap<>();
 
     boolean isEmpty() {
-      return legacyClasses.isEmpty() && nonLegacyDefinitions.isEmpty();
+      return nonLegacyDefinitions.isEmpty();
     }
 
     boolean containsType(DexType type) {
-      return legacyClasses.containsKey(type) || nonLegacyDefinitions.containsKey(type);
+      return nonLegacyDefinitions.containsKey(type);
     }
 
     boolean containsTypeOfKind(DexType type, SyntheticKind kind) {
@@ -84,22 +77,17 @@
     }
 
     boolean verifyNotRewritten(NonIdentityGraphLens lens) {
-      assert legacyClasses.keySet().equals(lens.rewriteTypes(legacyClasses.keySet()));
       assert nonLegacyDefinitions.keySet().equals(lens.rewriteTypes(nonLegacyDefinitions.keySet()));
       return true;
     }
 
     Collection<DexProgramClass> getAllProgramClasses() {
-      List<DexProgramClass> allPending =
-          new ArrayList<>(nonLegacyDefinitions.size() + legacyClasses.size());
+      List<DexProgramClass> allPending = new ArrayList<>(nonLegacyDefinitions.size());
       for (SyntheticDefinition<?, ?, ?> item : nonLegacyDefinitions.values()) {
         if (item.isProgramDefinition()) {
           allPending.add(item.asProgramDefinition().getHolder());
         }
       }
-      for (LegacySyntheticDefinition legacy : legacyClasses.values()) {
-        allPending.add(legacy.getDefinition());
-      }
       return Collections.unmodifiableList(allPending);
     }
   }
@@ -189,22 +177,16 @@
   public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
     DexClass clazz = null;
     SyntheticKind kind = null;
-    LegacySyntheticDefinition legacyItem = pending.legacyClasses.get(type);
-    if (legacyItem != null) {
-      clazz = legacyItem.getDefinition();
-    } else {
-      SyntheticDefinition<?, ?, ?> item = pending.nonLegacyDefinitions.get(type);
-      if (item != null) {
-        clazz = item.getHolder();
-        kind = item.getKind();
-        assert clazz.isProgramClass() == item.isProgramDefinition();
-        assert clazz.isClasspathClass() == item.isClasspathDefinition();
-      }
+    SyntheticDefinition<?, ?, ?> item = pending.nonLegacyDefinitions.get(type);
+    if (item != null) {
+      clazz = item.getHolder();
+      kind = item.getKind();
+      assert clazz.isProgramClass() == item.isProgramDefinition();
+      assert clazz.isClasspathClass() == item.isClasspathDefinition();
     }
     if (clazz != null) {
-      assert legacyItem != null || kind != null;
-      assert baseDefinitionFor.apply(type) == null
-              || (kind != null && kind.mayOverridesNonProgramType)
+      assert kind != null;
+      assert baseDefinitionFor.apply(type) == null || kind.mayOverridesNonProgramType
           : "Pending synthetic definition also present in the active program: " + type;
       return clazz;
     }
@@ -227,10 +209,6 @@
     return committed.containsType(type);
   }
 
-  private boolean isLegacyCommittedSynthetic(DexType type) {
-    return committed.containsLegacyType(type);
-  }
-
   private boolean isNonLegacyCommittedSynthetic(DexType type) {
     return committed.containsNonLegacyType(type);
   }
@@ -239,22 +217,10 @@
     return pending.containsType(type);
   }
 
-  private boolean isLegacyPendingSynthetic(DexType type) {
-    return pending.legacyClasses.containsKey(type);
-  }
-
   private boolean isNonLegacyPendingSynthetic(DexType type) {
     return pending.nonLegacyDefinitions.containsKey(type);
   }
 
-  public boolean isLegacySyntheticClass(DexType type) {
-    return isLegacyCommittedSynthetic(type) || isLegacyPendingSynthetic(type);
-  }
-
-  public boolean isLegacySyntheticClass(DexProgramClass clazz) {
-    return isLegacySyntheticClass(clazz.getType());
-  }
-
   public boolean isNonLegacySynthetic(DexProgramClass clazz) {
     return isNonLegacySynthetic(clazz.type);
   }
@@ -291,7 +257,7 @@
   }
 
   public boolean isSyntheticClass(DexType type) {
-    return isLegacySyntheticClass(type) || isNonLegacySynthetic(type);
+    return isNonLegacySynthetic(type);
   }
 
   public boolean isSyntheticClass(DexProgramClass clazz) {
@@ -306,21 +272,14 @@
     return committed.containsSyntheticInput(clazz.getType());
   }
 
-  public FeatureSplit getContextualFeatureSplit(DexType type) {
-    if (pending.legacyClasses.containsKey(type)) {
-      LegacySyntheticDefinition definition = pending.legacyClasses.get(type);
-      return definition.getFeatureSplit();
-    }
-    if (committed.containsLegacyType(type)) {
-      List<LegacySyntheticReference> types = committed.getLegacyTypes(type);
-      if (types.isEmpty()) {
-        return null;
-      }
-      assert verifyAllHaveSameFeature(types, LegacySyntheticReference::getFeatureSplit);
-      return types.get(0).getFeatureSplit();
-    }
+  public FeatureSplit getContextualFeatureSplit(
+      DexType type, ClassToFeatureSplitMap classToFeatureSplitMap) {
     if (isSyntheticOfKind(type, SyntheticKind.ENUM_UNBOXING_SHARED_UTILITY_CLASS)) {
-      return FeatureSplit.BASE;
+      // Use the startup base if there is one, such that we don't merge non-startup classes with the
+      // shared utility class in case it is used during startup. The use of base startup allows for
+      // merging startup classes with the shared utility class, however, which could be bad for
+      // startup if the shared utility class is not used during startup.
+      return classToFeatureSplitMap.getBaseStartup();
     }
     List<SynthesizingContext> contexts = getSynthesizingContexts(type);
     if (contexts.isEmpty()) {
@@ -358,13 +317,6 @@
     ImmutableList.Builder<DexType> builder = ImmutableList.builder();
     forEachSynthesizingContext(
         type, synthesizingContext -> builder.add(synthesizingContext.getSynthesizingContextType()));
-    for (LegacySyntheticReference legacyReference : committed.getLegacyTypes(type)) {
-      builder.addAll(legacyReference.getContexts());
-    }
-    LegacySyntheticDefinition legacyDefinition = pending.legacyClasses.get(type);
-    if (legacyDefinition != null) {
-      builder.addAll(legacyDefinition.getContexts());
-    }
     return builder.build();
   }
 
@@ -416,10 +368,6 @@
     return true;
   }
 
-  public Collection<DexProgramClass> getLegacyPendingClasses() {
-    return ListUtils.map(pending.legacyClasses.values(), LegacySyntheticDefinition::getDefinition);
-  }
-
   private SynthesizingContext getSynthesizingContext(
       ProgramDefinition context, AppView<?> appView) {
     return getSynthesizingContext(
@@ -451,29 +399,6 @@
 
   // Addition and creation of synthetic items.
 
-  public void addLegacySyntheticClassForLibraryDesugaring(DexProgramClass clazz) {
-    internalAddLegacySyntheticClass(clazz);
-    // No context information is added for library context.
-    // This is intended only to support desugared-library compilation.
-  }
-
-  // TODO(b/158159959): Remove the usage of this direct class addition.
-  public void addLegacySyntheticClass(
-      DexProgramClass clazz, ProgramDefinition context, FeatureSplit featureSplit) {
-    LegacySyntheticDefinition legacyItem = internalAddLegacySyntheticClass(clazz);
-    legacyItem.addContext(context, featureSplit);
-  }
-
-  private LegacySyntheticDefinition internalAddLegacySyntheticClass(DexProgramClass clazz) {
-    assert !isCommittedSynthetic(clazz.type);
-    assert !pending.nonLegacyDefinitions.containsKey(clazz.type);
-    LegacySyntheticDefinition legacyItem =
-        pending.legacyClasses.computeIfAbsent(
-            clazz.getType(), type -> new LegacySyntheticDefinition(clazz));
-    assert legacyItem.getDefinition() == clazz;
-    return legacyItem;
-  }
-
   private DexProgramClass internalEnsureDexProgramClass(
       SyntheticKind kind,
       Consumer<SyntheticProgramClassBuilder> classConsumer,
@@ -824,9 +749,6 @@
     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);
     // Compute the synthetic additions and add them to the application.
     ImmutableList<DexType> committedProgramTypes;
     DexApplication amendedApplication;
@@ -863,15 +785,6 @@
         committedProgramTypes);
   }
 
-  private static boolean verifyClassesAreInApp(
-      DexApplication app, Collection<LegacySyntheticDefinition> classes) {
-    for (LegacySyntheticDefinition item : classes) {
-      DexProgramClass clazz = item.getDefinition();
-      assert app.programDefinitionFor(clazz.type) != null : "Missing synthetic: " + clazz.type;
-    }
-    return true;
-  }
-
   public void writeAttributeIfIntermediateSyntheticClass(
       ClassWriter writer, DexProgramClass clazz, AppView<?> appView) {
     if (!appView.options().intermediate || !appView.options().isGeneratingClassFiles()) {
diff --git a/src/main/java/com/android/tools/r8/utils/AccessUtils.java b/src/main/java/com/android/tools/r8/utils/AccessUtils.java
new file mode 100644
index 0000000..0498949
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/AccessUtils.java
@@ -0,0 +1,36 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.utils;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexDefinitionSupplier;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+
+public class AccessUtils {
+
+  public static boolean isAccessibleInSameContextsAs(
+      DexType newType, DexType oldType, DexDefinitionSupplier definitions) {
+    DexItemFactory dexItemFactory = definitions.dexItemFactory();
+    DexType newBaseType = newType.toBaseType(dexItemFactory);
+    if (!newBaseType.isClassType()) {
+      return true;
+    }
+    DexClass newBaseClass = definitions.definitionFor(newBaseType);
+    if (newBaseClass == null) {
+      return false;
+    }
+    if (newBaseClass.isPublic()) {
+      return true;
+    }
+    DexType oldBaseType = oldType.toBaseType(dexItemFactory);
+    assert oldBaseType.isClassType();
+    DexClass oldBaseClass = definitions.definitionFor(oldBaseType);
+    if (oldBaseClass == null || oldBaseClass.isPublic()) {
+      return false;
+    }
+    return newBaseType.isSamePackage(oldBaseType);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index b1a2757..959238e 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -34,6 +34,7 @@
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.InternalCompilerError;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.experimental.startup.StartupConfiguration;
 import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.features.FeatureSplitConfiguration;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -528,6 +529,7 @@
           dumpProgramResources(
               dumpProgramFileName,
               options.getFeatureSplitConfiguration(),
+              options.getStartupConfiguration(),
               nextDexIndex,
               out,
               reporter,
@@ -581,6 +583,7 @@
   private int dumpProgramResources(
       String archiveName,
       FeatureSplitConfiguration featureSplitConfiguration,
+      StartupConfiguration startupConfiguration,
       int nextDexIndex,
       ZipOutputStream out,
       Reporter reporter,
@@ -595,7 +598,7 @@
     try {
       ClassToFeatureSplitMap classToFeatureSplitMap =
           ClassToFeatureSplitMap.createInitialClassToFeatureSplitMap(
-              dexItemFactory, featureSplitConfiguration, reporter);
+              dexItemFactory, featureSplitConfiguration, startupConfiguration, reporter);
       if (featureSplitConfiguration != null) {
         for (FeatureSplit featureSplit : featureSplitConfiguration.getFeatureSplits()) {
           ByteArrayOutputStream archiveByteStream = new ByteArrayOutputStream();
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 de70549..fadaaa0 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -33,6 +33,7 @@
 import com.android.tools.r8.errors.MissingNestHostNestDesugarDiagnostic;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
+import com.android.tools.r8.experimental.startup.StartupConfiguration;
 import com.android.tools.r8.features.FeatureSplitConfiguration;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
@@ -159,6 +160,7 @@
 
   public DataResourceConsumer dataResourceConsumer;
   public FeatureSplitConfiguration featureSplitConfiguration;
+  public StartupConfiguration startupConfiguration;
 
   public List<Consumer<InspectorImpl>> outputInspections = Collections.emptyList();
 
@@ -1637,7 +1639,6 @@
     public boolean allowInvokeErrors = false;
     public boolean allowUnnecessaryDontWarnWildcards = true;
     public boolean allowUnusedDontWarnRules = true;
-    public boolean disableL8AnnotationRemoval = false;
     public boolean reportUnusedProguardConfigurationRules = false;
     public boolean alwaysUseExistingAccessInfoCollectionsInMemberRebinding = true;
     public boolean alwaysUsePessimisticRegisterAllocation = false;
diff --git a/src/main/java/com/android/tools/r8/utils/Timing.java b/src/main/java/com/android/tools/r8/utils/Timing.java
index c1046e9..5367c26 100644
--- a/src/main/java/com/android/tools/r8/utils/Timing.java
+++ b/src/main/java/com/android/tools/r8/utils/Timing.java
@@ -371,6 +371,15 @@
     stack.push(child);
   }
 
+  public <E extends Exception> void time(String title, ThrowingAction<E> action) throws E {
+    begin(title);
+    try {
+      action.execute();
+    } finally {
+      end();
+    }
+  }
+
   public <T> T time(String title, Supplier<T> supplier) {
     begin(title);
     try {
diff --git a/src/test/java/com/android/tools/r8/KotlinCompilerTool.java b/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
index 3cd4941..9b81396 100644
--- a/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
+++ b/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
@@ -6,6 +6,7 @@
 import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.MAX_SUPPORTED_VERSION;
 import static com.android.tools.r8.ToolHelper.isWindows;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
@@ -303,9 +304,17 @@
 
   /** Compile asserting success and return the output path. */
   public Path compile() throws IOException {
+    return compile(false);
+  }
+
+  public Path compile(boolean expectingFailure) throws IOException {
     Path output = getOrCreateOutputPath();
     ProcessResult result = compileInternal(output);
-    assertEquals(result.toString(), result.exitCode, 0);
+    if (expectingFailure) {
+      assertNotEquals(result.toString(), result.exitCode, 0);
+    } else {
+      assertEquals(result.toString(), result.exitCode, 0);
+    }
     return output;
   }
 
diff --git a/src/test/java/com/android/tools/r8/KotlinTestParameters.java b/src/test/java/com/android/tools/r8/KotlinTestParameters.java
index 2ac3f87..0ddd80e 100644
--- a/src/test/java/com/android/tools/r8/KotlinTestParameters.java
+++ b/src/test/java/com/android/tools/r8/KotlinTestParameters.java
@@ -52,6 +52,10 @@
     return !isNewerThanOrEqualTo(otherVersion);
   }
 
+  public boolean isOlderThanMinSupported() {
+    return isOlderThan(KotlinCompilerVersion.MIN_SUPPORTED_VERSION);
+  }
+
   public boolean isFirst() {
     return index == 0;
   }
@@ -68,6 +72,7 @@
   public static class Builder {
 
     private Predicate<KotlinCompilerVersion> compilerFilter = c -> false;
+    private Predicate<KotlinCompilerVersion> oldCompilerFilter = c -> true;
     private Predicate<KotlinTargetVersion> targetVersionFilter = t -> false;
     private boolean withDevCompiler =
         System.getProperty("com.android.tools.r8.kotlincompilerdev") != null;
@@ -105,11 +110,21 @@
       return this;
     }
 
+    public Builder withOldCompilers() {
+      this.withOldCompilers = true;
+      return this;
+    }
+
     public Builder withOldCompilersIfSet() {
       assumeTrue(withOldCompilers);
       return this;
     }
 
+    public Builder withOldCompilersStartingFrom(KotlinCompilerVersion minOldVersion) {
+      oldCompilerFilter = oldCompilerFilter.and(v -> v.isGreaterThanOrEqualTo(minOldVersion));
+      return this;
+    }
+
     public Builder withAllTargetVersions() {
       withTargetVersionFilter(t -> t != KotlinTargetVersion.NONE);
       return this;
@@ -139,8 +154,8 @@
         compilerVersions =
             Arrays.stream(KotlinCompilerVersion.values())
                 .filter(c -> c.isLessThan(KotlinCompilerVersion.MIN_SUPPORTED_VERSION))
+                .filter(c -> oldCompilerFilter.test(c))
                 .collect(Collectors.toList());
-
       } else {
         compilerVersions =
             KotlinCompilerVersion.getSupported().stream()
@@ -162,7 +177,7 @@
           }
         }
       }
-      assert !testParameters.isEmpty();
+      assert !testParameters.isEmpty() || withOldCompilers;
       return new KotlinTestParametersCollection(testParameters);
     }
   }
diff --git a/src/test/java/com/android/tools/r8/L8TestBuilder.java b/src/test/java/com/android/tools/r8/L8TestBuilder.java
index 072da5a..e672f87 100644
--- a/src/test/java/com/android/tools/r8/L8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/L8TestBuilder.java
@@ -139,11 +139,6 @@
     return this;
   }
 
-  public L8TestBuilder setDisableL8AnnotationRemoval(boolean disableL8AnnotationRemoval) {
-    return addOptionsModifier(
-        options -> options.testing.disableL8AnnotationRemoval = disableL8AnnotationRemoval);
-  }
-
   public L8TestCompileResult compile()
       throws IOException, CompilationFailedException, ExecutionException {
     // We wrap exceptions in a RuntimeException to call this from a lambda.
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index f0c648b..ccdd0ca 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -2237,7 +2237,7 @@
       builder.appendArtOption("-Xnoimage-dex2oat");
     }
     for (String s : ToolHelper.getBootLibs(dexVm)) {
-      builder.appendBootClassPath(new File(s).getCanonicalPath());
+      builder.appendBootClasspath(new File(s).getCanonicalPath());
     }
     builder.setMainClass(JUNIT_TEST_RUNNER);
     builder.appendProgramArgument(fullClassName);
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 0480694..b96cef4 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -179,7 +179,7 @@
     for (int i = 2; i < args.length; i++) {
       args[i] = featureDependencies[i - 2].toString();
     }
-    return runArt(runtime, additionalRunClassPath, mainClassSubject.getFinalName(), args);
+    return runArt(runtime, mainClassSubject.getFinalName(), args);
   }
 
   public String getProguardMap() {
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index 9ab97e7..af079d9 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -33,6 +33,7 @@
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ObjectArrays;
+import java.io.File;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.nio.file.Path;
@@ -56,6 +57,7 @@
   public final int minApiLevel;
   private final OutputMode outputMode;
   final List<Path> additionalRunClassPath = new ArrayList<>();
+  final List<Path> additionalBootClasspath = new ArrayList<>();
   final List<String> vmArguments = new ArrayList<>();
   private boolean withArt6Plus64BitsLib = false;
   private boolean withArtFrameworks = true;
@@ -164,12 +166,10 @@
       case DEX:
         return runArt(
             new DexRuntime(ToolHelper.getDexVm()),
-            additionalRunClassPath,
             mainClassSubject.getFinalName());
       case CF:
         return runJava(
             TestRuntime.getDefaultJavaRuntime(),
-            additionalRunClassPath,
             mainClassSubject.getFinalName());
       default:
         throw new Unreachable();
@@ -207,12 +207,11 @@
     }
     assertThat("Did you forget a keep rule for the main method?", mainClassSubject, isPresent());
     if (runtime.isDex()) {
-      return runArt(runtime, additionalRunClassPath, mainClassSubject.getFinalName(), args);
+      return runArt(runtime, mainClassSubject.getFinalName(), args);
     }
     assert runtime.isCf();
     return runJava(
         runtime,
-        additionalRunClassPath,
         ObjectArrays.concat(mainClassSubject.getFinalName(), args));
   }
 
@@ -256,6 +255,38 @@
     }
   }
 
+  public CR addBootClasspathClasses(Class<?>... classes) throws Exception {
+    return addBootClasspathClasses(Arrays.asList(classes));
+  }
+
+  public CR addBootClasspathClasses(List<Class<?>> classes) throws Exception {
+    if (getBackend() == Backend.DEX) {
+      additionalBootClasspath.add(
+          testForD8(state.getTempFolder())
+              .addProgramClasses(classes)
+              .setMinApi(minApiLevel)
+              .compile()
+              .writeToZip());
+      return self();
+    }
+    assert getBackend() == Backend.CF;
+    try {
+      Path path = state.getNewTempFolder().resolve("runtime-classes.jar");
+      ArchiveConsumer consumer = new ArchiveConsumer(path);
+      for (Class<?> clazz : classes) {
+        consumer.accept(
+            ByteDataView.of(ToolHelper.getClassAsBytes(clazz)),
+            DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName()),
+            null);
+      }
+      consumer.finished(null);
+      additionalBootClasspath.add(path);
+      return self();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   public CR addDesugaredCoreLibraryRunClassPath(
       Function<AndroidApiLevel, Path> classPathSupplier, AndroidApiLevel minAPILevel) {
     addRunClasspathFiles(classPathSupplier.apply(minAPILevel));
@@ -523,30 +554,29 @@
     }
   }
 
-  private RR runJava(TestRuntime runtime, List<Path> additionalClassPath, String... arguments)
-      throws IOException {
+  private RR runJava(TestRuntime runtime, String... arguments) throws IOException {
     assert runtime != null;
     Path out = state.getNewTempFolder().resolve("out.zip");
     app.writeToZip(out, OutputMode.ClassFile);
-    List<Path> classPath = ImmutableList.<Path>builder()
-        .addAll(additionalClassPath)
-        .add(out)
-        .build();
-    ProcessResult result = ToolHelper.runJava(runtime.asCf(), vmArguments, classPath, arguments);
+    List<Path> classPath =
+        ImmutableList.<Path>builder().addAll(additionalRunClassPath).add(out).build();
+    ProcessResult result =
+        ToolHelper.runJava(
+            runtime.asCf(), vmArguments, additionalBootClasspath, classPath, arguments);
     return createRunResult(runtime, result);
   }
 
-  RR runArt(
-      TestRuntime runtime, List<Path> additionalClassPath, String mainClass, String... arguments)
-      throws IOException {
+  RR runArt(TestRuntime runtime, String mainClass, String... arguments) throws IOException {
     DexVm vm = runtime.asDex().getVm();
     // TODO(b/127785410): Always assume a non-null runtime.
     Path out = state.getNewTempFolder().resolve("out.zip");
     app.writeToZip(out, OutputMode.DexIndexed);
-    List<String> classPath = ImmutableList.<String>builder()
-        .addAll(additionalClassPath.stream().map(Path::toString).collect(Collectors.toList()))
-        .add(out.toString())
-        .build();
+    List<String> classPath =
+        ImmutableList.<String>builder()
+            .addAll(
+                additionalRunClassPath.stream().map(Path::toString).collect(Collectors.toList()))
+            .add(out.toString())
+            .build();
     Consumer<ArtCommandBuilder> commandConsumer =
         withArt6Plus64BitsLib && vm.getVersion().isNewerThanOrEqual(DexVm.Version.V6_0_1)
             ? builder -> builder.appendArtOption("--64")
@@ -554,6 +584,22 @@
     commandConsumer =
         commandConsumer.andThen(
             builder -> {
+              if (!additionalBootClasspath.isEmpty()) {
+                DexVm dexVm = runtime.asDex().getVm();
+                if (dexVm.isNewerThan(DexVm.ART_4_4_4_HOST)) {
+                  builder.appendArtOption("-Ximage:/system/non/existent/image.art");
+                  builder.appendArtOption("-Xnoimage-dex2oat");
+                }
+                try {
+                  for (String s : ToolHelper.getBootLibs(dexVm)) {
+                    builder.appendBootClasspath(new File(s).getCanonicalPath());
+                  }
+                } catch (Exception e) {
+                  throw new RuntimeException();
+                }
+                additionalBootClasspath.forEach(
+                    path -> builder.appendBootClasspath(path.toString()));
+              }
               for (String vmArgument : vmArguments) {
                 builder.appendArtOption(vmArgument);
               }
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 2d0cc12..57fabd1 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -422,7 +422,7 @@
     protected List<String> classpaths = new ArrayList<>();
     protected String mainClass;
     protected List<String> programArguments = new ArrayList<>();
-    protected List<String> bootClassPaths = new ArrayList<>();
+    protected List<String> bootClasspaths = new ArrayList<>();
     protected String executionDirectory;
 
     public CommandBuilder appendArtOption(String option) {
@@ -450,8 +450,8 @@
       return this;
     }
 
-    public CommandBuilder appendBootClassPath(String lib) {
-      bootClassPaths.add(lib);
+    public CommandBuilder appendBootClasspath(String lib) {
+      bootClasspaths.add(lib);
       return this;
     }
 
@@ -475,13 +475,13 @@
         builder.append(entry.getValue());
         result.add(builder.toString());
       }
+      if (!bootClasspaths.isEmpty()) {
+        result.add("-Xbootclasspath:" + String.join(":", bootClasspaths));
+      }
       if (!classpaths.isEmpty()) {
         result.add("-cp");
         result.add(String.join(":", classpaths));
       }
-      if (!bootClassPaths.isEmpty()) {
-        result.add("-Xbootclasspath:" + String.join(":", bootClassPaths));
-      }
       if (mainClass != null) {
         result.add(mainClass);
       }
@@ -555,7 +555,7 @@
           .setVmOptions(options)
           .setSystemProperties(systemProperties)
           .setClasspath(toFileList(classpaths))
-          .setBootClasspath(toFileList(bootClassPaths))
+          .setBootClasspath(toFileList(bootClasspaths))
           .setMainClass(mainClass)
           .setProgramArguments(programArguments);
     }
@@ -1416,12 +1416,28 @@
   public static ProcessResult runJava(
       CfRuntime runtime, List<String> vmArgs, List<Path> classpath, String... args)
       throws IOException {
-    String cp =
-        classpath.stream().map(Path::toString).collect(Collectors.joining(CLASSPATH_SEPARATOR));
+    return runJava(runtime, vmArgs, ImmutableList.of(), classpath, args);
+  }
+
+  public static ProcessResult runJava(
+      CfRuntime runtime,
+      List<String> vmArgs,
+      List<Path> bootClasspaths,
+      List<Path> classpath,
+      String... args)
+      throws IOException {
     List<String> cmdline = new ArrayList<>(Arrays.asList(runtime.getJavaExecutable().toString()));
     cmdline.addAll(vmArgs);
+    if (!bootClasspaths.isEmpty()) {
+      cmdline.add(
+          "-Xbootclasspath/a:"
+              + bootClasspaths.stream()
+                  .map(Path::toString)
+                  .collect(Collectors.joining(CLASSPATH_SEPARATOR)));
+    }
     cmdline.add("-cp");
-    cmdline.add(cp);
+    cmdline.add(
+        classpath.stream().map(Path::toString).collect(Collectors.joining(CLASSPATH_SEPARATOR)));
     cmdline.addAll(Arrays.asList(args));
     ProcessBuilder builder = new ProcessBuilder(cmdline);
     return runProcess(builder);
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineMissingInterfaceTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineMissingInterfaceTest.java
new file mode 100644
index 0000000..4f89220
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineMissingInterfaceTest.java
@@ -0,0 +1,93 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.testing.AndroidBuildVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelInlineMissingInterfaceTest extends TestBase {
+
+  private final AndroidApiLevel libraryAdditionApiLevel = AndroidApiLevel.M;
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    boolean isApiLevel =
+        parameters.isDexRuntime()
+            && parameters.getApiLevel().isGreaterThanOrEqualTo(libraryAdditionApiLevel);
+    testForR8(parameters.getBackend())
+        .addProgramClasses(ProgramClass.class, VerificationError.class, Main.class)
+        .addLibraryClasses(LibraryClass.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .addAndroidBuildVersion()
+        .apply(setMockApiLevelForClass(LibraryClass.class, libraryAdditionApiLevel))
+        .apply(
+            setMockApiLevelForDefaultInstanceInitializer(
+                LibraryClass.class, libraryAdditionApiLevel))
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .compile()
+        .inspect(
+            inspector -> {
+              // Dex2Oat do not complain about missing super interfaces since these are not verified
+              // the same way as super types. We therefore expect the class to be absent.
+              assertThat(inspector.clazz(VerificationError.class), Matchers.isAbsent());
+            })
+        .applyIf(isApiLevel, b -> b.addRunClasspathClasses(LibraryClass.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLinesIf(isApiLevel, "Hello World")
+        .assertSuccessWithOutputLinesIf(!isApiLevel, "Lower Api Level");
+  }
+
+  public interface LibraryClass {}
+
+  public static class ProgramClass implements LibraryClass {
+
+    @NeverInline
+    public void foo() {
+      System.out.println("Hello World");
+    }
+  }
+
+  public static class VerificationError {
+
+    public static ProgramClass create() {
+      return new ProgramClass();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (AndroidBuildVersion.VERSION >= 23) {
+        VerificationError.create().foo();
+      } else {
+        System.out.println("Lower Api Level");
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineMissingSuperTypeTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineMissingSuperTypeTest.java
new file mode 100644
index 0000000..4e05ffb
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineMissingSuperTypeTest.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.testing.AndroidBuildVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelInlineMissingSuperTypeTest extends TestBase {
+
+  private final AndroidApiLevel libraryAdditionApiLevel = AndroidApiLevel.M;
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    boolean isMockedApiLevel =
+        parameters.isDexRuntime()
+            && parameters.getApiLevel().isGreaterThanOrEqualTo(libraryAdditionApiLevel);
+    testForR8(parameters.getBackend())
+        .addProgramClasses(ProgramClass.class, VerificationError.class, Main.class)
+        .addLibraryClasses(LibraryClass.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .addAndroidBuildVersion()
+        .apply(setMockApiLevelForClass(LibraryClass.class, libraryAdditionApiLevel))
+        .apply(
+            setMockApiLevelForDefaultInstanceInitializer(
+                LibraryClass.class, libraryAdditionApiLevel))
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .compile()
+        .inspect(
+            inspector -> {
+              // TODO(b/207832084): Should be present and only inlined from M.
+              assertThat(inspector.clazz(VerificationError.class), Matchers.isAbsent());
+            })
+        .applyIf(isMockedApiLevel, b -> b.addRunClasspathClasses(LibraryClass.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLinesIf(isMockedApiLevel, "Hello World")
+        .assertSuccessWithOutputLinesIf(!isMockedApiLevel, "Lower Api Level");
+  }
+
+  public static class LibraryClass {}
+
+  public static class ProgramClass extends LibraryClass {
+
+    @NeverInline
+    public void foo() {
+      System.out.println("Hello World");
+    }
+  }
+
+  public static class VerificationError {
+
+    public static ProgramClass create() {
+      return new ProgramClass();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (AndroidBuildVersion.VERSION >= 23) {
+        VerificationError.create().foo();
+      } else {
+        System.out.println("Lower Api Level");
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockClassTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockClassTest.java
new file mode 100644
index 0000000..4125cc2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockClassTest.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeFalse;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.testing.AndroidBuildVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelMockClassTest extends TestBase {
+
+  private final AndroidApiLevel mockLevel = AndroidApiLevel.M;
+
+  @Parameter public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    // TODO(b/197078995): Make this work on 12.
+    assumeFalse(
+        parameters.isDexRuntime() && parameters.getDexRuntimeVersion().isEqualTo(Version.V12_0_0));
+    boolean isMockApiLevel =
+        parameters.isDexRuntime() && parameters.getApiLevel().isGreaterThanOrEqualTo(mockLevel);
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class)
+        .addLibraryClasses(LibraryClass.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addAndroidBuildVersion()
+        .apply(setMockApiLevelForClass(LibraryClass.class, mockLevel))
+        .apply(setMockApiLevelForDefaultInstanceInitializer(LibraryClass.class, mockLevel))
+        .compile()
+        .applyIf(
+            parameters.isDexRuntime()
+                && parameters.getRuntime().maxSupportedApiLevel().isGreaterThanOrEqualTo(mockLevel),
+            b -> b.addBootClasspathClasses(LibraryClass.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLinesIf(isMockApiLevel, "LibraryClass::foo")
+        .assertSuccessWithOutputLinesIf(!isMockApiLevel, "Hello World")
+        .inspect(
+            inspector ->
+                // TODO(b/204982782): These should be stubbed for api-level 1-23.
+                assertThat(inspector.clazz(LibraryClass.class), Matchers.isAbsent()));
+  }
+
+  // Only present from api level 23.
+  public static class LibraryClass {
+
+    public void foo() {
+      System.out.println("LibraryClass::foo");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (AndroidBuildVersion.VERSION >= 23) {
+        new LibraryClass().foo();
+      } else {
+        System.out.println("Hello World");
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockInheritedClassTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockInheritedClassTest.java
new file mode 100644
index 0000000..46a9fe8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockInheritedClassTest.java
@@ -0,0 +1,88 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeFalse;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.testing.AndroidBuildVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelMockInheritedClassTest extends TestBase {
+
+  private final AndroidApiLevel mockLevel = AndroidApiLevel.M;
+
+  @Parameter public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    // TODO(b/197078995): Make this work on 12.
+    assumeFalse(
+        parameters.isDexRuntime() && parameters.getDexRuntimeVersion().isEqualTo(Version.V12_0_0));
+    boolean isMockApiLevel =
+        parameters.isDexRuntime() && parameters.getApiLevel().isGreaterThanOrEqualTo(mockLevel);
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, ProgramClass.class)
+        .addLibraryClasses(LibraryClass.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepClassRules(ProgramClass.class)
+        .addAndroidBuildVersion()
+        .apply(setMockApiLevelForClass(LibraryClass.class, mockLevel))
+        .apply(setMockApiLevelForDefaultInstanceInitializer(LibraryClass.class, mockLevel))
+        .compile()
+        .applyIf(
+            parameters.isDexRuntime()
+                && parameters.getRuntime().maxSupportedApiLevel().isGreaterThanOrEqualTo(mockLevel),
+            b -> b.addBootClasspathClasses(LibraryClass.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLinesIf(isMockApiLevel, "ProgramClass::foo")
+        .assertSuccessWithOutputLinesIf(!isMockApiLevel, "Hello World")
+        .inspect(
+            inspector ->
+                // TODO(b/204982782): These should be stubbed for api-level 1-23.
+                assertThat(inspector.clazz(LibraryClass.class), Matchers.isAbsent()));
+  }
+
+  // Only present from api level 23.
+  public static class LibraryClass {}
+
+  public static class ProgramClass extends LibraryClass {
+
+    public void foo() {
+      System.out.println("ProgramClass::foo");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (AndroidBuildVersion.VERSION >= 23) {
+        new ProgramClass().foo();
+      } else {
+        System.out.println("Hello World");
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMethodMissingClassTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMethodMissingClassTest.java
new file mode 100644
index 0000000..6b91898
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMethodMissingClassTest.java
@@ -0,0 +1,128 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForMethod;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeFalse;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.testing.AndroidBuildVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelMockMethodMissingClassTest extends TestBase {
+
+  private final AndroidApiLevel initialLibraryMockLevel = AndroidApiLevel.M;
+  private final AndroidApiLevel finalLibraryMethodLevel = AndroidApiLevel.O_MR1;
+
+  @Parameter public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    // TODO(b/197078995): Make this work on 12.
+    assumeFalse(
+        parameters.isDexRuntime() && parameters.getDexRuntimeVersion().isEqualTo(Version.V12_0_0));
+    boolean preMockApis =
+        parameters.isCfRuntime() || parameters.getApiLevel().isLessThan(initialLibraryMockLevel);
+    boolean postMockApis =
+        !preMockApis && parameters.getApiLevel().isGreaterThanOrEqualTo(finalLibraryMethodLevel);
+    boolean betweenMockApis = !preMockApis && !postMockApis;
+    Method addedOn23 = LibraryClass.class.getMethod("addedOn23");
+    Method adeddOn27 = LibraryClass.class.getMethod("addedOn27");
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class)
+        .addLibraryClasses(LibraryClass.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addAndroidBuildVersion()
+        .apply(setMockApiLevelForClass(LibraryClass.class, initialLibraryMockLevel))
+        .apply(
+            setMockApiLevelForDefaultInstanceInitializer(
+                LibraryClass.class, initialLibraryMockLevel))
+        .apply(setMockApiLevelForMethod(addedOn23, initialLibraryMockLevel))
+        .apply(setMockApiLevelForMethod(adeddOn27, finalLibraryMethodLevel))
+        .compile()
+        .applyIf(
+            parameters.isDexRuntime()
+                && parameters
+                    .getRuntime()
+                    .maxSupportedApiLevel()
+                    .isGreaterThanOrEqualTo(initialLibraryMockLevel),
+            b -> b.addBootClasspathClasses(LibraryClass.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLinesIf(preMockApis, "Hello World")
+        .assertSuccessWithOutputLinesIf(
+            betweenMockApis,
+            "LibraryClass::addedOn23",
+            "LibraryClass::missingAndReferenced",
+            "Hello World")
+        .assertSuccessWithOutputLinesIf(
+            postMockApis,
+            "LibraryClass::addedOn23",
+            "LibraryClass::missingAndReferenced",
+            "LibraryCLass::addedOn27",
+            "Hello World")
+        .inspect(
+            inspector -> {
+              // TODO(b/204982782): Should be stubbed for api-level 1-23 with methods.
+              assertThat(
+                  inspector.clazz(ApiModelMockClassTest.LibraryClass.class), Matchers.isAbsent());
+            });
+  }
+
+  // Only present from api level 23.
+  public static class LibraryClass {
+
+    public void addedOn23() {
+      System.out.println("LibraryClass::addedOn23");
+    }
+
+    public void addedOn27() {
+      System.out.println("LibraryCLass::addedOn27");
+    }
+
+    public void missingAndReferenced() {
+      System.out.println("LibraryClass::missingAndReferenced");
+    }
+
+    public void missingNotReferenced() {
+      System.out.println("LibraryClass::missingNotReferenced");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (AndroidBuildVersion.VERSION >= 23) {
+        LibraryClass libraryClass = new LibraryClass();
+        libraryClass.addedOn23();
+        libraryClass.missingAndReferenced();
+        if (AndroidBuildVersion.VERSION >= 27) {
+          libraryClass.addedOn27();
+        }
+      }
+      System.out.println("Hello World");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockSuperChainClassTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockSuperChainClassTest.java
new file mode 100644
index 0000000..285f3d0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockSuperChainClassTest.java
@@ -0,0 +1,113 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeFalse;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.testing.AndroidBuildVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelMockSuperChainClassTest extends TestBase {
+
+  private final AndroidApiLevel mockApiLevel = AndroidApiLevel.N;
+  private final AndroidApiLevel lowerMockApiLevel = AndroidApiLevel.M;
+
+  @Parameter public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    // TODO(b/197078995): Make this work on 12.
+    assumeFalse(
+        parameters.isDexRuntime() && parameters.getDexRuntimeVersion().isEqualTo(Version.V12_0_0));
+    boolean isMockApiLevel =
+        parameters.isDexRuntime() && parameters.getApiLevel().isGreaterThanOrEqualTo(mockApiLevel);
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, ProgramClass.class)
+        .addLibraryClasses(LibraryClass.class, OtherLibraryClass.class, LibraryInterface.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepClassRules(ProgramClass.class)
+        .addAndroidBuildVersion()
+        .apply(setMockApiLevelForClass(LibraryClass.class, lowerMockApiLevel))
+        .apply(setMockApiLevelForDefaultInstanceInitializer(LibraryClass.class, lowerMockApiLevel))
+        .apply(setMockApiLevelForClass(OtherLibraryClass.class, mockApiLevel))
+        .apply(setMockApiLevelForDefaultInstanceInitializer(OtherLibraryClass.class, mockApiLevel))
+        .apply(setMockApiLevelForClass(LibraryInterface.class, lowerMockApiLevel))
+        .compile()
+        .applyIf(
+            parameters.isDexRuntime()
+                && parameters
+                    .getRuntime()
+                    .maxSupportedApiLevel()
+                    .isGreaterThanOrEqualTo(lowerMockApiLevel),
+            b -> b.addBootClasspathClasses(LibraryClass.class, LibraryInterface.class))
+        .applyIf(
+            parameters.isDexRuntime()
+                && parameters
+                    .getRuntime()
+                    .maxSupportedApiLevel()
+                    .isGreaterThanOrEqualTo(mockApiLevel),
+            b -> b.addBootClasspathClasses(OtherLibraryClass.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLinesIf(isMockApiLevel, "ProgramClass::foo")
+        .assertSuccessWithOutputLinesIf(!isMockApiLevel, "Hello World")
+        .inspect(
+            inspector -> {
+              // TODO(b/204982782): These should be stubbed out for api-level 1-23.
+              assertThat(inspector.clazz(LibraryClass.class), not(Matchers.isPresent()));
+              assertThat(inspector.clazz(LibraryInterface.class), not(Matchers.isPresent()));
+              // TODO(b/204982782): This should be stubbed out for api-level 1-24.
+              assertThat(inspector.clazz(OtherLibraryClass.class), not(Matchers.isPresent()));
+            });
+  }
+
+  // Only present from api level 23.
+  public static class LibraryClass {}
+
+  // Only present from api level 23
+  public interface LibraryInterface {}
+
+  // Only present from api level 24
+  public static class OtherLibraryClass extends LibraryClass {}
+
+  public static class ProgramClass extends OtherLibraryClass implements LibraryInterface {
+
+    public void foo() {
+      System.out.println("ProgramClass::foo");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (AndroidBuildVersion.VERSION >= 24) {
+        new ProgramClass().foo();
+      } else {
+        System.out.println("Hello World");
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfTryCatchReferenceTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfTryCatchReferenceTest.java
new file mode 100644
index 0000000..9565973
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfTryCatchReferenceTest.java
@@ -0,0 +1,122 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForClass;
+import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForDefaultInstanceInitializer;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelNoInliningOfTryCatchReferenceTest extends TestBase {
+
+  private final AndroidApiLevel exceptionApiLevel = AndroidApiLevel.L_MR1;
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Method tryCatch = TestClass.class.getDeclaredMethod("testTryCatch");
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, TestClass.class, Caller.class, KeptClass.class)
+        .addLibraryClasses(ApiException.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMethodRules(
+            Reference.methodFromMethod(KeptClass.class.getDeclaredMethod("keptMethodThatMayThrow")))
+        .addKeepMainRule(Main.class)
+        .apply(setMockApiLevelForClass(ApiException.class, exceptionApiLevel))
+        .apply(setMockApiLevelForDefaultInstanceInitializer(ApiException.class, exceptionApiLevel))
+        .apply(ApiModelingTestHelper::enableApiCallerIdentification)
+        .enableInliningAnnotations()
+        .addHorizontallyMergedClassesInspector(
+            horizontallyMergedClassesInspector -> {
+              if (parameters.isDexRuntime()
+                  && parameters.getApiLevel().isGreaterThanOrEqualTo(exceptionApiLevel)) {
+                horizontallyMergedClassesInspector.assertClassesMerged(
+                    TestClass.class, Caller.class);
+              } else {
+                horizontallyMergedClassesInspector.assertNoClassesMerged();
+              }
+            })
+        .apply(
+            ApiModelingTestHelper.addTracedApiReferenceLevelCallBack(
+                (reference, apiLevel) -> {
+                  if (reference.equals(Reference.methodFromMethod(tryCatch))) {
+                    assertEquals(
+                        exceptionApiLevel.max(
+                            parameters.isCfRuntime()
+                                ? AndroidApiLevel.B
+                                : parameters.getApiLevel()),
+                        apiLevel);
+                  }
+                }))
+        .compile()
+        .applyIf(
+            parameters.isCfRuntime()
+                || parameters
+                    .asDexRuntime()
+                    .getMinApiLevel()
+                    .isGreaterThanOrEqualTo(exceptionApiLevel),
+            b -> b.addRunClasspathClasses(ApiException.class))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello World");
+  }
+
+  public static class ApiException extends RuntimeException {}
+
+  public static class TestClass {
+
+    public static void testTryCatch() {
+      try {
+        KeptClass.keptMethodThatMayThrow();
+      } catch (ApiException e) {
+        System.out.println("Caught ApiException");
+      }
+    }
+  }
+
+  public static class KeptClass {
+
+    public static void keptMethodThatMayThrow() {
+      if (System.currentTimeMillis() == 0) {
+        throw new ApiException();
+      }
+      System.out.println("Hello World");
+    }
+  }
+
+  public static class Caller {
+
+    @NeverInline
+    public static void callTestClass() {
+      TestClass.testTryCatch();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      Caller.callTestClass();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
index 0e373e9..f1498b6 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
@@ -7,6 +7,7 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+import com.android.tools.r8.AlwaysInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -51,6 +52,11 @@
             "  synthetic void registerObserver(...);",
             "}")
         .allowAccessModification()
+        .addAlwaysInliningAnnotations()
+        .addKeepRules(
+            "-alwaysinline class * { @"
+                + AlwaysInline.class.getTypeName()
+                + " !synthetic <methods>; }")
         .enableNeverClassInliningAnnotations()
         // TODO(b/120764902): MemberSubject.getOriginalName() is not working without the @NeverMerge
         //  annotation on DataAdapter.Observer.
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleObservableList.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleObservableList.java
index e6eceb7..b99ee02 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleObservableList.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleObservableList.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.bridgeremoval.bridgestokeep;
 
+import com.android.tools.r8.AlwaysInline;
 import com.android.tools.r8.bridgeremoval.bridgestokeep.ObservableList.Observer;
 import java.util.ArrayList;
 import java.util.List;
@@ -13,6 +14,7 @@
 
   private List<O> observers = new ArrayList<>();
 
+  @AlwaysInline
   @Override
   public void registerObserver(O observer) {
     if (observer != null && observers != null && !observers.contains(observer)) {
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
index cdecb76..12bbdf3 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
@@ -50,7 +50,10 @@
 
   private static final String HELLO_NAME = "hello.Hello";
   private static final String[] KEEP_HELLO = {
-    "-keep class " + HELLO_NAME + " {", "  public static void main(...);", "}",
+    "-keep class " + HELLO_NAME + " {",
+    "  public static void main(...);",
+    "}",
+    "-allowaccessmodification"
   };
 
   private static Pair<Path, Path> r8R8Debug;
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java
new file mode 100644
index 0000000..d594603
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java
@@ -0,0 +1,121 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.classmerging.horizontal;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.experimental.startup.StartupConfiguration;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.google.common.collect.ImmutableList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class HorizontalClassMergingWithStartupClassesTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public List<Class<?>> startupClasses;
+
+  @Parameters(name = "{0}, startup classes: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(),
+        ImmutableList.of(
+            Collections.emptyList(), ImmutableList.of(StartupA.class, StartupB.class)));
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepClassAndMembersRules(Main.class)
+        .addOptionsModification(
+            options -> {
+              DexItemFactory dexItemFactory = options.dexItemFactory();
+              options.startupConfiguration =
+                  new StartupConfiguration(
+                      startupClasses.stream()
+                          .map(clazz -> toDexType(clazz, dexItemFactory))
+                          .collect(Collectors.toList()));
+            })
+        .addHorizontallyMergedClassesInspector(
+            inspector ->
+                inspector
+                    .applyIf(
+                        startupClasses.isEmpty(),
+                        i ->
+                            i.assertIsCompleteMergeGroup(
+                                StartupA.class,
+                                StartupB.class,
+                                OnClickHandlerA.class,
+                                OnClickHandlerB.class),
+                        i ->
+                            i.assertIsCompleteMergeGroup(StartupA.class, StartupB.class)
+                                .assertIsCompleteMergeGroup(
+                                    OnClickHandlerA.class, OnClickHandlerB.class))
+                    .assertNoOtherClassesMerged())
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("StartupA", "StartupB");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      StartupA.foo();
+      StartupB.bar();
+    }
+
+    // @Keep
+    public void onClick() {
+      OnClickHandlerA.baz();
+      OnClickHandlerB.qux();
+    }
+  }
+
+  static class StartupA {
+
+    @NeverInline
+    static void foo() {
+      System.out.println("StartupA");
+    }
+  }
+
+  static class StartupB {
+
+    @NeverInline
+    static void bar() {
+      System.out.println("StartupB");
+    }
+  }
+
+  static class OnClickHandlerA {
+
+    @NeverInline
+    static void baz() {
+      System.out.println("IdleA");
+    }
+  }
+
+  static class OnClickHandlerB {
+
+    @NeverInline
+    static void qux() {
+      System.out.println("IdleB");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
index 645588c..e57aaa9 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
@@ -163,10 +163,6 @@
               L8TestBuilder::setDebug)
           .addOptionsModifier(optionsModifier)
           .setDesugarJDKLibsConfiguration(ToolHelper.DESUGAR_LIB_CONVERSIONS)
-          // If we compile extended library here, it means we use TestNG. TestNG requires
-          // annotations, hence we disable annotation removal. This implies that extra warnings are
-          // generated.
-          .setDisableL8AnnotationRemoval(!additionalProgramFiles.isEmpty())
           .compile()
           .applyIf(
               additionalProgramFiles.isEmpty(),
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
index d07e819..e3afc1c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
@@ -68,9 +68,9 @@
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
     if (method.getHolderType().toSourceString().endsWith("$C")) {
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+      assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
     } else {
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNull();
+      assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNull();
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
index eb665f8..847bf55 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
@@ -63,9 +63,9 @@
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
     if (method.getHolderType().toSourceString().endsWith("$C")) {
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+      assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
     } else {
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNull();
+      assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNull();
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
index ee612f8..f55c70b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
@@ -58,7 +58,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+    assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
     assert callSiteOptimizationInfo.getAbstractArgumentValue(1).isUnknown();
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
index fed41d3..ca24f1f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
@@ -64,7 +64,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+    assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
     assert callSiteOptimizationInfo.getAbstractArgumentValue(1).isUnknown();
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
index 042ca95..39f33af 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
@@ -64,7 +64,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+    assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
     AbstractValue abstractValue = callSiteOptimizationInfo.getAbstractArgumentValue(1);
     assert abstractValue.isSingleStringValue()
         && abstractValue.asSingleStringValue().getDexString().toString().equals("nul");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
index 4c1b255..5c80990 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
@@ -56,8 +56,8 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(0).isDefinitelyNotNull();
-    assert callSiteOptimizationInfo.getAbstractArgumentValue(0).isUnknown();
+    assertTrue(callSiteOptimizationInfo.getDynamicType(0).isNotNullType());
+    assertTrue(callSiteOptimizationInfo.getAbstractArgumentValue(0).isUnknown());
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
index ba515db5..51593ba 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
@@ -62,11 +62,15 @@
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
     if (methodName.equals("m")) {
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+      assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
       assert callSiteOptimizationInfo.getAbstractArgumentValue(1).isUnknown();
     } else {
       assert methodName.equals("test");
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(0).isDefinitelyNotNull();
+      assert callSiteOptimizationInfo
+          .getDynamicType(0)
+          .asDynamicTypeWithUpperBound()
+          .getDynamicUpperBoundType()
+          .isDefinitelyNotNull();
       assert callSiteOptimizationInfo.getAbstractArgumentValue(0).isUnknown();
     }
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
index bbe45f0..1c5689d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
@@ -60,7 +60,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+    assert callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull();
     AbstractValue abstractValue = callSiteOptimizationInfo.getAbstractArgumentValue(1);
     if (method.getHolderType().toSourceString().endsWith("$A")) {
       assert abstractValue.isSingleStringValue()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
index 86a89ed..76daffe 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
@@ -13,7 +13,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -54,14 +53,12 @@
   }
 
   private void callSiteOptimizationInfoInspect(ProgramMethod method) {
-    assert method.getReference().name.toString().equals("test")
-        : "Unexpected revisit: " + method.toSourceString();
+    assertTrue(
+        "Unexpected revisit: " + method.toSourceString(),
+        method.getReference().name.toString().equals("test"));
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
-    assert upperBoundType.isDefinitelyNotNull();
-    assert upperBoundType.isClassType()
-        && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Base");
+    assertTrue(callSiteOptimizationInfo.getDynamicType(1).isNotNullType());
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
index 5b7fa84..5811471 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
@@ -63,12 +63,20 @@
         method.getOptimizationInfo().getArgumentInfos();
     TypeElement upperBoundType;
     if (methodName.equals("test")) {
-      upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
+      upperBoundType =
+          callSiteOptimizationInfo
+              .getDynamicType(1)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType();
     } else {
       // TODO(b/139246447): should avoid visiting <init>, which is trivial, default init!
       // For testing purpose, `Base` is not merged and kept. The system correctly caught that, when
       // the default initializer is invoked, the receiver had a refined type, `Sub1`.
-      upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
+      upperBoundType =
+          callSiteOptimizationInfo
+              .getDynamicType(0)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType();
     }
     assert upperBoundType.isDefinitelyNotNull();
     assert upperBoundType.isClassType()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
index 4c72b52..9fe54b4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
@@ -14,7 +14,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -64,10 +63,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
-    assert upperBoundType.isDefinitelyNotNull();
-    assert upperBoundType.isClassType()
-        && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Base");
+    assertTrue(callSiteOptimizationInfo.getDynamicType(1).isNotNullType());
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
index 0c4b99a..fd6b29e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -66,14 +67,18 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
-    assert upperBoundType.isDefinitelyNotNull();
+    DynamicType dynamicType = callSiteOptimizationInfo.getDynamicType(1);
     if (method.getHolderType().toSourceString().endsWith("$A")) {
+      TypeElement upperBoundType =
+          callSiteOptimizationInfo
+              .getDynamicType(1)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType();
+      assert upperBoundType.isDefinitelyNotNull();
       assert upperBoundType.isClassType()
           && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Sub1");
     } else {
-      assert upperBoundType.isClassType()
-          && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Base");
+      assertTrue(dynamicType.isNotNullType());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
index 0b46131..2055210 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -52,14 +51,12 @@
   }
 
   private void callSiteOptimizationInfoInspect(ProgramMethod method) {
-    assert method.getReference().name.toString().equals("test")
-        : "Unexpected revisit: " + method.toSourceString();
+    assertTrue(
+        "Unexpected revisit: " + method.toSourceString(),
+        method.getReference().name.toString().equals("test"));
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
-    assert upperBoundType.isDefinitelyNotNull();
-    assert upperBoundType.isClassType()
-        && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Base");
+    assertTrue(callSiteOptimizationInfo.getDynamicType(0).isNotNullType());
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
index dae8e30..a32daad 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
@@ -63,7 +63,11 @@
     // TODO(b/139246447): should avoid visiting <init>, which is trivial, default init!
     // For testing purpose, `Base` is not merged and kept. The system correctly caught that, when
     // the default initializer is invoked, the receiver had a refined type, `Sub1`.
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
+    TypeElement upperBoundType =
+        callSiteOptimizationInfo
+            .getDynamicType(0)
+            .asDynamicTypeWithUpperBound()
+            .getDynamicUpperBoundType();
     assert upperBoundType.isDefinitelyNotNull();
     assert upperBoundType.isClassType()
         && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Sub1");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
index 1952e51..b419ad2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
@@ -14,7 +14,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -62,13 +61,15 @@
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
     if (methodName.equals("m")) {
-      TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
-      assert upperBoundType.isDefinitelyNotNull();
-      assert upperBoundType.isClassType()
-          && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$Base");
+      assertTrue(callSiteOptimizationInfo.getDynamicType(1).isNotNullType());
     } else {
-      assert methodName.equals("test");
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(0).isDefinitelyNotNull();
+      assertTrue(methodName.equals("test"));
+      assertTrue(
+          callSiteOptimizationInfo
+              .getDynamicType(0)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType()
+              .isDefinitelyNotNull());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
index e863304..99a3ddf 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
@@ -63,12 +63,20 @@
         method.getOptimizationInfo().getArgumentInfos();
     TypeElement upperBoundType;
     if (methodName.equals("m")) {
-      upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
+      upperBoundType =
+          callSiteOptimizationInfo
+              .getDynamicType(1)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType();
     } else {
       // TODO(b/139246447): should avoid visiting <init>, which is trivial, default init!
       // For testing purpose, `Base` is not merged and kept. The system correctly caught that, when
       // the default initializer is invoked, the receiver had a refined type, `Sub1`.
-      upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(0);
+      upperBoundType =
+          callSiteOptimizationInfo
+              .getDynamicType(0)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType();
     }
     assert upperBoundType.isDefinitelyNotNull();
     assert upperBoundType.isClassType()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
index dc8820b..fd605ac 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
@@ -57,7 +57,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+    assert callSiteOptimizationInfo.getDynamicType(1).isNotNullType();
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
index f989c9f..a80798a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
@@ -64,7 +64,11 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
+    TypeElement upperBoundType =
+        callSiteOptimizationInfo
+            .getDynamicType(1)
+            .asDynamicTypeWithUpperBound()
+            .getDynamicUpperBoundType();
     assert upperBoundType.isNullable();
     assert upperBoundType.isClassType()
         && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$A");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
index 0c38b8f..b3988ee 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
@@ -63,7 +63,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(1).isDefinitelyNotNull();
+    assertTrue(callSiteOptimizationInfo.getDynamicType(1).getNullability().isDefinitelyNotNull());
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
index d386c2f..cf5cbe1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
@@ -55,7 +55,7 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    assert callSiteOptimizationInfo.getDynamicUpperBoundType(0).isDefinitelyNotNull();
+    assert callSiteOptimizationInfo.getDynamicType(0).isNotNullType();
   }
 
   private void inspect(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
index e473e4a..08bd75c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
@@ -62,13 +62,21 @@
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
     if (methodName.equals("m")) {
-      TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
+      TypeElement upperBoundType =
+          callSiteOptimizationInfo
+              .getDynamicType(1)
+              .asDynamicTypeWithUpperBound()
+              .getDynamicUpperBoundType();
       assert upperBoundType.isNullable();
       assert upperBoundType.isClassType()
           && upperBoundType.asClassType().getClassType().equals(method.getHolderType());
     } else {
       assert methodName.equals("test");
-      assert callSiteOptimizationInfo.getDynamicUpperBoundType(0).isDefinitelyNotNull();
+      assert callSiteOptimizationInfo
+          .getDynamicType(0)
+          .asDynamicTypeWithUpperBound()
+          .getDynamicUpperBoundType()
+          .isDefinitelyNotNull();
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
index 0ee8eca..c1c88a2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
@@ -60,7 +60,11 @@
         : "Unexpected revisit: " + method.toSourceString();
     CallSiteOptimizationInfo callSiteOptimizationInfo =
         method.getOptimizationInfo().getArgumentInfos();
-    TypeElement upperBoundType = callSiteOptimizationInfo.getDynamicUpperBoundType(1);
+    TypeElement upperBoundType =
+        callSiteOptimizationInfo
+            .getDynamicType(1)
+            .asDynamicTypeWithUpperBound()
+            .getDynamicUpperBoundType();
     assert upperBoundType.isClassType()
         && upperBoundType.asClassType().getClassType().toSourceString().endsWith("$A");
     if (method.getHolderType().toSourceString().endsWith("$A")) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineCatchHandlerWithLibraryTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineCatchHandlerWithLibraryTypeTest.java
index 5874af4..e5635d0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineCatchHandlerWithLibraryTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineCatchHandlerWithLibraryTypeTest.java
@@ -93,11 +93,6 @@
         || parameters.getApiLevel().getLevel() < EXCEPTIONS.get(exception);
   }
 
-  private boolean compileTargetHasVerificationBug() {
-    // A CF target could target any API in the end.
-    return parameters.isCfRuntime() || parameters.getApiLevel().isLessThan(AndroidApiLevel.L);
-  }
-
   @Test
   public void test() throws Exception {
     testForR8(parameters.getBackend())
@@ -131,7 +126,7 @@
     boolean mainHasInlinedCatchHandler =
         Streams.stream(classSubject.mainMethod().iterateTryCatches())
             .anyMatch(tryCatch -> tryCatch.isCatching(exception));
-    if (compileTargetHasVerificationBug() && compilationTargetIsMissingExceptionType()) {
+    if (compilationTargetIsMissingExceptionType()) {
       assertFalse(mainHasInlinedCatchHandler);
     } else {
       assertTrue(mainHasInlinedCatchHandler);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
index 68991bd..84b6917 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.ir.optimize.inliner;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestBase;
@@ -72,9 +73,9 @@
         result.inspector().clazz(TestClassCallingMethodWithNonExisting.class);
     boolean hasCatchHandler =
         Streams.stream(classSubject.mainMethod().iterateTryCatches()).count() > 0;
-    int runtimeLevel = parameters.getApiLevel().getLevel();
-    assertEquals(runtimeLevel >= AndroidApiLevel.L.getLevel(), hasCatchHandler);
-
+    // The catch handler does not exist in ClassWithCatchNonExisting.methodWithCatch thus we assign
+    // UNKNOWN api level. As a result we do not inline.
+    assertFalse(hasCatchHandler);
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
new file mode 100644
index 0000000..bf1ec2e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.membervaluepropagation.fields;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class FieldTypeStrengtheningTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection parameters() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              ClassSubject aClassSubject = inspector.clazz(A.class);
+              assertThat(aClassSubject, isPresent());
+
+              FieldSubject fieldSubject = mainClassSubject.uniqueFieldWithName("f");
+              assertEquals(
+                  aClassSubject.getFinalName(), fieldSubject.getField().getType().getTypeName());
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("A");
+  }
+
+  static class Main {
+
+    static Object f;
+
+    public static void main(String[] args) {
+      setField();
+      printField();
+    }
+
+    @NeverInline
+    static void setField() {
+      f = new A();
+    }
+
+    @NeverInline
+    static void printField() {
+      System.out.println(f);
+    }
+  }
+
+  public static class A {
+
+    @Override
+    public String toString() {
+      return "A";
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index 2d2611f..05758fd 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_3_72;
 import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_5_0;
+import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLIN_DEV;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
@@ -36,6 +37,7 @@
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -62,6 +64,8 @@
     // SAM interfaces lambdas are implemented by invoke dynamic in kotlin 1.5 unlike 1.4 where a
     // class is generated for each. In CF we leave invokeDynamic but for DEX we desugar the classes
     // and merge them.
+    // TODO(b/208816049): Fix test.
+    Assume.assumeTrue(kotlinParameters.getCompiler().isNot(KOTLIN_DEV));
     boolean hasKotlinCGeneratedLambdaClasses = kotlinParameters.isOlderThan(KOTLINC_1_5_0);
     String mainClassName = "class_inliner_lambda_j_style.MainKt";
     runTest(
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
index 03d1aa2..d426170 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
@@ -27,10 +27,7 @@
   public static List<Object[]> data() {
     return buildParameters(
         getTestParameters().withDexRuntimes().withAllApiLevels().build(),
-        getKotlinTestParameters()
-            .withAllCompilers()
-            .withTargetVersion(KotlinTargetVersion.JAVA_6)
-            .build());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public KotlinLambdaMergingDebugTest(
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
index 1dae299..39d2473 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
@@ -99,13 +99,17 @@
             .assertAllWarningMessagesMatch(
                 equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
             .writeToZip();
+    boolean expectingCompilationError = kotlinParameters.isOlderThanMinSupported() && !keepUnit;
     Path output =
         kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
             .addClasspathFiles(libJar)
             .addSourceFiles(
                 getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(expectingCompilationError);
+    if (expectingCompilationError) {
+      return;
+    }
     final JvmTestRunResult runResult =
         testForJvm()
             .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
index 440a8d5..5739e90 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
@@ -135,7 +135,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(
                 getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar(), libJar)
         .addProgramFiles(output)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
index 5437d0d..b2e2631 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
@@ -84,7 +84,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/anonymous_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
         .addClasspath(main)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
index 994a011..d3e2677 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
@@ -1,17 +1,28 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 package com.android.tools.r8.kotlin.metadata;
 
+import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_4_20;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion;
 import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.kotlin.KotlinMetadataWriter;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.nio.file.Path;
 import java.util.Collection;
+import kotlinx.metadata.jvm.KotlinClassMetadata;
+import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -19,21 +30,25 @@
 @RunWith(Parameterized.class)
 public class MetadataRewriteDelegatedPropertyTest extends KotlinMetadataTestBase {
 
+  private static final String PKG_LIB = PKG + ".delegated_property_lib";
   private static final String PKG_APP = PKG + ".delegated_property_app";
-  private static final String EXPECTED_MAIN =
+  private static final String EXPECTED =
       StringUtils.lines(
-          "Initial string has been read in CustomDelegate from 'x'",
-          "Initial string has been read in CustomDelegate from 'x'",
-          "New value has been read in CustomDelegate from 'x'",
-          "New value has been read in CustomDelegate from 'x'",
-          "null",
-          "New value has been read in CustomDelegate from 'x'");
+          "foobar",
+          "var com.android.tools.r8.kotlin.metadata.delegated_property_lib.MyDelegatedProperty.oldName:"
+              + " kotlin.String");
+
+  private static final KotlinCompilerVersion MIN_SUPPORTED_KOTLIN_VERSION = KOTLINC_1_4_20;
 
   @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
+        getKotlinTestParameters()
+            .withOldCompilersStartingFrom(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withCompilersStartingFromIncluding(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withAllTargetVersions()
+            .build());
   }
 
   public MetadataRewriteDelegatedPropertyTest(
@@ -43,17 +58,26 @@
   }
 
   private final TestParameters parameters;
-  private static final KotlinCompileMemoizer jars =
+
+  private static final KotlinCompileMemoizer libJars =
       getCompileMemoizer(
-          getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"));
+          getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_LIB), "lib"));
 
   @Test
   public void smokeTest() throws Exception {
+    Path libJar = libJars.getForConfiguration(kotlinc, targetVersion);
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(
+                getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
     testForJvm()
-        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar())
-        .addClasspath(jars.getForConfiguration(kotlinc, targetVersion))
+        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar(), libJar)
+        .addClasspath(output)
         .run(parameters.getRuntime(), PKG_APP + ".MainKt")
-        .assertSuccessWithOutput(EXPECTED_MAIN);
+        .assertSuccessWithOutput(EXPECTED);
   }
 
   @Test
@@ -64,21 +88,60 @@
                 kotlinc.getKotlinStdlibJar(),
                 kotlinc.getKotlinReflectJar(),
                 kotlinc.getKotlinAnnotationJar())
-            .addProgramFiles(jars.getForConfiguration(kotlinc, targetVersion))
-            .addKeepAllClassesRule()
+            .addKeepClassAndMembersRules(PKG_LIB + ".MyDelegatedProperty")
+            .addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
             .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
             .compile()
-            .inspect(
-                inspector ->
-                    assertEqualMetadata(
-                        new CodeInspector(jars.getForConfiguration(kotlinc, targetVersion)),
-                        inspector,
-                        (addedStrings, addedNonInitStrings) -> {}))
+            .inspect(this::inspectMetadata)
             .writeToZip();
+    Path main =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(outputJar)
+            .addSourceFiles(
+                getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
     testForJvm()
-        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar())
-        .addClasspath(outputJar)
+        .addRunClasspathFiles(
+            kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar(), outputJar)
+        .addClasspath(main)
         .run(parameters.getRuntime(), PKG_APP + ".MainKt")
-        .assertSuccessWithOutput(EXPECTED_MAIN);
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testInsufficientMetadataForLib() throws Exception {
+    Path outputJar =
+        testForR8(parameters.getBackend())
+            .addClasspathFiles(
+                kotlinc.getKotlinStdlibJar(),
+                kotlinc.getKotlinReflectJar(),
+                kotlinc.getKotlinAnnotationJar())
+            .addKeepClassAndMembersRules(PKG_LIB + ".MyDelegatedProperty")
+            .addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
+            .compile()
+            .writeToZip();
+    ProcessResult compileResult =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(outputJar)
+            .addSourceFiles(
+                getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compileRaw();
+    Assert.assertEquals(1, compileResult.exitCode);
+    assertThat(
+        compileResult.stderr,
+        containsString(
+            "unsupported [reference to the synthetic extension property for a Java get/set"
+                + " method]"));
+  }
+
+  private void inspectMetadata(CodeInspector inspector) {
+    ClassSubject clazz = inspector.clazz(PKG_LIB + ".MyDelegatedProperty");
+    assertThat(clazz, isPresent());
+    KotlinClassMetadata kotlinClassMetadata = clazz.getKotlinClassMetadata();
+    Assert.assertNotNull(kotlinClassMetadata);
+    String metadataAsString = KotlinMetadataWriter.kotlinMetadataToString("", kotlinClassMetadata);
+    assertThat(metadataAsString, containsString("syntheticMethodForDelegate:"));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
index 15a3391..e45b633 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
@@ -21,11 +21,9 @@
 import com.android.tools.r8.utils.codeinspector.KmPropertySubject;
 import com.android.tools.r8.utils.codeinspector.KmTypeProjectionSubject;
 import com.android.tools.r8.utils.codeinspector.KmTypeSubject;
-import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
 import kotlinx.metadata.KmFlexibleTypeUpperBound;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -96,7 +94,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/flexible_upper_bound_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar(), libJar)
         .addClasspath(main)
@@ -104,7 +105,7 @@
         .assertSuccessWithOutput(EXPECTED);
   }
 
-  private void inspect(CodeInspector inspector) throws IOException, ExecutionException {
+  private void inspect(CodeInspector inspector) {
     // We are checking that A is renamed, and that the flexible upper bound information is
     // reflecting that.
     ClassSubject a = inspector.clazz(PKG_LIB + ".A");
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
index 8b9e4c1..2b316c9 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
@@ -104,7 +104,10 @@
             .addClasspathFiles(baseLibJar, libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/classpath_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), baseLibJar, libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
index dc4535c..eae75ac 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
@@ -144,7 +144,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/companion_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
index b1001e1..a03354e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
@@ -157,7 +157,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/extension_function_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
index 7f0fc70..67401c2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
@@ -162,7 +162,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/extension_property_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
index 001f000..10afff3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
@@ -158,7 +158,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/function_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
index 2707bc2..fb2e952 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
@@ -98,7 +98,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/vararg_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java
index 97ec9f0..cbbbbb0 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java
@@ -93,7 +93,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/nested_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
index 6d69d26..557562c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
@@ -87,7 +87,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/parametertype_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
index a29d2ec..7e12a9f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
@@ -95,7 +95,10 @@
             .addSourceFiles(
                 getKotlinFileInTest(PKG_PREFIX + "/fragile_property_only_getter", "getter_user"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
@@ -192,7 +195,10 @@
             .addSourceFiles(
                 getKotlinFileInTest(PKG_PREFIX + "/fragile_property_only_setter", "setter_user"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
index 06ed6a6..2a69c5a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
@@ -85,7 +85,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/propertytype_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
index 59d626b..84ee3ec 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
@@ -87,7 +87,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/returntype_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
index 7aa3952..afe617a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
@@ -88,7 +88,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/supertype_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
@@ -135,7 +138,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/supertype_app", "main"))
             .setOutputPath(temp.newFolder().toPath())
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
index 8482191..cfc0ea8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
@@ -138,7 +138,10 @@
         kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/typealias_app", "main"))
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
 
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar(), libJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
index 18fce95..880bb14 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
@@ -140,7 +140,10 @@
         kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
             .addClasspathFiles(libJar)
             .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/typeargument_app", "main"))
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
         .addClasspath(mainJar)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlineClassIncludeDescriptorClassesTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlineClassIncludeDescriptorClassesTest.java
new file mode 100644
index 0000000..ac394af
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlineClassIncludeDescriptorClassesTest.java
@@ -0,0 +1,112 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.*;
+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 com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import java.nio.file.Path;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInlineClassIncludeDescriptorClassesTest extends KotlinMetadataTestBase {
+
+  private final String EXPECTED = StringUtils.lines("Hello World!");
+  private static final KotlinCompilerVersion MIN_SUPPORTED_KOTLIN_VERSION = KOTLINC_1_6_0;
+
+  @Parameterized.Parameters(name = "{0}, {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(),
+        getKotlinTestParameters()
+            .withOldCompilersStartingFrom(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withCompilersStartingFromIncluding(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withAllTargetVersions()
+            .build());
+  }
+
+  public MetadataRewriteInlineClassIncludeDescriptorClassesTest(
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
+    this.parameters = parameters;
+  }
+
+  private static final KotlinCompileMemoizer libJars =
+      getCompileMemoizer(
+          getKotlinFileInTest(PKG_PREFIX + "/inline_class_fun_descriptor_classes_lib", "lib"),
+          getKotlinFileInTest(
+              PKG_PREFIX + "/inline_class_fun_descriptor_classes_lib", "keepForApi"));
+  private final TestParameters parameters;
+
+  @Test
+  public void smokeTest() throws Exception {
+    Path libJar = libJars.getForConfiguration(kotlinc, targetVersion);
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(
+                getKotlinFileInTest(
+                    PKG_PREFIX + "/inline_class_fun_descriptor_classes_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+    testForJvm()
+        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".inline_class_fun_descriptor_classes_app.MainKt")
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testMetadataForLib() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinAnnotationJar())
+            .addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            // kotlinc will generate a method for the unboxed type on the form login-XXXXX(String).
+            // We define an annotation that specify we keep the method and descriptor classes.
+            .addKeepRules(
+                "-keepclasseswithmembers class * { @"
+                    + PKG
+                    + ".inline_class_fun_descriptor_classes_lib.KeepForApi *; }")
+            .addKeepRules(
+                "-keepclassmembers,includedescriptorclasses class * { @"
+                    + PKG
+                    + ".inline_class_fun_descriptor_classes_lib.KeepForApi *; }")
+            .compile()
+            .inspect(
+                inspector -> {
+                  // TODO(b/208209210): Perhaps this should be kept.
+                  assertThat(
+                      inspector.clazz(
+                          PKG + ".inline_class_fun_descriptor_classes_lib.KeepForApi.Password"),
+                      not(Matchers.isPresent()));
+                })
+            .writeToZip();
+    ProcessResult kotlinCompileAppResult =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(
+                getKotlinFileInTest(
+                    PKG_PREFIX + "/inline_class_fun_descriptor_classes_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compileRaw();
+    assertEquals(1, kotlinCompileAppResult.exitCode);
+    assertThat(kotlinCompileAppResult.stderr, containsString("unresolved reference: Password"));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlineClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlineClassTest.java
new file mode 100644
index 0000000..af22ae1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlineClassTest.java
@@ -0,0 +1,121 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_6_0;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.kotlin.KotlinMetadataWriter;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import junit.framework.TestCase;
+import kotlinx.metadata.jvm.KotlinClassHeader;
+import kotlinx.metadata.jvm.KotlinClassMetadata;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInlineClassTest extends KotlinMetadataTestBase {
+
+  private final String EXPECTED = StringUtils.lines("Password(s=Hello World!)");
+  private final String passwordTypeName = PKG + ".inline_class_lib.Password";
+  private static final KotlinCompilerVersion MIN_SUPPORTED_KOTLIN_VERSION = KOTLINC_1_6_0;
+
+  @Parameterized.Parameters(name = "{0}, {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(),
+        getKotlinTestParameters()
+            .withOldCompilersStartingFrom(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withCompilersStartingFromIncluding(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withAllTargetVersions()
+            .build());
+  }
+
+  public MetadataRewriteInlineClassTest(
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
+    this.parameters = parameters;
+  }
+
+  private static final KotlinCompileMemoizer libJars =
+      getCompileMemoizer(getKotlinFileInTest(PKG_PREFIX + "/inline_class_lib", "lib"));
+  private final TestParameters parameters;
+
+  @Test
+  public void smokeTest() throws Exception {
+    Path libJar = libJars.getForConfiguration(kotlinc, targetVersion);
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/inline_class_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+    testForJvm()
+        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".inline_class_app.MainKt")
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testMetadataForLib() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinAnnotationJar())
+            .addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
+            .addKeepClassAndMembersRules(passwordTypeName)
+            // kotlinc will generate a method for the unboxed type on the form login-XXXXX(String).
+            // Ideally, this should be targeted by annotation instead.
+            .addKeepRules(
+                "-keep class " + PKG + ".inline_class_lib.LibKt { *** login-*(java.lang.String); }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspect)
+            .writeToZip();
+    Path main =
+        kotlinc(parameters.getRuntime().asCf(), kotlinc, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/inline_class_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+    testForJvm()
+        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar(), libJar)
+        .addClasspath(main)
+        .run(parameters.getRuntime(), PKG + ".inline_class_app.MainKt")
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  private void inspect(CodeInspector inspector) throws IOException {
+    CodeInspector stdLibInspector =
+        new CodeInspector(libJars.getForConfiguration(kotlinc, targetVersion));
+    ClassSubject clazzSubject = stdLibInspector.clazz(passwordTypeName);
+    ClassSubject r8Clazz = inspector.clazz(clazzSubject.getOriginalName());
+    assertThat(r8Clazz, isPresent());
+    KotlinClassMetadata originalMetadata = clazzSubject.getKotlinClassMetadata();
+    KotlinClassMetadata rewrittenMetadata = r8Clazz.getKotlinClassMetadata();
+    TestCase.assertNotNull(rewrittenMetadata);
+    KotlinClassHeader originalHeader = originalMetadata.getHeader();
+    KotlinClassHeader rewrittenHeader = rewrittenMetadata.getHeader();
+    TestCase.assertEquals(originalHeader.getKind(), rewrittenHeader.getKind());
+    TestCase.assertEquals(originalHeader.getPackageName(), rewrittenHeader.getPackageName());
+    Assert.assertArrayEquals(originalHeader.getData1(), rewrittenHeader.getData1());
+    Assert.assertArrayEquals(originalHeader.getData2(), rewrittenHeader.getData2());
+    String expected = KotlinMetadataWriter.kotlinMetadataToString("", originalMetadata);
+    String actual = KotlinMetadataWriter.kotlinMetadataToString("", rewrittenMetadata);
+    TestCase.assertEquals(expected, actual);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteLocalDelegatedPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteLocalDelegatedPropertyTest.java
new file mode 100644
index 0000000..2a7ee54
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteLocalDelegatedPropertyTest.java
@@ -0,0 +1,84 @@
+// 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.kotlin.metadata;
+
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.nio.file.Path;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteLocalDelegatedPropertyTest extends KotlinMetadataTestBase {
+
+  private static final String PKG_APP = PKG + ".local_delegated_property_app";
+  private static final String EXPECTED_MAIN =
+      StringUtils.lines(
+          "Initial string has been read in CustomDelegate from 'x'",
+          "Initial string has been read in CustomDelegate from 'x'",
+          "New value has been read in CustomDelegate from 'x'",
+          "New value has been read in CustomDelegate from 'x'",
+          "null",
+          "New value has been read in CustomDelegate from 'x'");
+
+  @Parameterized.Parameters(name = "{0}, {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
+  }
+
+  public MetadataRewriteLocalDelegatedPropertyTest(
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
+    this.parameters = parameters;
+  }
+
+  private final TestParameters parameters;
+  private static final KotlinCompileMemoizer jars =
+      getCompileMemoizer(
+          getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"));
+
+  @Test
+  public void smokeTest() throws Exception {
+    testForJvm()
+        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar())
+        .addClasspath(jars.getForConfiguration(kotlinc, targetVersion))
+        .run(parameters.getRuntime(), PKG_APP + ".MainKt")
+        .assertSuccessWithOutput(EXPECTED_MAIN);
+  }
+
+  @Test
+  public void testMetadataForLib() throws Exception {
+    Path outputJar =
+        testForR8(parameters.getBackend())
+            .addClasspathFiles(
+                kotlinc.getKotlinStdlibJar(),
+                kotlinc.getKotlinReflectJar(),
+                kotlinc.getKotlinAnnotationJar())
+            .addProgramFiles(jars.getForConfiguration(kotlinc, targetVersion))
+            .addKeepAllClassesRule()
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(
+                inspector ->
+                    assertEqualMetadata(
+                        new CodeInspector(jars.getForConfiguration(kotlinc, targetVersion)),
+                        inspector,
+                        (addedStrings, addedNonInitStrings) -> {}))
+            .writeToZip();
+    testForJvm()
+        .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinReflectJar())
+        .addClasspath(outputJar)
+        .run(parameters.getRuntime(), PKG_APP + ".MainKt")
+        .assertSuccessWithOutput(EXPECTED_MAIN);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
index 0cf8903..b46dc08 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
@@ -89,7 +89,10 @@
             .addClasspathFiles(libJar)
             .addSourceFiles(
                 getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
-            .compile();
+            .compile(kotlinParameters.isOlderThanMinSupported());
+    if (kotlinParameters.isOlderThanMinSupported()) {
+      return;
+    }
     testForJvm()
         .addRunClasspathFiles(kotlinc.getKotlinStdlibJar(), libJar)
         .addProgramFiles(output)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteValueClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteValueClassTest.java
index 29fa8ec..6aecc85 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteValueClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteValueClassTest.java
@@ -11,6 +11,7 @@
 import static org.hamcrest.core.StringContains.containsString;
 import static org.junit.Assert.assertNull;
 
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion;
 import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.kotlin.KotlinMetadataWriter;
@@ -37,13 +38,15 @@
   private static final String PKG_LIB = PKG + ".value_class_lib";
   private static final String PKG_APP = PKG + ".value_class_app";
   private final TestParameters parameters;
+  private static final KotlinCompilerVersion MIN_SUPPORTED_KOTLIN_VERSION = KOTLINC_1_5_0;
 
   @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
         getKotlinTestParameters()
-            .withCompilersStartingFromIncluding(KOTLINC_1_5_0)
+            .withOldCompilersStartingFrom(MIN_SUPPORTED_KOTLIN_VERSION)
+            .withCompilersStartingFromIncluding(MIN_SUPPORTED_KOTLIN_VERSION)
             .withTargetVersion(JAVA_8)
             .build());
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_app/main.kt
index a35754f..43a9e2e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_app/main.kt
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_app/main.kt
@@ -1,59 +1,14 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
+
 package com.android.tools.r8.kotlin.metadata.delegated_property_app
 
-import kotlin.reflect.KMutableProperty1
-import kotlin.reflect.KProperty
-import kotlin.reflect.full.declaredMemberProperties
-import kotlin.reflect.jvm.isAccessible
-
-class Resource(private var s : String = "Initial string") {
-
-  override fun toString(): String {
-    return s;
-  }
-}
-
-object CustomDelegate {
-
-  private var resource : Resource = Resource()
-
-  operator fun getValue(thisRef: Any?, property: KProperty<*>): Resource {
-    println("$resource has been read in CustomDelegate from '${property.name}'")
-    return resource;
-  }
-
-  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Resource) {
-    println("$value has been assigned to '${property.name}'")
-    this.resource = resource;
-  }
-}
-
-open class Base {
-
-  fun doSomethingOnBarRef() : Resource {
-    var x by CustomDelegate
-    val propRef = x.javaClass.kotlin.declaredMemberProperties.first() as KMutableProperty1<Resource, String>
-    propRef.isAccessible = true
-    propRef.set(x, "New value")
-    propRef.get(x)
-    // Getting the delegate is not yet supported and will return null. We are printing the value
-    // allowing us to observe if the behavior changes.
-    println(propRef.getDelegate(x))
-    return x
-  }
-}
-
-object Impl : Base() {
-  operator fun invoke(): Impl {
-    return this
-  }
-}
-
+import com.android.tools.r8.kotlin.metadata.delegated_property_lib.MyDelegatedProperty
 
 fun main() {
-  val impl = Impl()
-  impl.doSomethingOnBarRef()
+  val myDelegatedProperty = MyDelegatedProperty()
+  myDelegatedProperty.oldName = "foobar";
+  println(myDelegatedProperty.newName)
+  println(myDelegatedProperty::oldName.toString())
 }
-
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_lib/lib.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_lib/lib.kt
new file mode 100644
index 0000000..da40ce5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/delegated_property_lib/lib.kt
@@ -0,0 +1,10 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata.delegated_property_lib
+
+class MyDelegatedProperty {
+  var newName: String = "Hello World!"
+  var oldName: String by this::newName
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_app/main.kt
new file mode 100644
index 0000000..28cecd5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_app/main.kt
@@ -0,0 +1,12 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata.inline_class_app
+
+import com.android.tools.r8.kotlin.metadata.inline_class_lib.Password
+import com.android.tools.r8.kotlin.metadata.inline_class_lib.login
+
+fun main() {
+  login(Password("Hello World!"))
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_app/main.kt
new file mode 100644
index 0000000..a9d5023
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_app/main.kt
@@ -0,0 +1,13 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata.inline_class_fun_descriptor_classes_app
+
+import com.android.tools.r8.kotlin.metadata.inline_class_fun_descriptor_classes_lib.create
+import com.android.tools.r8.kotlin.metadata.inline_class_fun_descriptor_classes_lib.Password
+import com.android.tools.r8.kotlin.metadata.inline_class_fun_descriptor_classes_lib.login
+
+fun main() {
+  login(create("Hello World!"))
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_lib/keepForApi.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_lib/keepForApi.kt
new file mode 100644
index 0000000..1e0ec5a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_lib/keepForApi.kt
@@ -0,0 +1,11 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata.inline_class_fun_descriptor_classes_lib
+
+@Target(AnnotationTarget.FUNCTION)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class KeepForApi {
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_lib/lib.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_lib/lib.kt
new file mode 100644
index 0000000..8c902e7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_fun_descriptor_classes_lib/lib.kt
@@ -0,0 +1,18 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata.inline_class_fun_descriptor_classes_lib
+
+@JvmInline
+value class Password(val s: String)
+
+@KeepForApi
+fun create(pw : String) : Password {
+  return Password(pw)
+}
+
+@KeepForApi
+fun login(pw : Password) {
+  println(pw.s)
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_lib/lib.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_lib/lib.kt
new file mode 100644
index 0000000..56bc18f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/inline_class_lib/lib.kt
@@ -0,0 +1,12 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.metadata.inline_class_lib
+
+@JvmInline
+value class Password(private val s: String)
+
+fun login(pw : Password) {
+  println(pw)
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/local_delegated_property_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/local_delegated_property_app/main.kt
new file mode 100644
index 0000000..b8959e8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/local_delegated_property_app/main.kt
@@ -0,0 +1,59 @@
+// 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.kotlin.metadata.local_delegated_property_app
+
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.declaredMemberProperties
+import kotlin.reflect.jvm.isAccessible
+
+class Resource(private var s : String = "Initial string") {
+
+  override fun toString(): String {
+    return s;
+  }
+}
+
+object CustomDelegate {
+
+  private var resource : Resource = Resource()
+
+  operator fun getValue(thisRef: Any?, property: KProperty<*>): Resource {
+    println("$resource has been read in CustomDelegate from '${property.name}'")
+    return resource;
+  }
+
+  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Resource) {
+    println("$value has been assigned to '${property.name}'")
+    this.resource = resource;
+  }
+}
+
+open class Base {
+
+  fun doSomethingOnBarRef() : Resource {
+    var x by CustomDelegate
+    val propRef = x.javaClass.kotlin.declaredMemberProperties.first() as KMutableProperty1<Resource, String>
+    propRef.isAccessible = true
+    propRef.set(x, "New value")
+    propRef.get(x)
+    // Getting the delegate is not yet supported and will return null. We are printing the value
+    // allowing us to observe if the behavior changes.
+    println(propRef.getDelegate(x))
+    return x
+  }
+}
+
+object Impl : Base() {
+  operator fun invoke(): Impl {
+    return this
+  }
+}
+
+
+fun main() {
+  val impl = Impl()
+  impl.doSomethingOnBarRef()
+}
+
diff --git a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
index 2e211ad..cda6322 100644
--- a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
@@ -9,6 +9,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.NoFieldTypeStrengthening;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.references.Reference;
@@ -30,7 +31,8 @@
 
   @Parameterized.Parameters(name = "{1}, overload aggressively: {0}")
   public static List<Object[]> data() {
-    return buildParameters(BooleanUtils.values(), getTestParameters().withAllRuntimes().build());
+    return buildParameters(
+        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
   }
 
   public OverloadedReservedFieldNamingTest(
@@ -47,7 +49,8 @@
         .addKeepRules(
             "-keep class " + A.class.getTypeName() + " { boolean a; }",
             overloadAggressively ? "-overloadaggressively" : "")
-        .setMinApi(parameters.getRuntime())
+        .enableNoFieldTypeStrengtheningAnnotations()
+        .setMinApi(parameters.getApiLevel())
         .compile()
         .inspect(this::verifyAggressiveOverloading)
         .run(parameters.getRuntime(), TestClass.class)
@@ -82,6 +85,8 @@
 
     static final boolean a = System.currentTimeMillis() >= 0;
     static final String hello = System.currentTimeMillis() >= 0 ? "Hello" : null;
+
+    @NoFieldTypeStrengthening
     static final Object world = System.currentTimeMillis() >= 0 ? " world!" : null;
 
     @Override
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java
index 543dbf8..6faa4f7 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java
@@ -9,7 +9,7 @@
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoFieldTypeStrengthening;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -33,6 +33,7 @@
         .addKeepClassRules(NonPublicKeptClass.class)
         .apply(this::configureRepackaging)
         .enableInliningAnnotations()
+        .enableNoFieldTypeStrengtheningAnnotations()
         .setMinApi(parameters.getApiLevel())
         .compile()
         .inspect(this::inspect)
@@ -63,6 +64,7 @@
 
   public static class IneligibleForRepackaging {
 
+    @NoFieldTypeStrengthening
     private static NonPublicKeptClass FIELD =
         System.currentTimeMillis() > 0 ? new PublicSubClass() : null;
 
diff --git a/src/test/java/com/android/tools/r8/softverification/FoundClass.java b/src/test/java/com/android/tools/r8/softverification/FoundClass.java
index cc25389..2165828 100644
--- a/src/test/java/com/android/tools/r8/softverification/FoundClass.java
+++ b/src/test/java/com/android/tools/r8/softverification/FoundClass.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.softverification;
 
-public class FoundClass {
+public class FoundClass extends RuntimeException {
 
   public static int staticField = 42;
 
diff --git a/src/test/java/com/android/tools/r8/softverification/MissingClass.java b/src/test/java/com/android/tools/r8/softverification/MissingClass.java
index d653af7..189ba2b 100644
--- a/src/test/java/com/android/tools/r8/softverification/MissingClass.java
+++ b/src/test/java/com/android/tools/r8/softverification/MissingClass.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.softverification;
 
-public class MissingClass {
+public class MissingClass extends RuntimeException {
 
   public static int staticField = 42;
 
diff --git a/src/test/java/com/android/tools/r8/softverification/MissingMember.java b/src/test/java/com/android/tools/r8/softverification/MissingMember.java
index 9fee087..8d9a2de 100644
--- a/src/test/java/com/android/tools/r8/softverification/MissingMember.java
+++ b/src/test/java/com/android/tools/r8/softverification/MissingMember.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.softverification;
 
-public class MissingMember {
+public class MissingMember extends RuntimeException {
 
   public static int staticField = 42;
 
diff --git a/src/test/java/com/android/tools/r8/softverification/MissingSuperType.java b/src/test/java/com/android/tools/r8/softverification/MissingSuperType.java
new file mode 100644
index 0000000..e77ea01
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/softverification/MissingSuperType.java
@@ -0,0 +1,21 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.softverification;
+
+public class MissingSuperType extends MissingClass {
+
+  public static int staticField = 42;
+
+  public int instanceField = 42;
+
+  public static void staticMethod() {
+    System.out.println("MissingSuperType::staticMethod");
+  }
+
+  @Override
+  public void instanceMethod() {
+    System.out.println("MissingSuperType::instanceMethod");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/softverification/TestHashCode.java b/src/test/java/com/android/tools/r8/softverification/TestHashCode.java
new file mode 100644
index 0000000..d856b71
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/softverification/TestHashCode.java
@@ -0,0 +1,26 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.softverification;
+
+public class TestHashCode {
+
+  public static String run() {
+    return run(null);
+  }
+
+  public static String run(MissingClass missingClass) {
+    if (System.currentTimeMillis() == 0) {
+      missingClass.hashCode();
+    }
+    if (System.currentTimeMillis() == 0) {
+      missingClass.hashCode();
+    }
+    String currentString = "foobar";
+    for (int i = 0; i < 10; i++) {
+      currentString = "foobar" + (i + currentString.length());
+    }
+    return currentString;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/softverification/TestRunner.java b/src/test/java/com/android/tools/r8/softverification/TestRunner.java
index 6baef2a..dbe5ab1 100644
--- a/src/test/java/com/android/tools/r8/softverification/TestRunner.java
+++ b/src/test/java/com/android/tools/r8/softverification/TestRunner.java
@@ -47,9 +47,15 @@
     measure.start("InstanceField");
     TestInstanceField.run();
     sb.append(measure.stop());
+    measure.start("HashCode");
+    TestHashCode.run();
+    sb.append(measure.stop());
     measure.start("InstanceMethod");
     TestInstanceMethod.run();
     sb.append(measure.stop());
+    measure.start("TryCatch");
+    TestTryCatch.run();
+    sb.append(measure.stop());
     return sb.toString();
   }
 
diff --git a/src/test/java/com/android/tools/r8/softverification/TestRunnerBuilder.java b/src/test/java/com/android/tools/r8/softverification/TestRunnerBuilder.java
index 375f03f..c3f91db 100644
--- a/src/test/java/com/android/tools/r8/softverification/TestRunnerBuilder.java
+++ b/src/test/java/com/android/tools/r8/softverification/TestRunnerBuilder.java
@@ -74,8 +74,11 @@
 
   private static final Path ANDROID_STUDIO_LIB_PATH = Paths.get("PATH_TO_PROJECT/libs/library.jar");
 
-  private static final int COUNT = 1100;
+  private static final int COUNT = 800;
 
+  private static final List<Class<?>> referenceClasses =
+      ImmutableList.of(
+          MissingClass.class, MissingMember.class, FoundClass.class, MissingSuperType.class);
   private static final List<Class<?>> testClasses =
       ImmutableList.of(
           TestCheckCast.class,
@@ -85,7 +88,9 @@
           TestStaticField.class,
           TestStaticMethod.class,
           TestInstanceField.class,
-          TestInstanceMethod.class);
+          TestInstanceMethod.class,
+          TestHashCode.class,
+          TestTryCatch.class);
   private static final Collection<String> testClassBinaryNames =
       ImmutableSet.copyOf(ListUtils.map(testClasses, TestBase::binaryName));
 
@@ -93,8 +98,7 @@
     ZipBuilder builder = ZipBuilder.builder(path);
     builder.addFilesRelative(
         ToolHelper.getClassPathForTests(), ToolHelper.getClassFileForTestClass(Measure.class));
-    for (Class<?> clazz :
-        ImmutableList.of(MissingClass.class, MissingMember.class, FoundClass.class)) {
+    for (Class<?> clazz : referenceClasses) {
       String postFix = clazz.getSimpleName();
       int classCounter = 0;
       for (int i = 0; i < COUNT; i++) {
@@ -168,6 +172,11 @@
             .replaceClassDescriptorInMethodInstructions(
                 descriptor(MissingClass.class),
                 getDescriptorFromClassBinaryName(referenceBinaryName))
+            .transformTryCatchBlock(
+                "run",
+                (start, end, handler, type, visitor) -> {
+                  visitor.visitTryCatchBlock(start, end, handler, referenceBinaryName);
+                })
             .transform());
   }
 
diff --git a/src/test/java/com/android/tools/r8/softverification/TestTryCatch.java b/src/test/java/com/android/tools/r8/softverification/TestTryCatch.java
new file mode 100644
index 0000000..4be92a3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/softverification/TestTryCatch.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.softverification;
+
+public class TestTryCatch {
+
+  public static Object getObject() {
+    return new Object();
+  }
+
+  public static String run() {
+    try {
+      getObject();
+    } catch (MissingClass e) {
+      throw new RuntimeException("Foo");
+    }
+    String currentString = "foobar";
+    for (int i = 0; i < 10; i++) {
+      currentString = "foobar" + (i + currentString.length());
+    }
+    return currentString;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
index 689fce0..69b8232 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
@@ -71,8 +71,17 @@
 
   public HorizontallyMergedClassesInspector applyIf(
       boolean condition, ThrowableConsumer<HorizontallyMergedClassesInspector> consumer) {
+    return applyIf(condition, consumer, ThrowableConsumer.empty());
+  }
+
+  public HorizontallyMergedClassesInspector applyIf(
+      boolean condition,
+      ThrowableConsumer<HorizontallyMergedClassesInspector> thenConsumer,
+      ThrowableConsumer<HorizontallyMergedClassesInspector> elseConsumer) {
     if (condition) {
-      consumer.acceptWithRuntimeException(this);
+      thenConsumer.acceptWithRuntimeException(this);
+    } else {
+      elseConsumer.acceptWithRuntimeException(this);
     }
     return this;
   }
diff --git a/tools/test.py b/tools/test.py
index f5ce159..041f17b 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -287,9 +287,9 @@
   if options.print_obfuscated_stacktraces:
     gradle_args.append('-Pprint_obfuscated_stacktraces')
   if options.kotlin_compiler_old:
-    gradle_args.append('-Dcom.android.tools.r8.kotlincompilerold=1')
+    gradle_args.append('-Pkotlin_compiler_old')
   if options.kotlin_compiler_dev:
-    gradle_args.append('-Dcom.android.tools.r8.kotlincompilerdev=1')
+    gradle_args.append('-Pkotlin_compiler_dev')
     download_kotlin_dev.download_newest()
   if os.name == 'nt':
     # temporary hack