diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
index 26eb08a..51ef31e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
@@ -4,14 +4,20 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexAnnotationSet;
+import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
 import com.google.common.base.Equivalence.Wrapper;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
@@ -31,24 +37,30 @@
   private final Collection<DexProgramClass> toMergeGroup;
   private final DexItemFactory dexItemFactory;
   private final HorizontalClassMergerGraphLens.Builder lensBuilder;
+  private final FieldAccessInfoCollectionModifier.Builder fieldAccessChangesBuilder;
 
   private final Reference2IntMap<DexType> classIdentifiers = new Reference2IntOpenHashMap<>();
-
   private final Map<DexProto, ConstructorMerger.Builder> constructorMergers;
+  private final DexField classIdField;
 
   ClassMerger(
       AppView<?> appView,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
+      FieldAccessInfoCollectionModifier.Builder fieldAccessChangesBuilder,
       DexProgramClass target,
       Collection<DexProgramClass> toMergeGroup) {
     this.appView = appView;
     this.lensBuilder = lensBuilder;
+    this.fieldAccessChangesBuilder = fieldAccessChangesBuilder;
     this.target = target;
     this.toMergeGroup = toMergeGroup;
-    this.constructorMergers = new IdentityHashMap<>();
 
+    this.constructorMergers = new IdentityHashMap<>();
     this.dexItemFactory = appView.dexItemFactory();
 
+    // TODO(b/165498187): ensure the name for the field is fresh
+    classIdField = dexItemFactory.createField(target.type, dexItemFactory.intType, "$r8$classId");
+
     buildClassIdentifierMap();
   }
 
@@ -112,8 +124,8 @@
 
   void mergeConstructors() {
     for (ConstructorMerger.Builder builder : constructorMergers.values()) {
-      ConstructorMerger constructorMerger = builder.build(appView, target);
-      constructorMerger.merge(lensBuilder, classIdentifiers);
+      ConstructorMerger constructorMerger = builder.build(appView, target, classIdField);
+      constructorMerger.merge(lensBuilder, fieldAccessChangesBuilder, classIdentifiers);
     }
   }
 
@@ -131,8 +143,20 @@
         });
   }
 
