diff --git a/src/main/java/com/android/tools/r8/ResourceShrinker.java b/src/main/java/com/android/tools/r8/ResourceShrinker.java
index 6267db1..d7805b3 100644
--- a/src/main/java/com/android/tools/r8/ResourceShrinker.java
+++ b/src/main/java/com/android/tools/r8/ResourceShrinker.java
@@ -233,11 +233,11 @@
 
     private void processAnnotations(DexProgramClass classDef) {
       Stream<DexAnnotation> instanceFieldAnnotations =
-          Arrays.stream(classDef.instanceFields())
+          classDef.instanceFields().stream()
               .filter(DexEncodedField::hasAnnotation)
               .flatMap(f -> Arrays.stream(f.annotations.annotations));
       Stream<DexAnnotation> staticFieldAnnotations =
-          Arrays.stream(classDef.staticFields())
+          classDef.staticFields().stream()
               .filter(DexEncodedField::hasAnnotation)
               .flatMap(f -> Arrays.stream(f.annotations.annotations));
       Stream<DexAnnotation> virtualMethodAnnotations =
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 3acb55b..3f82b47 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.4.74";
+  public static final String LABEL = "1.4.75";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index e8ebbbb..9e7c09b 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -562,8 +562,8 @@
         item -> mixedSectionOffsets.getOffsetFor(item.parameterAnnotationsList));
   }
 