+  void appendClassIdField() {
+    DexEncodedField encodedField =
+        new DexEncodedField(
+            classIdField,
+            FieldAccessFlags.fromSharedAccessFlags(
+                Constants.ACC_PUBLIC + Constants.ACC_FINAL + Constants.ACC_SYNTHETIC),
+            DexAnnotationSet.empty(),
+            null);
+    target.appendInstanceField(encodedField);
+  }
+
   public void mergeGroup() {
     addTargetConstructors();
+    appendClassIdField();
 
     for (DexProgramClass clazz : toMergeGroup) {
       merge(clazz);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java
index 58fe0b7..ff2a898 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java
@@ -4,17 +4,19 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.conversion.IRBuilder;
 import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
 import com.android.tools.r8.utils.IntBox;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceMap.Entry;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map.Entry;
-import java.util.SortedMap;
 
 /**
  * Generate code of the form: <code>
@@ -32,23 +34,54 @@
  * </code>
  */
 public class ConstructorEntryPoint extends SyntheticSourceCode {
-  private final SortedMap<Integer, DexMethod> typeConstructors;
+  private final DexField classIdField;
+  private final Int2ReferenceSortedMap<DexMethod> typeConstructors;
 
   public ConstructorEntryPoint(
-      SortedMap<Integer, DexMethod> typeConstructors,
-      DexMethod method,
+      Int2ReferenceSortedMap<DexMethod> typeConstructors,
+      DexMethod newConstructor,
+      DexField classIdField,
       Position callerPosition,
       DexMethod originalMethod) {
-    super(method.holder, method, callerPosition, originalMethod);
+    super(newConstructor.holder, newConstructor, callerPosition, originalMethod);
 
     this.typeConstructors = typeConstructors;
+    this.classIdField = classIdField;
   }
 
-  @Override
-  protected void prepareInstructions() {
+  void addConstructorInvoke(DexMethod typeConstructor) {
+    add(
+        builder -> {
+          List<Value> arguments = new ArrayList<>(typeConstructor.getArity() + 1);
+          arguments.add(builder.getReceiverValue());
+
+          // If there are any arguments add them to the list.
+          for (int i = 0; i < typeConstructor.getArity(); i++) {
+            arguments.add(builder.getArgumentValues().get(i));
+          }
+
+          builder.addInvoke(Type.DIRECT, typeConstructor, typeConstructor.proto, arguments, false);
+        });
+  }
+
+  /** Assign the given register to the class id field. */
+  void addRegisterClassIdAssignment(int idRegister) {
+    add(builder -> builder.addInstancePut(idRegister, getReceiverRegister(), classIdField));
+  }
+
+  /** Assign the given constant integer value to the class id field. */
+  void addConstantRegisterClassIdAssignment(int classId) {
+    int idRegister = nextRegister(ValueType.INT);
+    add(builder -> builder.addIntConst(idRegister, classId));
+    addRegisterClassIdAssignment(idRegister);
+  }
+
+  protected void prepareMultiConstructorInstructions() {
     int typeConstructorCount = typeConstructors.size();
     int idRegister = getParamRegister(method.getArity() - 1);
 
+    addRegisterClassIdAssignment(idRegister);
+
     int[] keys = new int[typeConstructorCount - 1];
     int[] offsets = new int[typeConstructorCount - 1];
     IntBox fallthrough = new IntBox();
@@ -57,10 +90,9 @@
         builder -> builder.addSwitch(idRegister, keys, fallthrough.get(), offsets),
         builder -> endsSwitch(builder, switchIndex, fallthrough.get(), offsets));
 
-
     int index = 0;
-    for (Entry<Integer, DexMethod> entry : typeConstructors.entrySet()) {
-      int classId = entry.getKey();
+    for (Entry<DexMethod> entry : typeConstructors.int2ReferenceEntrySet()) {
+      int classId = entry.getIntKey();
       DexMethod typeConstructor = entry.getValue();
 
       if (index == 0) {
@@ -72,23 +104,26 @@
         offsets[index - 1] = nextInstructionIndex();
       }
 
-      add(
-          builder -> {
-            List<Value> arguments = new ArrayList<>(typeConstructor.getArity());
-            arguments.add(builder.getReceiverValue());
-            int paramIndex = 0;
-            for (Value argument : builder.getArgumentValues()) {
-              if (paramIndex++ >= typeConstructor.getArity()) {
-                break;
-              }
-              arguments.add(argument);
-            }
-            builder.addInvoke(
-                Type.DIRECT, typeConstructor, typeConstructor.proto, arguments, false);
-          });
+      addConstructorInvoke(typeConstructor);
       add(IRBuilder::addReturn, endsBlock);
 
       index++;
     }
   }
+
+  protected void prepareSingleConstructorInstructions() {
+    Entry<DexMethod> entry = typeConstructors.int2ReferenceEntrySet().first();
+    addConstantRegisterClassIdAssignment(entry.getIntKey());
+    addConstructorInvoke(entry.getValue());
+    add(IRBuilder::addReturn, endsBlock);
+  }
+
+  @Override
+  protected void prepareInstructions() {
+    if (typeConstructors.size() > 1) {
+      prepareMultiConstructorInstructions();
+    } else {
+      prepareSingleConstructorInstructions();
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPointSynthesizedCode.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPointSynthesizedCode.java
index a2ac6d8..7d250bb 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPointSynthesizedCode.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPointSynthesizedCode.java
@@ -4,30 +4,35 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.synthetic.AbstractSynthesizedCode;
-import java.util.SortedMap;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
 import java.util.function.Consumer;
 
 public class ConstructorEntryPointSynthesizedCode extends AbstractSynthesizedCode {
-  private DexMethod newConstructor;
-  private DexMethod originalMethod;
-  private final SortedMap<Integer, DexMethod> typeConstructors;
+  private final DexMethod newConstructor;
+  private final DexMethod originalMethod;
+  private final DexField classIdField;
+  private final Int2ReferenceSortedMap<DexMethod> typeConstructors;
 
   public ConstructorEntryPointSynthesizedCode(
-      SortedMap<Integer, DexMethod> typeConstructors,
+      Int2ReferenceSortedMap<DexMethod> typeConstructors,
       DexMethod newConstructor,
+      DexField classIdField,
       DexMethod originalMethod) {
     this.typeConstructors = typeConstructors;
     this.newConstructor = newConstructor;
+    this.classIdField = classIdField;
     this.originalMethod = originalMethod;
   }
 
   @Override
   public SourceCodeProvider getSourceCodeProvider() {
     return callerPosition ->
-        new ConstructorEntryPoint(typeConstructors, newConstructor, callerPosition, originalMethod);
+        new ConstructorEntryPoint(
+            typeConstructors, newConstructor, classIdField, callerPosition, originalMethod);
   }
 
   @Override
@@ -36,7 +41,6 @@
   }
 
   private void registerReachableDefinitions(UseRegistry registry) {
-    registry.registerInvokeDirect(newConstructor);
     for (DexMethod typeConstructor : typeConstructors.values()) {
       registry.registerInvokeDirect(typeConstructor);
     }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
index b9cb999..76f4814 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
@@ -15,6 +16,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceAVLTreeMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
@@ -28,12 +30,17 @@
   private final DexProgramClass target;
   private final Collection<DexEncodedMethod> constructors;
   private final DexItemFactory dexItemFactory;
+  private final DexField classIdField;
 
   ConstructorMerger(
-      AppView<?> appView, DexProgramClass target, Collection<DexEncodedMethod> constructors) {
+      AppView<?> appView,
+      DexProgramClass target,
+      Collection<DexEncodedMethod> constructors,
+      DexField classIdField) {
     this.appView = appView;
     this.target = target;
     this.constructors = constructors;
+    this.classIdField = classIdField;
 
     // Constructors should not be empty and all constructors should have the same prototype.
     assert !constructors.isEmpty();
@@ -54,11 +61,16 @@
       return this;
     }
 
-    public ConstructorMerger build(AppView<?> appView, DexProgramClass target) {
-      return new ConstructorMerger(appView, target, constructors);
+    public ConstructorMerger build(
+        AppView<?> appView, DexProgramClass target, DexField classIdField) {
+      return new ConstructorMerger(appView, target, constructors, classIdField);
     }
   }
 
+  private boolean isTrivialMerge() {
+    return constructors.size() == 1;
+  }
+
   private DexMethod moveConstructor(DexEncodedMethod constructor) {
     DexMethod method =
         dexItemFactory.createFreshMethodName(
@@ -82,6 +94,10 @@
     DexEncodedMethod firstConstructor = constructors.stream().findFirst().get();
     DexProto oldProto = firstConstructor.getProto();
 
+    if (isTrivialMerge()) {
+      return oldProto;
+    }
+
     List<DexType> parameters = new ArrayList<>();
     Collections.addAll(parameters, oldProto.parameters.values);
     parameters.add(dexItemFactory.intType);
@@ -95,8 +111,9 @@
   }
 
   /** Synthesize a new method which selects the constructor based on a parameter type. */
-  void mergeMany(
+  void merge(
       HorizontalClassMergerGraphLens.Builder lensBuilder,
+      FieldAccessInfoCollectionModifier.Builder fieldAccessChangesBuilder,
       Reference2IntMap<DexType> classIdentifiers) {
     // Tree map as must be sorted.
     Int2ReferenceSortedMap<DexMethod> typeConstructorClassMap = new Int2ReferenceAVLTreeMap<>();
@@ -119,7 +136,10 @@
         appView.dexItemFactory().createMethod(target.type, newProto, dexItemFactory.initMethodName);
     ConstructorEntryPointSynthesizedCode synthesizedCode =
         new ConstructorEntryPointSynthesizedCode(
-            typeConstructorClassMap, newConstructorReference, originalConstructorReference);
+            typeConstructorClassMap,
+            newConstructorReference,
+            classIdField,
+            originalConstructorReference);
     DexEncodedMethod newConstructor =
         new DexEncodedMethod(
             newConstructorReference,
@@ -130,46 +150,24 @@
             classFileVersion,
             true);
 
-    // Map each old constructor to the newly synthesized constructor in the graph lens.
-    for (DexEncodedMethod oldConstructor : constructors) {
-      lensBuilder.mapConstructor(
-          oldConstructor.method,
-          newConstructorReference,
-          classIdentifiers.getInt(oldConstructor.getHolderType()));
+    if (isTrivialMerge()) {
+      // The constructor does not require the additional argument, just map it like a regular
+      // method.
+      lensBuilder.mapMethod(constructors.iterator().next().method, newConstructorReference);
+    } else {
+      // Map each old constructor to the newly synthesized constructor in the graph lens.
+      for (DexEncodedMethod oldConstructor : constructors) {
+        lensBuilder.mapMergedConstructor(
+            oldConstructor.method,
+            newConstructorReference,
+            classIdentifiers.getInt(oldConstructor.getHolderType()));
+      }
     }
     // Map the first constructor to the newly synthesized constructor.
     lensBuilder.recordExtraOriginalSignature(originalConstructorReference, newConstructorReference);
 
     target.addDirectMethod(newConstructor);
-  }
 
-  /**
-   * The constructor does not conflict with any other constructors. Add the constructor (if any) to
-   * the target directly.
-   */
-  void mergeTrivial(HorizontalClassMergerGraphLens.Builder lensBuilder) {
-    assert constructors.size() <= 1;
-
-    if (!constructors.isEmpty()) {
-      DexEncodedMethod constructor = constructors.iterator().next();
-
-      // Only move the constructor if it is not already in the target type.
-      if (constructor.holder() != target.type) {
-        DexEncodedMethod newConstructor =
-            constructor.toRenamedHolderMethod(target.type, dexItemFactory);
-        target.addDirectMethod(constructor);
-        lensBuilder.moveConstructor(constructor.method, newConstructor.method);
-      }
-    }
-  }
-
-  public void merge(
-      HorizontalClassMergerGraphLens.Builder lensBuilder,
-      Reference2IntMap<DexType> classIdentifiers) {
-    if (constructors.size() <= 1) {
-      mergeTrivial(lensBuilder);
-    } else {
-      mergeMany(lensBuilder, classIdentifiers);
-    }
+    fieldAccessChangesBuilder.fieldWrittenByMethod(classIdField, newConstructorReference);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
index b843e09..f7ac858 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.horizontalclassmerging.policies.SameParentClass;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.ClassMergingEnqueuerExtension;
+import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
 import com.android.tools.r8.shaking.MainDexClasses;
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
@@ -76,6 +77,8 @@
     Map<DexType, DexType> mergedClasses = new IdentityHashMap<>();
     HorizontalClassMergerGraphLens.Builder lensBuilder =
         new HorizontalClassMergerGraphLens.Builder();
+    FieldAccessInfoCollectionModifier.Builder fieldAccessChangesBuilder =
+        new FieldAccessInfoCollectionModifier.Builder();
 
     // TODO(b/166577694): Replace Collection<DexProgramClass> with MergeGroup
     for (Collection<DexProgramClass> group : groups) {
@@ -88,12 +91,14 @@
         mergedClasses.put(clazz.type, target.type);
       }
 
-      ClassMerger merger = new ClassMerger(appView, lensBuilder, target, group);
+      ClassMerger merger =
+          new ClassMerger(appView, lensBuilder, fieldAccessChangesBuilder, target, group);
       merger.mergeGroup();
     }
 
     HorizontalClassMergerGraphLens lens =
-        new TreeFixer(appView, lensBuilder, mergedClasses).fixupTypeReferences();
+        new TreeFixer(appView, lensBuilder, fieldAccessChangesBuilder, mergedClasses)
+            .fixupTypeReferences();
     return lens;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
index bd2751c..4389282 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
@@ -126,16 +126,13 @@
       return this;
     }
 
+    /** Unidirectional mapping from one method to another. */
     public Builder recordExtraOriginalSignature(DexMethod from, DexMethod to) {
       extraOriginalMethodSignatures.put(to, extraOriginalMethodSignatures.getOrDefault(from, from));
       return this;
     }
 
-    /**
-     * Unidirectional mapping from one method to another. This seems to only be used by synthesized
-     * constructors so is private for now. See {@link Builder#moveConstructor(DexMethod,
-     * DexMethod)}.
-     */
+    /** Unidirectional mapping from one method to another. */
     public Builder mapMethod(DexMethod from, DexMethod to) {
       for (DexMethod existingFrom :
           completeInverseMethodMap.getOrDefault(from, Collections.emptySet())) {
@@ -151,7 +148,7 @@
       return this;
     }
 
-    public boolean hasOriginalConstructorSignatureMappingFor(DexMethod method) {
+    public boolean hasExtraSignatureMappingFor(DexMethod method) {
       return extraOriginalMethodSignatures.containsKey(method);
     }
 
@@ -167,18 +164,10 @@
      * @param constructorId The id that must be appended to the constructor call to ensure the
      *     correct constructor is called.
      */
-    public Builder mapConstructor(DexMethod from, DexMethod to, int constructorId) {
+    public Builder mapMergedConstructor(DexMethod from, DexMethod to, int constructorId) {
       mapMethod(from, to);
       constructorIds.put(from, constructorId);
       return this;
     }
-
-    /**
-     * Bidirectional mapping from one constructor to another. When a single constructor is simply
-     * moved from one class to another, we can uniquely map the new constructor back to the old one.
-     */
-    public Builder moveConstructor(DexMethod from, DexMethod to) {
-      return moveMethod(from, to);
-    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
index 2d9be81..7d0d5c0 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.shaking.AnnotationFixer;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
 import com.android.tools.r8.utils.OptionalBool;
 import java.util.IdentityHashMap;
 import java.util.List;
@@ -30,14 +31,17 @@
   private final Map<DexType, DexType> mergedClasses;
   private final Map<DexProto, DexProto> protoFixupCache = new IdentityHashMap<>();
   private final HorizontalClassMergerGraphLens.Builder lensBuilder;
+  private final FieldAccessInfoCollectionModifier.Builder fieldAccessChangesBuilder;
   private final AppView<AppInfoWithLiveness> appView;
 
   public TreeFixer(
       AppView<AppInfoWithLiveness> appView,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
+      FieldAccessInfoCollectionModifier.Builder fieldAccessChangesBuilder,
       Map<DexType, DexType> mergedClasses) {
     this.mergedClasses = mergedClasses;
     this.lensBuilder = lensBuilder;
+    this.fieldAccessChangesBuilder = fieldAccessChangesBuilder;
     this.appView = appView;
   }
 
@@ -50,6 +54,8 @@
     }
     HorizontalClassMergerGraphLens lens = lensBuilder.build(appView, mergedClasses);
 
+    fieldAccessChangesBuilder.build(this::fixupMethod).modify(appView);
+
     if (lens != null) {
       new AnnotationFixer(lens).run(appView.appInfo().classes());
     }
@@ -65,7 +71,7 @@
 
     // If the method is a synthesized method, then don't record the original signature.
     if ((method.getCode() instanceof ConstructorEntryPointSynthesizedCode)) {
-      assert lensBuilder.hasOriginalConstructorSignatureMappingFor(methodReference);
+      assert lensBuilder.hasExtraSignatureMappingFor(methodReference);
       lensBuilder.recordExtraOriginalSignature(methodReference, newMethodReference);
       lensBuilder.mapMethod(methodReference, newMethodReference);
     } else {
diff --git a/src/main/java/com/android/tools/r8/shaking/FieldAccessInfoCollectionModifier.java b/src/main/java/com/android/tools/r8/shaking/FieldAccessInfoCollectionModifier.java
new file mode 100644
index 0000000..4e9d977
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/shaking/FieldAccessInfoCollectionModifier.java
@@ -0,0 +1,96 @@
+// 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.shaking;
+
+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.FieldAccessInfoCollectionImpl;
+import com.android.tools.r8.graph.FieldAccessInfoImpl;
+import com.android.tools.r8.graph.ProgramMethod;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+public class FieldAccessInfoCollectionModifier {
+
+  static class FieldReferences {
+    final List<DexMethod> writeContexts = new ArrayList<>();
+    final List<DexMethod> readContexts = new ArrayList<>();
+
+    void fixUpMethods(List<DexMethod> methods, Function<DexMethod, DexMethod> fixUpMethod) {
+      for (int i = 0; i < methods.size(); i++) {
+        DexMethod method = methods.get(i);
+        DexMethod newMethod = fixUpMethod.apply(method);
+        if (method != newMethod) {
+          methods.set(i, newMethod);
+        }
+      }
+    }
+
+    void fixUp(Function<DexMethod, DexMethod> fixUpMethod) {
+      fixUpMethods(writeContexts, fixUpMethod);
+      fixUpMethods(readContexts, fixUpMethod);
+    }
+  }
+
+  final Map<DexField, FieldReferences> newFieldAccesses;
+
+  FieldAccessInfoCollectionModifier(Map<DexField, FieldReferences> newFieldAccesses) {
+    this.newFieldAccesses = newFieldAccesses;
+  }
+
+  void forEachFieldAccess(
+      AppView<?> appView,
+      Collection<DexMethod> methods,
+      DexField field,
+      BiConsumer<DexField, ProgramMethod> record) {
+    for (DexMethod method : methods) {
+      ProgramMethod programMethod =
+          appView.definitionFor(method.holder).asProgramClass().lookupProgramMethod(method);
+      record.accept(field, programMethod);
+    }
+  }
+
+  public void modify(AppView<AppInfoWithLiveness> appView) {
+    FieldAccessInfoCollectionImpl impl = appView.appInfo().getMutableFieldAccessInfoCollection();
+    newFieldAccesses.forEach(
+        (field, info) -> {
+          FieldAccessInfoImpl fieldAccessInfo = new FieldAccessInfoImpl(field);
+          forEachFieldAccess(appView, info.readContexts, field, fieldAccessInfo::recordRead);
+          forEachFieldAccess(appView, info.writeContexts, field, fieldAccessInfo::recordWrite);
+          impl.extend(field, fieldAccessInfo);
+        });
+  }
+
+  public static class Builder {
+    final Map<DexField, FieldReferences> newFieldAccesses = new IdentityHashMap<>();
+
+    public Builder() {}
+
+    public FieldAccessInfoCollectionModifier build(Function<DexMethod, DexMethod> fixupMethod) {
+      for (FieldReferences fieldReference : newFieldAccesses.values()) {
+        fieldReference.fixUp(fixupMethod);
+      }
+      return new FieldAccessInfoCollectionModifier(newFieldAccesses);
+    }
+
+    FieldReferences getFieldReferences(DexField field) {
+      return newFieldAccesses.computeIfAbsent(field, ignore -> new FieldReferences());
+    }
+
+    public void fieldReadByMethod(DexField field, DexMethod method) {
+      getFieldReferences(field).readContexts.add(method);
+    }
+
+    public void fieldWrittenByMethod(DexField field, DexMethod method) {
+      getFieldReferences(field).writeContexts.add(method);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
new file mode 100644
index 0000000..226af98
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
@@ -0,0 +1,79 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.classmerging.horizontal.ConstructorMergingTest.A;
+import com.android.tools.r8.classmerging.horizontal.ConstructorMergingTest.B;
+import com.android.tools.r8.classmerging.horizontal.ConstructorMergingTest.Main;
+import org.junit.Test;
+
+public class MergedConstructorForwardingTest extends HorizontalClassMergingTestBase {
+
+  public MergedConstructorForwardingTest(
+      TestParameters parameters, boolean enableHorizontalClassMerging) {
+    super(parameters, enableHorizontalClassMerging);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addOptionsModification(
+            options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("42", "13", "21", "39")
+        .inspect(
+            codeInspector -> {
+              if (enableHorizontalClassMerging) {
+                assertThat(codeInspector.clazz(A.class), isPresent());
+                assertThat(codeInspector.clazz(B.class), not(isPresent()));
+                // TODO(b/165517236): Explicitly check classes have been merged.
+              } else {
+                assertThat(codeInspector.clazz(A.class), isPresent());
+                assertThat(codeInspector.clazz(B.class), isPresent());
+              }
+            });
+  }
+
+  @NeverClassInline
+  public static class A {
+    public A() {
+      this(42);
+    }
+
+    public A(long x) {
+      System.out.println(x);
+    }
+  }
+
+  @NeverClassInline
+  public static class B {
+    public B() {
+      this(7);
+    }
+
+    public B(long y) {
+      System.out.println(y * 3);
+    }
+  }
+
+  public static class Main {
+    public static void main(String[] args) {
+      A a = new A();
+      a = new A(13);
+      B b = new B();
+      b = new B(13);
+    }
+  }
+}