-  private void writeEncodedFields(DexEncodedField[] fields) {
-    assert PresortedComparable.isSorted(Arrays.asList(fields));
+  private void writeEncodedFields(List<DexEncodedField> fields) {
+    assert PresortedComparable.isSorted(fields);
     int currentOffset = 0;
     for (DexEncodedField field : fields) {
       int nextOffset = mapping.getOffsetFor(field.field);
@@ -600,8 +600,8 @@
   private void writeClassData(DexProgramClass clazz) {
     assert clazz.hasMethodsOrFields();
     mixedSectionOffsets.setOffsetFor(clazz, dest.position());
-    dest.putUleb128(clazz.staticFields().length);
-    dest.putUleb128(clazz.instanceFields().length);
+    dest.putUleb128(clazz.staticFields().size());
+    dest.putUleb128(clazz.instanceFields().size());
     dest.putUleb128(clazz.directMethods().size());
     dest.putUleb128(clazz.virtualMethods().size());
     writeEncodedFields(clazz.staticFields());
diff --git a/src/main/java/com/android/tools/r8/graph/DexAnnotationDirectory.java b/src/main/java/com/android/tools/r8/graph/DexAnnotationDirectory.java
index 1ef2f68..f283d46 100644
--- a/src/main/java/com/android/tools/r8/graph/DexAnnotationDirectory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexAnnotationDirectory.java
@@ -8,7 +8,6 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.utils.OrderedMergingIterator;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.function.Function;
 
@@ -38,11 +37,10 @@
         parameterAnnotations.add(method);
       }
     }
-    assert isSorted(Arrays.asList(clazz.staticFields()));
-    assert isSorted(Arrays.asList(clazz.instanceFields()));
+    assert isSorted(clazz.staticFields());
+    assert isSorted(clazz.instanceFields());
     OrderedMergingIterator<DexEncodedField, DexField> fields =
-        new OrderedMergingIterator<>(
-            Arrays.asList(clazz.staticFields()), Arrays.asList(clazz.instanceFields()));
+        new OrderedMergingIterator<>(clazz.staticFields(), clazz.instanceFields());
     fieldAnnotations = new ArrayList<>();
     while (fields.hasNext()) {
       DexEncodedField field = fields.next();
@@ -68,7 +66,6 @@
     return fieldAnnotations;
   }
 
-
   /**
    * DexAnnotationDirectory of a class can be canonicalized only if a clazz has annotations and
    * does not contains annotations for his fields, methods or parameters. Indeed, if a field, method
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 5e65aa3..5220d64 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -23,8 +23,11 @@
 
 public abstract class DexClass extends DexDefinition {
 
-  public interface MethodSetter {
+  public interface FieldSetter {
+    void setField(int index, DexEncodedField field);
+  }
 
+  public interface MethodSetter {
     void setMethod(int index, DexEncodedMethod method);
   }
 
@@ -171,8 +174,8 @@
     assert verifyNoDuplicateMethods();
   }
 
-  public void setDirectMethods(DexEncodedMethod[] values) {
-    directMethods = MoreObjects.firstNonNull(values, NO_METHODS);
+  public void setDirectMethods(DexEncodedMethod[] methods) {
+    directMethods = MoreObjects.firstNonNull(methods, NO_METHODS);
     assert verifyCorrectnessOfMethodHolders(directMethods());
     assert verifyNoDuplicateMethods();
   }
@@ -221,14 +224,14 @@
     assert verifyNoDuplicateMethods();
   }
 
-  public void setVirtualMethods(DexEncodedMethod[] values) {
-    virtualMethods = MoreObjects.firstNonNull(values, NO_METHODS);
+  public void setVirtualMethods(DexEncodedMethod[] methods) {
+    virtualMethods = MoreObjects.firstNonNull(methods, NO_METHODS);
     assert verifyCorrectnessOfMethodHolders(virtualMethods());
     assert verifyNoDuplicateMethods();
   }
 
   private boolean verifyCorrectnessOfMethodHolder(DexEncodedMethod method) {
-    assert method.method.holder == type
+    assert method.method.getHolder() == type
         : "Expected method `"
             + method.method.toSourceString()
             + "` to have holder `"
@@ -340,12 +343,53 @@
     }
   }
 
-  public DexEncodedField[] staticFields() {
-    return staticFields;
+  public List<DexEncodedField> staticFields() {
+    assert staticFields != null;
+    if (InternalOptions.assertionsEnabled()) {
+      return Collections.unmodifiableList(Arrays.asList(staticFields));
+    }
+    return Arrays.asList(staticFields);
   }
 
-  public void setStaticFields(DexEncodedField[] values) {
-    staticFields = MoreObjects.firstNonNull(values, NO_FIELDS);
+  public void appendStaticField(DexEncodedField field) {
+    DexEncodedField[] newFields = new DexEncodedField[staticFields.length + 1];
+    System.arraycopy(staticFields, 0, newFields, 0, staticFields.length);
+    newFields[staticFields.length] = field;
+    staticFields = newFields;
+    assert verifyCorrectnessOfFieldHolder(field);
+    assert verifyNoDuplicateFields();
+  }
+
+  public void appendStaticFields(Collection<DexEncodedField> fields) {
+    DexEncodedField[] newFields = new DexEncodedField[staticFields.length + fields.size()];
+    System.arraycopy(staticFields, 0, newFields, 0, staticFields.length);
+    int i = staticFields.length;
+    for (DexEncodedField field : fields) {
+      newFields[i] = field;
+      i++;
+    }
+    staticFields = newFields;
+    assert verifyCorrectnessOfFieldHolders(fields);
+    assert verifyNoDuplicateFields();
+  }
+
+  public void removeStaticField(int index) {
+    DexEncodedField[] newFields = new DexEncodedField[staticFields.length - 1];
+    System.arraycopy(staticFields, 0, newFields, 0, index);
+    System.arraycopy(staticFields, index + 1, newFields, index, staticFields.length - index - 1);
+    staticFields = newFields;
+  }
+
+  public void setStaticField(int index, DexEncodedField field) {
+    staticFields[index] = field;
+    assert verifyCorrectnessOfFieldHolder(field);
+    assert verifyNoDuplicateFields();
+  }
+
+  public void setStaticFields(DexEncodedField[] fields) {
+    staticFields = MoreObjects.firstNonNull(fields, NO_FIELDS);
+    assert verifyCorrectnessOfFieldHolders(staticFields());
+    assert verifyNoDuplicateFields();
   }
 
   public boolean definesStaticField(DexField field) {
@@ -357,12 +401,80 @@
     return false;
   }
 
-  public DexEncodedField[] instanceFields() {
-    return instanceFields;
+  public List<DexEncodedField> instanceFields() {
+    assert instanceFields != null;
+    if (InternalOptions.assertionsEnabled()) {
+      return Collections.unmodifiableList(Arrays.asList(instanceFields));
+    }
+    return Arrays.asList(instanceFields);
   }
 
-  public void setInstanceFields(DexEncodedField[] values) {
-    instanceFields = MoreObjects.firstNonNull(values, NO_FIELDS);
+  public void appendInstanceField(DexEncodedField field) {
+    DexEncodedField[] newFields = new DexEncodedField[instanceFields.length + 1];
+    System.arraycopy(instanceFields, 0, newFields, 0, instanceFields.length);
+    newFields[instanceFields.length] = field;
+    instanceFields = newFields;
+    assert verifyCorrectnessOfFieldHolder(field);
+    assert verifyNoDuplicateFields();
+  }
+
+  public void appendInstanceFields(Collection<DexEncodedField> fields) {
+    DexEncodedField[] newFields = new DexEncodedField[instanceFields.length + fields.size()];
+    System.arraycopy(instanceFields, 0, newFields, 0, instanceFields.length);
+    int i = instanceFields.length;
+    for (DexEncodedField field : fields) {
+      newFields[i] = field;
+      i++;
+    }
+    instanceFields = newFields;
+    assert verifyCorrectnessOfFieldHolders(fields);
+    assert verifyNoDuplicateFields();
+  }
+
+  public void removeInstanceField(int index) {
+    DexEncodedField[] newFields = new DexEncodedField[instanceFields.length - 1];
+    System.arraycopy(instanceFields, 0, newFields, 0, index);
+    System.arraycopy(
+        instanceFields, index + 1, newFields, index, instanceFields.length - index - 1);
+    instanceFields = newFields;
+  }
+
+  public void setInstanceField(int index, DexEncodedField field) {
+    instanceFields[index] = field;
+    assert verifyCorrectnessOfFieldHolder(field);
+    assert verifyNoDuplicateFields();
+  }
+
+  public void setInstanceFields(DexEncodedField[] fields) {
+    instanceFields = MoreObjects.firstNonNull(fields, NO_FIELDS);
+    assert verifyCorrectnessOfFieldHolders(instanceFields());
+    assert verifyNoDuplicateFields();
+  }
+
+  private boolean verifyCorrectnessOfFieldHolder(DexEncodedField field) {
+    assert field.field.getHolder() == type
+        : "Expected field `"
+            + field.field.toSourceString()
+            + "` to have holder `"
+            + type.toSourceString()
+            + "`";
+    return true;
+  }
+
+  private boolean verifyCorrectnessOfFieldHolders(Iterable<DexEncodedField> fields) {
+    for (DexEncodedField field : fields) {
+      assert verifyCorrectnessOfFieldHolder(field);
+    }
+    return true;
+  }
+
+  private boolean verifyNoDuplicateFields() {
+    Set<DexField> unique = Sets.newIdentityHashSet();
+    for (DexEncodedField field : fields()) {
+      boolean changed = unique.add(field.field);
+      assert changed : "Duplicate field `" + field.field.toSourceString() + "`";
+    }
+    return true;
   }
 
   public DexEncodedField[] allFieldsSorted() {
@@ -380,14 +492,14 @@
    * Find static field in this class matching field
    */
   public DexEncodedField lookupStaticField(DexField field) {
-    return lookupTarget(staticFields(), field);
+    return lookupTarget(staticFields, field);
   }
 
   /**
    * Find instance field in this class matching field.
    */
   public DexEncodedField lookupInstanceField(DexField field) {
-    return lookupTarget(instanceFields(), field);
+    return lookupTarget(instanceFields, field);
   }
 
   /**
@@ -598,7 +710,7 @@
   }
 
   public boolean defaultValuesForStaticFieldsMayTriggerAllocation() {
-    return Arrays.stream(staticFields())
+    return staticFields().stream()
         .anyMatch(field -> field.getStaticValue().mayTriggerAllocation());
   }
 
@@ -669,6 +781,8 @@
   public boolean isValid() {
     assert !isInterface()
         || Arrays.stream(virtualMethods).noneMatch(method -> method.accessFlags.isFinal());
+    assert verifyCorrectnessOfFieldHolders(fields());
+    assert verifyNoDuplicateFields();
     assert verifyCorrectnessOfMethodHolders(methods());
     assert verifyNoDuplicateMethods();
     return true;
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 57b08fb..4312bfd 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -225,7 +225,7 @@
   }
 
   public boolean hasMethodsOrFields() {
-    int numberOfFields = staticFields().length + instanceFields().length;
+    int numberOfFields = staticFields().size() + instanceFields().size();
     int numberOfMethods = directMethods().size() + virtualMethods().size();
     return numberOfFields + numberOfMethods > 0;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/SwitchMapCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/SwitchMapCollector.java
index a620ea9..44bba62 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/SwitchMapCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/SwitchMapCollector.java
@@ -19,7 +19,6 @@
 import com.android.tools.r8.utils.InternalOptions;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
-import java.util.Arrays;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -93,7 +92,7 @@
     if (!clazz.accessFlags.isSynthetic() && !clazz.hasClassInitializer()) {
       return;
     }
-    List<DexEncodedField> switchMapFields = Arrays.stream(clazz.staticFields())
+    List<DexEncodedField> switchMapFields = clazz.staticFields().stream()
         .filter(this::maybeIsSwitchMap).collect(Collectors.toList());
     if (!switchMapFields.isEmpty()) {
       IRCode initializer =
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 37441ac..0b98926 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
@@ -209,7 +209,7 @@
     //      of class inlining
     //
 
-    if (eligibleClassDefinition.instanceFields().length > 0) {
+    if (eligibleClassDefinition.instanceFields().size() > 0) {
       return false;
     }
     if (eligibleClassDefinition.type.hasSubtypes()) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java
index ede37b1..5a39e71 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java
@@ -16,6 +16,7 @@
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.Comparator;
+import java.util.List;
 import java.util.function.IntFunction;
 
 // While mapping fields representing lambda captures we rearrange fields to make sure
@@ -106,8 +107,8 @@
   }
 
   // Compute capture signature based on lambda class capture fields.
-  public static String getCaptureSignature(DexEncodedField[] fields) {
-    return getCaptureSignature(fields.length, i -> fields[i].field.type);
+  public static String getCaptureSignature(List<DexEncodedField> fields) {
+    return getCaptureSignature(fields.size(), i -> fields.get(i).field.type);
   }
 
   // Compute capture signature based on type list.
@@ -118,7 +119,7 @@
   // Having a list of fields of lambda captured values, maps one of them into
   // an index of the appropriate field in normalized capture signature.
   public static int mapFieldIntoCaptureIndex(
-      String capture, DexEncodedField[] lambdaFields, DexField fieldToMap) {
+      String capture, List<DexEncodedField> lambdaFields, DexField fieldToMap) {
     char fieldKind = fieldToMap.type.toShorty();
     int numberOfSameCaptureKind = 0;
     int result = -1;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
index f3fecde..375e1cc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
@@ -109,16 +109,16 @@
     return lambdas.get(lambda).id;
   }
 
-  protected final DexEncodedField[] lambdaCaptureFields(DexType lambda) {
+  protected final List<DexEncodedField> lambdaCaptureFields(DexType lambda) {
     assert lambdas.containsKey(lambda);
     return lambdas.get(lambda).clazz.instanceFields();
   }
 
   protected final DexEncodedField lambdaSingletonField(DexType lambda) {
     assert lambdas.containsKey(lambda);
-    DexEncodedField[] fields = lambdas.get(lambda).clazz.staticFields();
-    assert fields.length < 2;
-    return fields.length == 0 ? null : fields[0];
+    List<DexEncodedField> fields = lambdas.get(lambda).clazz.staticFields();
+    assert fields.size() < 2;
+    return fields.size() == 0 ? null : fields.get(0);
   }
 
   // Contains less than 2 elements?
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java
index e8fcd40..21a3083 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java
@@ -24,6 +24,7 @@
 import com.android.tools.r8.kotlin.Kotlin;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.google.common.collect.Lists;
+import java.util.List;
 import java.util.function.IntFunction;
 
 // Represents a j-style lambda group created to combine several lambda classes
@@ -152,8 +153,8 @@
     }
 
     @Override
-    int getInstanceInitializerSize(DexEncodedField[] captures) {
-      return captures.length + 2;
+    int getInstanceInitializerSize(List<DexEncodedField> captures) {
+      return captures.size() + 2;
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java
index f677b46..292e120 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java
@@ -27,6 +27,7 @@
 import com.android.tools.r8.kotlin.Kotlin;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.google.common.collect.Lists;
+import java.util.List;
 import java.util.function.IntFunction;
 
 // Represents a k-style lambda group created to combine several lambda classes
@@ -158,8 +159,8 @@
     }
 
     @Override
-    int getInstanceInitializerSize(DexEncodedField[] captures) {
-      return captures.length + 3;
+    int getInstanceInitializerSize(List<DexEncodedField> captures) {
+      return captures.size() + 3;
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java
index 2385f35..d49a2bd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java
@@ -29,6 +29,7 @@
 import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
 import com.android.tools.r8.kotlin.Kotlin;
 import com.android.tools.r8.utils.ThrowingConsumer;
+import java.util.List;
 
 // Encapsulates the logic of deep-checking of the lambda class assumptions.
 //
@@ -118,14 +119,14 @@
     }
   }
 
-  abstract int getInstanceInitializerSize(DexEncodedField[] captures);
+  abstract int getInstanceInitializerSize(List<DexEncodedField> captures);
 
   abstract int validateInstanceInitializerEpilogue(
       com.android.tools.r8.code.Instruction[] instructions, int index) throws LambdaStructureError;
 
   private void validateInstanceInitializer(DexClass lambda, Code code)
       throws LambdaStructureError {
-    DexEncodedField[] captures = lambda.instanceFields();
+    List<DexEncodedField> captures = lambda.instanceFields();
     com.android.tools.r8.code.Instruction[] instructions = code.asDexCode().instructions;
     int index = 0;
 
@@ -142,7 +143,7 @@
     assert index == instructions.length;
   }
 
-  private int validateInstanceInitializerParameterMapping(DexEncodedField[] captures,
+  private int validateInstanceInitializerParameterMapping(List<DexEncodedField> captures,
       Instruction[] instructions, int index) throws LambdaStructureError {
     int wideFieldsSeen = 0;
     for (DexEncodedField field : captures) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java
index 234bcc6..63e0684 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java
@@ -111,30 +111,30 @@
   }
 
   void validateStaticFields(Kotlin kotlin, DexClass lambda) throws LambdaStructureError {
-    DexEncodedField[] staticFields = lambda.staticFields();
-    if (staticFields.length == 1) {
-      DexEncodedField field = staticFields[0];
+    List<DexEncodedField> staticFields = lambda.staticFields();
+    if (staticFields.size() == 1) {
+      DexEncodedField field = staticFields.get(0);
       if (field.field.name != kotlin.functional.kotlinStyleLambdaInstanceName ||
           field.field.type != lambda.type || !field.accessFlags.isPublic() ||
           !field.accessFlags.isFinal() || !field.accessFlags.isStatic()) {
         throw new LambdaStructureError("unexpected static field " + field.toSourceString());
       }
       // No state if the lambda is a singleton.
-      if (lambda.instanceFields().length > 0) {
+      if (lambda.instanceFields().size() > 0) {
         throw new LambdaStructureError("has instance fields along with INSTANCE");
       }
       checkAccessFlags("static field access flags", field.accessFlags, SINGLETON_FIELD_FLAGS);
       checkFieldAnnotations(field);
 
-    } else if (staticFields.length > 1) {
+    } else if (staticFields.size() > 1) {
       throw new LambdaStructureError(
-          "only one static field max expected, found " + staticFields.length);
+          "only one static field max expected, found " + staticFields.size());
     }
   }
 
   String validateInstanceFields(DexClass lambda, boolean accessRelaxed)
       throws LambdaStructureError {
-    DexEncodedField[] instanceFields = lambda.instanceFields();
+    List<DexEncodedField> instanceFields = lambda.instanceFields();
     for (DexEncodedField field : instanceFields) {
       checkAccessFlags("capture field access flags", field.accessFlags,
           accessRelaxed ? CAPTURE_FIELD_FLAGS_RELAXED : CAPTURE_FIELD_FLAGS);
@@ -147,7 +147,7 @@
     for (DexEncodedMethod method : lambda.directMethods()) {
       if (method.isClassInitializer()) {
         // We expect to see class initializer only if there is a singleton field.
-        if (lambda.staticFields().length != 1) {
+        if (lambda.staticFields().size() != 1) {
           throw new LambdaStructureError("has static initializer, but no singleton field");
         }
         checkAccessFlags("unexpected static initializer access flags",
@@ -162,15 +162,15 @@
         // Lambda class is expected to have one constructor
         // with parameters matching capture signature.
         DexType[] parameters = method.method.proto.parameters.values;
-        DexEncodedField[] instanceFields = lambda.instanceFields();
-        if (parameters.length != instanceFields.length) {
+        List<DexEncodedField> instanceFields = lambda.instanceFields();
+        if (parameters.length != instanceFields.size()) {
           throw new LambdaStructureError("constructor parameters don't match captured values.");
         }
         for (int i = 0; i < parameters.length; i++) {
           // Kotlin compiler sometimes reshuffles the parameters so that their order
           // in the constructor don't match order of capture fields. We could add
           // support for it, but it happens quite rarely so don't bother for now.
-          if (parameters[i] != instanceFields[i].field.type) {
+          if (parameters[i] != instanceFields.get(i).field.type) {
             throw new LambdaStructureError(
                 "constructor parameters don't match captured values.", false);
           }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
index 443a2f4..bf205b3 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
@@ -141,18 +141,18 @@
       }
 
       // High-level limitations on what classes we consider eligible.
-      if (cls.isInterface() || // Must not be an interface or an abstract class.
-          cls.accessFlags.isAbstract() ||
+      if (cls.isInterface() // Must not be an interface or an abstract class.
+          || cls.accessFlags.isAbstract()
           // Don't support candidates with instance fields
-          cls.instanceFields().length > 0 ||
+          || cls.instanceFields().size() > 0
           // Only support classes directly extending java.lang.Object
-          cls.superType != factory.objectType ||
+          || cls.superType != factory.objectType
           // Instead of requiring the class being final,
           // just ensure it does not have subtypes
-          cls.type.hasSubtypes() ||
+          || cls.type.hasSubtypes()
           // Staticizing classes implementing interfaces is more
           // difficult, so don't support it until we really need it.
-          !cls.interfaces.isEmpty()) {
+          || !cls.interfaces.isEmpty()) {
         notEligible.add(cls.type);
       }
     });
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
index ff4a12e..4f4d4ef 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
@@ -46,7 +46,6 @@
 import java.util.concurrent.Future;
 import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 final class StaticizingProcessor {
 
@@ -119,7 +118,7 @@
       // CHECK: instance initializer used to create an instance is trivial.
       // NOTE: Along with requirement that candidate does not have instance
       // fields this should guarantee that the constructor is empty.
-      assert candidateClass.instanceFields().length == 0;
+      assert candidateClass.instanceFields().size() == 0;
       assert constructorUsed.isProcessed();
       TrivialInitializer trivialInitializer =
           constructorUsed.getOptimizationInfo().getTrivialInitializerInfo();
@@ -225,7 +224,7 @@
         //       extend java.lang.Object guarantees that the constructor is actually
         //       empty and does not need to be inlined.
         assert candidateInfo.candidate.superType == factory().objectType;
-        assert candidateInfo.candidate.instanceFields().length == 0;
+        assert candidateInfo.candidate.instanceFields().size() == 0;
 
         Value singletonValue = instruction.outValue();
         assert singletonValue != null;
@@ -313,7 +312,7 @@
   // From staticizer's viewpoint, `sp` is trivial in the sense that it is composed of values that
   // refer to the same singleton field. If so, we can safely relax the assertion; remove uses of
   // field reads; remove quasi-trivial phis; and then remove original field reads.
-  private boolean testAndcollectPhisComposedOfSameFieldRead(
+  private boolean testAndCollectPhisComposedOfSameFieldRead(
       Set<Phi> phisToCheck, DexField field, Set<Phi> trivialPhis) {
     for (Phi phi : phisToCheck) {
       Set<Phi> chainedPhis = Sets.newIdentityHashSet();
@@ -330,7 +329,7 @@
         }
       }
       if (!chainedPhis.isEmpty()) {
-        if (!testAndcollectPhisComposedOfSameFieldRead(chainedPhis, field, trivialPhis)) {
+        if (!testAndCollectPhisComposedOfSameFieldRead(chainedPhis, field, trivialPhis)) {
           return false;
         }
       }
@@ -347,7 +346,7 @@
     // However, it may be not true if re-processing introduces phis after optimizing common suffix.
     Set<Phi> trivialPhis = Sets.newIdentityHashSet();
     boolean hasTrivialPhis =
-        testAndcollectPhisComposedOfSameFieldRead(dest.uniquePhiUsers(), field, trivialPhis);
+        testAndCollectPhisComposedOfSameFieldRead(dest.uniquePhiUsers(), field, trivialPhis);
     assert dest.numberOfPhiUsers() == 0 || hasTrivialPhis;
     Set<Instruction> users = new HashSet<>(dest.uniqueUsers());
     // If that is the case, method calls we want to fix up include users of those phis.
@@ -510,12 +509,13 @@
 
   private boolean classMembersConflict(DexClass a, DexClass b) {
     assert Streams.stream(a.methods()).allMatch(DexEncodedMethod::isStatic);
-    assert a.instanceFields().length == 0;
-    return Stream.of(a.staticFields()).anyMatch(fld -> b.lookupField(fld.field) != null) ||
-        Streams.stream(a.methods()).anyMatch(method -> b.lookupMethod(method.method) != null);
+    assert a.instanceFields().size() == 0;
+    return a.staticFields().stream().anyMatch(fld -> b.lookupField(fld.field) != null)
+        || Streams.stream(a.methods()).anyMatch(method -> b.lookupMethod(method.method) != null);
   }
 
-  private void moveMembersIntoHost(Set<DexEncodedMethod> staticizedMethods,
+  private void moveMembersIntoHost(
+      Set<DexEncodedMethod> staticizedMethods,
       DexProgramClass candidateClass,
       DexType hostType, DexClass hostClass,
       BiMap<DexMethod, DexMethod> methodMapping,
@@ -523,26 +523,36 @@
     candidateToHostMapping.put(candidateClass.type, hostType);
 
     // Process static fields.
-    // Append fields first.
-    if (candidateClass.staticFields().length > 0) {
-      DexEncodedField[] oldFields = hostClass.staticFields();
-      DexEncodedField[] extraFields = candidateClass.staticFields();
-      DexEncodedField[] newFields = new DexEncodedField[oldFields.length + extraFields.length];
-      System.arraycopy(oldFields, 0, newFields, 0, oldFields.length);
-      System.arraycopy(extraFields, 0, newFields, oldFields.length, extraFields.length);
-      hostClass.setStaticFields(newFields);
-    }
-
-    // Fixup field types.
-    DexEncodedField[] staticFields = hostClass.staticFields();
-    for (int i = 0; i < staticFields.length; i++) {
-      DexEncodedField field = staticFields[i];
+    int numOfHostStaticFields = hostClass.staticFields().size();
+    DexEncodedField[] newFields =
+        candidateClass.staticFields().size() > 0
+            ? new DexEncodedField[numOfHostStaticFields + candidateClass.staticFields().size()]
+            : new DexEncodedField[numOfHostStaticFields];
+    List<DexEncodedField> oldFields = hostClass.staticFields();
+    for (int i = 0; i < oldFields.size(); i++) {
+      DexEncodedField field = oldFields.get(i);
       DexField newField = mapCandidateField(field.field, candidateClass.type, hostType);
       if (newField != field.field) {
-        staticFields[i] = field.toTypeSubstitutedField(newField);
+        newFields[i] = field.toTypeSubstitutedField(newField);
         fieldMapping.put(field.field, newField);
+      } else {
+        newFields[i] = field;
       }
     }
+    if (candidateClass.staticFields().size() > 0) {
+      List<DexEncodedField> extraFields = candidateClass.staticFields();
+      for (int i = 0; i < extraFields.size(); i++) {
+        DexEncodedField field = extraFields.get(i);
+        DexField newField = mapCandidateField(field.field, candidateClass.type, hostType);
+        if (newField != field.field) {
+          newFields[numOfHostStaticFields + i] = field.toTypeSubstitutedField(newField);
+          fieldMapping.put(field.field, newField);
+        } else {
+          newFields[numOfHostStaticFields + i] = field;
+        }
+      }
+    }
+    hostClass.setStaticFields(newFields);
 
     // Process static methods.
     List<DexEncodedMethod> extraMethods = candidateClass.directMethods();
diff --git a/src/main/java/com/android/tools/r8/naming/MinifiedNameMapPrinter.java b/src/main/java/com/android/tools/r8/naming/MinifiedNameMapPrinter.java
index e3d09b6..0fdeebc 100644
--- a/src/main/java/com/android/tools/r8/naming/MinifiedNameMapPrinter.java
+++ b/src/main/java/com/android/tools/r8/naming/MinifiedNameMapPrinter.java
@@ -72,7 +72,7 @@
     }
   }
 
-  private void writeFields(DexEncodedField[] fields, StringBuilder out) {
+  private void writeFields(List<DexEncodedField> fields, StringBuilder out) {
     for (DexEncodedField encodedField : fields) {
       DexField field = encodedField.field;
       DexString renamed = namingLens.lookupName(field);
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java
index a447e37..78dad02 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClass.FieldSetter;
 import com.android.tools.r8.graph.DexClass.MethodSetter;
 import com.android.tools.r8.graph.DexEncodedAnnotation;
 import com.android.tools.r8.graph.DexEncodedField;
@@ -326,8 +327,8 @@
       clazz.annotations = substituteTypesIn(clazz.annotations);
       fixupMethods(clazz.directMethods(), clazz::setDirectMethod);
       fixupMethods(clazz.virtualMethods(), clazz::setVirtualMethod);
-      clazz.setStaticFields(substituteTypesIn(clazz.staticFields()));
-      clazz.setInstanceFields(substituteTypesIn(clazz.instanceFields()));
+      fixupFields(clazz.staticFields(), clazz::setStaticField);
+      fixupFields(clazz.instanceFields(), clazz::setInstanceField);
     }
 
     private void fixupMethods(List<DexEncodedMethod> methods, MethodSetter setter) {
@@ -352,12 +353,12 @@
       }
     }
 
-    private DexEncodedField[] substituteTypesIn(DexEncodedField[] fields) {
+    private void fixupFields(List<DexEncodedField> fields, FieldSetter setter) {
       if (fields == null) {
-        return null;
+        return;
       }
-      for (int i = 0; i < fields.length; i++) {
-        DexEncodedField encodedField = fields[i];
+      for (int i = 0; i < fields.size(); i++) {
+        DexEncodedField encodedField = fields.get(i);
         DexField appliedField = appliedLense.lookupField(encodedField.field);
         DexType newHolderType = substituteType(appliedField.clazz, null);
         DexType newFieldType = substituteType(appliedField.type, null);
@@ -370,9 +371,8 @@
           newField = appliedField;
         }
         // Explicitly fix members.
-        fields[i] = encodedField.toTypeSubstitutedField(newField);
+        setter.setField(i, encodedField.toTypeSubstitutedField(newField));
       }
-      return fields;
     }
 
     private DexProto substituteTypesIn(DexProto proto, DexEncodedMethod context) {
diff --git a/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java b/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
index 42b7e21..9d68c91 100644
--- a/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
@@ -31,7 +31,6 @@
 import com.google.common.collect.Multiset.Entry;
 import com.google.common.collect.Streams;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -259,14 +258,14 @@
     if (appView.appInfo().neverMerge.contains(clazz.type)) {
       return MergeGroup.DONT_MERGE;
     }
-    if (clazz.staticFields().length + clazz.directMethods().size() + clazz.virtualMethods().size()
+    if (clazz.staticFields().size() + clazz.directMethods().size() + clazz.virtualMethods().size()
         == 0) {
       return MergeGroup.DONT_MERGE;
     }
-    if (clazz.instanceFields().length > 0) {
+    if (clazz.instanceFields().size() > 0) {
       return MergeGroup.DONT_MERGE;
     }
-    if (Arrays.stream(clazz.staticFields())
+    if (clazz.staticFields().stream()
         .anyMatch(field -> appView.appInfo().isPinned(field.field))) {
       return MergeGroup.DONT_MERGE;
     }
@@ -284,7 +283,7 @@
                     // TODO(christofferqa): Remove the invariant that the graph lense should not
                     // modify any methods from the sets alwaysInline and noSideEffects.
                     || appView.appInfo().alwaysInline.contains(method.method)
-                    || appView.appInfo().noSideEffects.keySet().contains(method))) {
+                    || appView.appInfo().noSideEffects.keySet().contains(method.method))) {
       return MergeGroup.DONT_MERGE;
     }
     if (clazz.classInitializationMayHaveSideEffects(appView.appInfo())) {
@@ -311,6 +310,7 @@
     // Disallow interfaces from being representatives, since interface methods require desugaring.
     return !clazz.isInterface();
   }
+
   private boolean merge(DexProgramClass clazz, MergeGroup group) {
     assert satisfiesMergeCriteria(clazz) == group;
     assert group != MergeGroup.DONT_MERGE;
@@ -451,15 +451,15 @@
         .allMatch(method -> method.accessFlags.isPrivate() || method.accessFlags.isPublic())) {
       return false;
     }
-    if (!Arrays.stream(clazz.staticFields())
-        .allMatch(method -> method.accessFlags.isPrivate() || method.accessFlags.isPublic())) {
+    if (!clazz.staticFields().stream()
+        .allMatch(field -> field.accessFlags.isPrivate() || field.accessFlags.isPublic())) {
       return false;
     }
 
     // Note that a class is only considered a candidate if it has no instance fields and all of its
     // virtual methods are private. Therefore, we don't need to consider check if there are any
     // package-private or protected instance fields or virtual methods here.
-    assert Arrays.stream(clazz.instanceFields()).count() == 0;
+    assert clazz.instanceFields().size() == 0;
     assert clazz.virtualMethods().stream().allMatch(method -> method.accessFlags.isPrivate());
 
     // Check that no methods access package-private or protected members.
@@ -485,8 +485,8 @@
     }
 
     assert targetClass.accessFlags.isAtLeastAsVisibleAs(sourceClass.accessFlags);
-    assert sourceClass.instanceFields().length == 0;
-    assert targetClass.instanceFields().length == 0;
+    assert sourceClass.instanceFields().size() == 0;
+    assert targetClass.instanceFields().size() == 0;
 
     numberOfMergedClasses++;
 
@@ -534,27 +534,31 @@
   }
 
   private DexEncodedField[] mergeFields(
-      DexEncodedField[] sourceFields, DexEncodedField[] targetFields, DexProgramClass targetClass) {
-    DexEncodedField[] result = new DexEncodedField[sourceFields.length + targetFields.length];
+      List<DexEncodedField> sourceFields,
+      List<DexEncodedField> targetFields,
+      DexProgramClass targetClass) {
+    DexEncodedField[] result = new DexEncodedField[sourceFields.size() + targetFields.size()];
 
     // Move all target fields to result.
-    System.arraycopy(targetFields, 0, result, 0, targetFields.length);
+    int index = 0;
+    for (DexEncodedField targetField : targetFields) {
+      result[index++] = targetField;
+    }
 
     // Move source fields to result one by one, renaming them if needed.
     FieldSignatureEquivalence equivalence = FieldSignatureEquivalence.get();
     Set<Wrapper<DexField>> existingFields =
-        Arrays.stream(targetFields)
+        targetFields.stream()
             .map(targetField -> equivalence.wrap(targetField.field))
             .collect(Collectors.toSet());
 
     Predicate<DexField> availableFieldSignatures =
         field -> !existingFields.contains(equivalence.wrap(field));
 
-    int i = targetFields.length;
     for (DexEncodedField sourceField : sourceFields) {
       DexEncodedField sourceFieldAfterMove =
           renameFieldIfNeeded(sourceField, targetClass, availableFieldSignatures);
-      result[i++] = sourceFieldAfterMove;
+      result[index++] = sourceFieldAfterMove;
 
       DexField originalField =
           fieldMapping.inverse().getOrDefault(sourceField.field, sourceField.field);
@@ -563,6 +567,7 @@
       existingFields.add(equivalence.wrap(sourceFieldAfterMove.field));
     }
 
+    assert index == result.length;
     return result;
   }
 
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 8017878..833cac3 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -21,7 +21,6 @@
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -109,8 +108,14 @@
         if (reachableVirtualMethods != null) {
           clazz.setVirtualMethods(reachableVirtualMethods);
         }
-        clazz.setInstanceFields(reachableFields(clazz.instanceFields()));
-        clazz.setStaticFields(reachableFields(clazz.staticFields()));
+        DexEncodedField[] reachableInstanceFields = reachableFields(clazz.instanceFields());
+        if (reachableInstanceFields != null) {
+          clazz.setInstanceFields(reachableInstanceFields);
+        }
+        DexEncodedField[] reachableStaticFields = reachableFields(clazz.staticFields());
+        if (reachableStaticFields != null) {
+          clazz.setStaticFields(reachableStaticFields);
+        }
         clazz.removeInnerClasses(this::isAttributeReferencingPrunedType);
         clazz.removeEnclosingMethod(this::isAttributeReferencingPrunedItem);
         usagePrinter.visited();
@@ -221,36 +226,37 @@
         usagePrinter.printUnusedMethod(method);
       }
     }
-    return reachableMethods.toArray(new DexEncodedMethod[reachableMethods.size()]);
+    return reachableMethods.isEmpty()
+        ? DexEncodedMethod.EMPTY_ARRAY
+        : reachableMethods.toArray(DexEncodedMethod.EMPTY_ARRAY);
   }
 
-  private DexEncodedField[] reachableFields(DexEncodedField[] fields) {
+  private DexEncodedField[] reachableFields(List<DexEncodedField> fields) {
     Predicate<DexField> isReachableOrReferencedField =
         field ->
             appInfo.liveFields.contains(field)
                 || appInfo.isFieldRead(field)
                 || appInfo.isFieldWritten(field);
-    int firstUnreachable =
-        firstUnreachableIndex(Arrays.asList(fields), isReachableOrReferencedField);
+    int firstUnreachable = firstUnreachableIndex(fields, isReachableOrReferencedField);
     // Return the original array if all fields are used.
     if (firstUnreachable == -1) {
-      return fields;
+      return null;
     }
     if (Log.ENABLED) {
-      Log.debug(getClass(), "Removing field: " + fields[firstUnreachable]);
+      Log.debug(getClass(), "Removing field %s.", fields.get(firstUnreachable));
     }
-    usagePrinter.printUnusedField(fields[firstUnreachable]);
-    ArrayList<DexEncodedField> reachableOrReferencedFields = new ArrayList<>(fields.length);
+    usagePrinter.printUnusedField(fields.get(firstUnreachable));
+    ArrayList<DexEncodedField> reachableOrReferencedFields = new ArrayList<>(fields.size());
     for (int i = 0; i < firstUnreachable; i++) {
-      reachableOrReferencedFields.add(fields[i]);
+      reachableOrReferencedFields.add(fields.get(i));
     }
-    for (int i = firstUnreachable + 1; i < fields.length; i++) {
-      DexEncodedField field = fields[i];
+    for (int i = firstUnreachable + 1; i < fields.size(); i++) {
+      DexEncodedField field = fields.get(i);
       if (isReachableOrReferencedField.test(field.field)) {
         reachableOrReferencedFields.add(field);
       } else {
         if (Log.ENABLED) {
-          Log.debug(getClass(), "Removing field: " + field);
+          Log.debug(getClass(), "Removing field %s.", field.field);
         }
         usagePrinter.printUnusedField(field);
       }
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 acfc42f..f6941d3 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClass.FieldSetter;
 import com.android.tools.r8.graph.DexClass.MethodSetter;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -1259,11 +1260,11 @@
     }
 
     private DexEncodedField[] mergeFields(
-        DexEncodedField[] sourceFields,
-        DexEncodedField[] targetFields,
+        Collection<DexEncodedField> sourceFields,
+        Collection<DexEncodedField> targetFields,
         Predicate<DexField> availableFieldSignatures,
         Set<DexString> existingFieldNames) {
-      DexEncodedField[] result = new DexEncodedField[sourceFields.length + targetFields.length];
+      DexEncodedField[] result = new DexEncodedField[sourceFields.size() + targetFields.size()];
       // Add fields from source
       int i = 0;
       for (DexEncodedField field : sourceFields) {
@@ -1274,21 +1275,10 @@
         i++;
       }
       // Add fields from target.
-      System.arraycopy(targetFields, 0, result, i, targetFields.length);
-      return result;
-    }
-
-    private DexEncodedMethod[] mergeMethods(
-        Collection<DexEncodedMethod> sourceMethods, List<DexEncodedMethod> targetMethods) {
-      DexEncodedMethod[] result = new DexEncodedMethod[sourceMethods.size() + targetMethods.size()];
-      // Add methods from source.
-      int i = 0;
-      for (DexEncodedMethod method : sourceMethods) {
-        result[i] = method;
+      for (DexEncodedField field : targetFields) {
+        result[i] = field;
         i++;
       }
-      // Add methods from target.
-      System.arraycopy(targetMethods, 0, result, i, targetMethods.size());
       return result;
     }
 
@@ -1434,8 +1424,8 @@
       for (DexProgramClass clazz : appInfo.classes()) {
         fixupMethods(clazz.directMethods(), clazz::setDirectMethod);
         fixupMethods(clazz.virtualMethods(), clazz::setVirtualMethod);
-        clazz.setStaticFields(substituteTypesIn(clazz.staticFields()));
-        clazz.setInstanceFields(substituteTypesIn(clazz.instanceFields()));
+        fixupFields(clazz.staticFields(), clazz::setStaticField);
+        fixupFields(clazz.instanceFields(), clazz::setInstanceField);
       }
       for (SynthesizedBridgeCode synthesizedBridge : synthesizedBridges) {
         synthesizedBridge.updateMethodSignatures(this::fixupMethod);
@@ -1462,22 +1452,21 @@
       }
     }
 
-    private DexEncodedField[] substituteTypesIn(DexEncodedField[] fields) {
+    private void fixupFields(List<DexEncodedField> fields, FieldSetter setter) {
       if (fields == null) {
-        return null;
+        return;
       }
-      for (int i = 0; i < fields.length; i++) {
-        DexEncodedField encodedField = fields[i];
+      for (int i = 0; i < fields.size(); i++) {
+        DexEncodedField encodedField = fields.get(i);
         DexField field = encodedField.field;
         DexType newType = fixupType(field.type);
         DexType newHolder = fixupType(field.clazz);
         DexField newField = application.dexItemFactory.createField(newHolder, newType, field.name);
         if (newField != encodedField.field) {
           lense.move(encodedField.field, newField);
-          fields[i] = encodedField.toTypeSubstitutedField(newField);
+          setter.setField(i, encodedField.toTypeSubstitutedField(newField));
         }
       }
-      return fields;
     }
 
     private DexMethod fixupMethod(DexMethod method) {
diff --git a/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java b/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java
index 9c9e785..e92e0f3 100644
--- a/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java
+++ b/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java
@@ -94,7 +94,7 @@
     assertThat(clazz, isPresent());
 
     // Redundant fields have been removed.
-    assertEquals(1, clazz.getDexClass().instanceFields().length);
-    assertEquals(1, clazz.getDexClass().staticFields().length);
+    assertEquals(1, clazz.getDexClass().instanceFields().size());
+    assertEquals(1, clazz.getDexClass().staticFields().size());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
index 7e9269d..82f8688 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
@@ -242,7 +242,7 @@
 
   private static int getLambdaSingletons(DexClass clazz) {
     assertEquals(1, clazz.interfaces.size());
-    return clazz.staticFields().length;
+    return clazz.staticFields().size();
   }
 
   private static boolean isLambdaOrGroup(DexClass clazz) {
diff --git a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
index d06809e..e247098 100644
--- a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
@@ -310,8 +310,8 @@
   }
 
   private static int countRenamedClassIdentifier(
-      CodeInspector inspector, DexEncodedField[] fields) {
-    return Arrays.stream(fields)
+      CodeInspector inspector, List<DexEncodedField> fields) {
+    return fields.stream()
         .filter(encodedField -> encodedField.getStaticValue() instanceof DexValueString)
         .reduce(0, (cnt, encodedField) -> {
           String cnstString =
diff --git a/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java b/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
index e5f3517..6196bb7 100644
--- a/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
@@ -6,8 +6,6 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.OutputMode;
-import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.shaking.PrintUsageTest.PrintUsageInspector.ClassSubject;
@@ -21,20 +19,16 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
@@ -50,9 +44,6 @@
   private final List<String> keepRulesFiles;
   private final Consumer<PrintUsageInspector> inspection;
 
-  @Rule
-  public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
-
   public PrintUsageTest(
       Backend backend,
       String test,
@@ -68,33 +59,19 @@
   @Before
   public void runR8andGetPrintUsage() throws Exception {
     Path out = temp.getRoot().toPath();
-    R8Command.Builder builder =
-        ToolHelper.addProguardConfigurationConsumer(
-                R8Command.builder(),
-                pgConfig -> {
-                  pgConfig.setPrintUsage(true);
-                  pgConfig.setPrintUsageFile(out.resolve(test + PRINT_USAGE_FILE_SUFFIX));
-                })
-            .addProgramFiles(Paths.get(programFile))
-            .addProguardConfigurationFiles(ListUtils.map(keepRulesFiles, Paths::get));
-
-    if (backend == Backend.DEX) {
-      builder
-          .setOutput(out, OutputMode.DexIndexed)
-          .addLibraryFiles(ToolHelper.getDefaultAndroidJar());
-    } else {
-      builder.setOutput(out, OutputMode.ClassFile).addLibraryFiles(ToolHelper.getJava8RuntimeJar());
-    }
-    ToolHelper.runR8(
-        builder.build(),
-        options -> {
-          // Disable inlining to make this test not depend on inlining decisions.
-          options.enableInlining = false;
-        });
+    testForR8(backend)
+        .addProgramFiles(Paths.get(programFile))
+        .addKeepRuleFiles(ListUtils.map(keepRulesFiles, Paths::get))
+        .addKeepRules(
+            "-printusage " + out.resolve(test + PRINT_USAGE_FILE_SUFFIX)
+        )
+        // Disable inlining to make this test not depend on inlining decisions.
+        .addOptionsModification(o -> o.enableInlining = false)
+        .compile();
   }
 
   @Test
-  public void printUsageTest() throws IOException, ExecutionException {
+  public void printUsageTest() throws IOException {
     Path out = temp.getRoot().toPath();
     Path printUsageFile = out.resolve(test + PRINT_USAGE_FILE_SUFFIX);
     if (inspection != null) {
@@ -118,20 +95,20 @@
 
     List<Object[]> testCases = new ArrayList<>();
     for (Backend backend : Backend.values()) {
-    Set<String> usedInspections = new HashSet<>();
-    for (String test : tests) {
-      File[] keepFiles = new File(ToolHelper.EXAMPLES_DIR + test)
-          .listFiles(file -> file.isFile() && file.getName().endsWith(".txt"));
-      for (File keepFile : keepFiles) {
-        String keepName = keepFile.getName();
-        Consumer<PrintUsageInspector> inspection =
-            getTestOptionalParameter(inspections, usedInspections, test, keepName);
-        if (inspection != null) {
+      Set<String> usedInspections = new HashSet<>();
+      for (String test : tests) {
+        File[] keepFiles = new File(ToolHelper.EXAMPLES_DIR + test)
+            .listFiles(file -> file.isFile() && file.getName().endsWith(".txt"));
+        for (File keepFile : keepFiles) {
+          String keepName = keepFile.getName();
+          Consumer<PrintUsageInspector> inspection =
+              getTestOptionalParameter(inspections, usedInspections, test, keepName);
+          if (inspection != null) {
             testCases.add(
                 new Object[] {backend, test, ImmutableList.of(keepFile.getPath()), inspection});
+          }
         }
       }
-    }
       assert usedInspections.size() == inspections.size();
     }
     return testCases;
@@ -152,6 +129,9 @@
   }
 
   private static void inspectShaking1(PrintUsageInspector inspector) {
+    Optional<ClassSubject> shaking1 = inspector.clazz("shaking1.Shaking");
+    assertTrue(shaking1.isPresent());
+    assertTrue(shaking1.get().method("void", "<init>", ImmutableList.of()));
     assertTrue(inspector.clazz("shaking1.Unused").isPresent());
     assertTrue(inspector.clazz("shaking1.Used").isPresent());
     ClassSubject used = inspector.clazz("shaking1.Used").get();
@@ -165,10 +145,10 @@
     assertTrue(staticFields.get().field("int", "unused"));
     Optional<ClassSubject> subClass1 = inspector.clazz("shaking2.SubClass1");
     assertTrue(subClass1.isPresent());
-    assertTrue(subClass1.get().method("void", "unusedVirtualMethod", Collections.emptyList()));
+    assertTrue(subClass1.get().method("void", "unusedVirtualMethod", ImmutableList.of()));
     Optional<ClassSubject> superClass = inspector.clazz("shaking2.SuperClass");
     assertTrue(superClass.isPresent());
-    assertTrue(superClass.get().method("void", "unusedStaticMethod", Collections.emptyList()));
+    assertTrue(superClass.get().method("void", "unusedStaticMethod", ImmutableList.of()));
   }
 
   private static void inspectShaking4(PrintUsageInspector inspector) {
@@ -188,15 +168,15 @@
     assertFalse(superClass.isPresent());
     Optional<ClassSubject> subClass = inspector.clazz("shaking9.Subclass");
     assertTrue(subClass.isPresent());
-    assertTrue(subClass.get().method("void", "aMethod", Collections.emptyList()));
-    assertFalse(subClass.get().method("void", "<init>", Collections.emptyList()));
+    assertTrue(subClass.get().method("void", "aMethod", ImmutableList.of()));
+    assertFalse(subClass.get().method("void", "<init>", ImmutableList.of()));
   }
 
   private static void inspectShaking12(PrintUsageInspector inspector) {
     assertFalse(inspector.clazz("shaking12.PeopleClass").isPresent());
     Optional<ClassSubject> animal = inspector.clazz("shaking12.AnimalClass");
     assertTrue(animal.isPresent());
-    assertTrue(animal.get().method("java.lang.String", "getName", Collections.emptyList()));
+    assertTrue(animal.get().method("java.lang.String", "getName", ImmutableList.of()));
   }
 
   static class PrintUsageInspector {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index ebaf5af..058a19d 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -109,12 +109,12 @@
   @Override
   public void forAllFields(Consumer<FoundFieldSubject> inspection) {
     CodeInspector.forAll(
-        Arrays.asList(dexClass.staticFields()),
+        dexClass.staticFields(),
         (dexField, clazz) -> new FoundFieldSubject(codeInspector, dexField, clazz),
         this,
         inspection);
     CodeInspector.forAll(
-        Arrays.asList(dexClass.instanceFields()),
+        dexClass.instanceFields(),
         (dexField, clazz) -> new FoundFieldSubject(codeInspector, dexField, clazz),
         this,
         inspection);
@@ -175,7 +175,7 @@
     return dexClass.accessFlags.isAnnotation();
   }
 
-  private DexEncodedField findField(DexEncodedField[] fields, DexField dexField) {
+  private DexEncodedField findField(List<DexEncodedField> fields, DexField dexField) {
     for (DexEncodedField field : fields) {
       if (field.field.equals(dexField)) {
         return field;