diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
index 383f816..05feecc 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
@@ -7,7 +7,6 @@
 import com.android.tools.r8.dex.MixedSectionCollection;
 import com.android.tools.r8.ir.code.ConstInstruction;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.optimize.info.DefaultFieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.MutableFieldOptimizationInfo;
@@ -150,36 +149,12 @@
    * <p>NOTE: It is the responsibility of the caller to check if this field is pinned or not.
    */
   public ConstInstruction valueAsConstInstruction(
-      IRCode code, Value dest, AppView<AppInfoWithLiveness> appView) {
-    // If it is a static field, we can only propagate the value if class initialization does not
-    // have side effects.
-    if (isStatic()) {
-      DexClass clazz = appView.definitionFor(field.holder);
-      if (clazz == null) {
-        return null;
-      }
-      DexType context = code.method.method.holder;
-      if (clazz.classInitializationMayHaveSideEffects(
-          appView,
-          // Types that are a super type of the current context are guaranteed to be initialized
-          // already.
-          type -> appView.isSubtype(context, type).isTrue())) {
-        // Ignore class initialization side-effects for dead proto extension fields to ensure that
-        // we force replace these field reads by null.
-        boolean ignore =
-            appView.withGeneratedExtensionRegistryShrinker(
-                shrinker -> shrinker.isDeadProtoExtensionField(field), false);
-        if (!ignore) {
-          return null;
-        }
-      }
-    }
-
+      IRCode code, DebugLocalInfo local, AppView<AppInfoWithLiveness> appView) {
     boolean isWritten = appView.appInfo().isFieldWrittenByFieldPutInstruction(this);
     if (!isWritten) {
       // Since the field is not written, we can simply return the default value for the type.
       DexValue value = isStatic() ? getStaticValue() : DexValue.defaultForType(field.type);
-      return value.asConstInstruction(code, dest, appView.options());
+      return value.asConstInstruction(appView, code, local);
     }
 
     // The only way to figure out whether the DexValue contains the final value is ensure the value
@@ -191,13 +166,38 @@
       }
       DexValue staticValue = getStaticValue();
       if (!staticValue.isDefault(field.type)) {
-        return staticValue.asConstInstruction(code, dest, appView.options());
+        return staticValue.asConstInstruction(appView, code, local);
       }
     }
 
     return null;
   }
 
+  public boolean mayTriggerClassInitializationSideEffects(
+      AppView<AppInfoWithLiveness> appView, DexType context) {
+    // Only static field matters when it comes to class initialization side effects.
+    if (!isStatic()) {
+      return false;
+    }
+    DexClass clazz = appView.definitionFor(field.holder);
+    if (clazz == null) {
+      return true;
+    }
+    if (clazz.classInitializationMayHaveSideEffects(
+        appView,
+        // Types that are a super type of the current context are guaranteed to be initialized
+        // already.
+        type -> appView.isSubtype(context, type).isTrue())) {
+      // Ignore class initialization side-effects for dead proto extension fields to ensure that
+      // we force replace these field reads by null.
+      boolean ignore =
+          appView.withGeneratedExtensionRegistryShrinker(
+              shrinker -> shrinker.isDeadProtoExtensionField(field), false);
+      return !ignore;
+    }
+    return false;
+  }
+
   public DexEncodedField toTypeSubstitutedField(DexField field) {
     if (this.field == field) {
       return this;
diff --git a/src/main/java/com/android/tools/r8/graph/DexValue.java b/src/main/java/com/android/tools/r8/graph/DexValue.java
index f9b12d3..aa6b651 100644
--- a/src/main/java/com/android/tools/r8/graph/DexValue.java
+++ b/src/main/java/com/android/tools/r8/graph/DexValue.java
@@ -3,21 +3,23 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
+import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
+
 import com.android.tools.r8.dex.DexOutputBuffer;
 import com.android.tools.r8.dex.FileWriter;
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.dex.MixedSectionCollection;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.BasicBlock.ThrowingInfo;
 import com.android.tools.r8.ir.code.ConstInstruction;
-import com.android.tools.r8.ir.code.ConstNumber;
 import com.android.tools.r8.ir.code.ConstString;
 import com.android.tools.r8.ir.code.DexItemBasedConstString;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.naming.dexitembasedstring.NameComputationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.EncodedValueUtils;
-import com.android.tools.r8.utils.InternalOptions;
 import java.util.Arrays;
 import org.objectweb.asm.Handle;
 import org.objectweb.asm.Type;
@@ -139,7 +141,8 @@
   public abstract Object getBoxedValue();
 
   /** Returns an instruction that can be used to materialize this {@link DexValue} (or null). */
-  public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
+  public ConstInstruction asConstInstruction(
+      AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
     return null;
   }
 
@@ -214,7 +217,8 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
       return null;
     }
   }
@@ -301,8 +305,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      return new ConstNumber(dest, value);
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createIntConstant(value, local);
     }
   }
 
@@ -357,8 +362,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      return new ConstNumber(dest, value);
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createIntConstant(value, local);
     }
   }
 
@@ -417,8 +423,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      return new ConstNumber(dest, value);
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createIntConstant(value, local);
     }
   }
 
@@ -473,8 +480,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      return new ConstNumber(dest, value);
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createIntConstant(value, local);
     }
   }
 
@@ -529,8 +537,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      return new ConstNumber(dest, value);
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createLongConstant(value, local);
     }
   }
 
@@ -571,6 +580,12 @@
     }
 
     @Override
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createFloatConstant(value, local);
+    }
+
+    @Override
     public int hashCode() {
       return (int) (value * 19);
     }
@@ -629,6 +644,12 @@
     }
 
     @Override
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createDoubleConstant(value, local);
+    }
+
+    @Override
     public int hashCode() {
       return (int) (value * 29);
     }
@@ -733,9 +754,12 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      TypeLatticeElement type = TypeLatticeElement.stringClassType(appView, definitelyNotNull());
+      Value outValue = code.createValue(type, local);
       ConstString instruction =
-          new ConstString(dest, value, ThrowingInfo.defaultForConstString(options));
+          new ConstString(outValue, value, ThrowingInfo.defaultForConstString(appView.options()));
       if (!instruction.instructionInstanceCanThrow()) {
         return instruction;
       }
@@ -773,10 +797,16 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      TypeLatticeElement type = TypeLatticeElement.stringClassType(appView, definitelyNotNull());
+      Value outValue = code.createValue(type, local);
       DexItemBasedConstString instruction =
           new DexItemBasedConstString(
-              dest, value, nameComputationInfo, ThrowingInfo.defaultForConstString(options));
+              outValue,
+              value,
+              nameComputationInfo,
+              ThrowingInfo.defaultForConstString(appView.options()));
       // DexItemBasedConstString cannot throw.
       assert !instruction.instructionInstanceCanThrow();
       return instruction;
@@ -1055,11 +1085,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      if (dest.getTypeLattice().isNullType()) {
-        return new ConstNumber(dest, 0);
-      }
-      return code.createConstNull(dest.getLocalInfo());
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createConstNull(local);
     }
   }
 
@@ -1118,8 +1146,9 @@
     }
 
     @Override
-    public ConstInstruction asConstInstruction(IRCode code, Value dest, InternalOptions options) {
-      return new ConstNumber(dest, value ? 1 : 0);
+    public ConstInstruction asConstInstruction(
+        AppView<? extends AppInfoWithSubtyping> appView, IRCode code, DebugLocalInfo local) {
+      return code.createIntConstant(BooleanUtils.intValue(value), local);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index ce02bf6..99a4956 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -1008,15 +1008,34 @@
     return createValue(typeLattice, null);
   }
 
-  public Phi createPhi(BasicBlock block, TypeLatticeElement type) {
-    return new Phi(valueNumberGenerator.next(), block, type, null, RegisterReadType.NORMAL);
+  public ConstNumber createDoubleConstant(double value, DebugLocalInfo local) {
+    Value out = createValue(TypeLatticeElement.DOUBLE, local);
+    return new ConstNumber(out, Double.doubleToLongBits(value));
+  }
+
+  public ConstNumber createFloatConstant(float value, DebugLocalInfo local) {
+    Value out = createValue(TypeLatticeElement.FLOAT, local);
+    return new ConstNumber(out, Float.floatToIntBits(value));
   }
 
   public ConstNumber createIntConstant(int value) {
-    Value out = createValue(TypeLatticeElement.INT);
+    return createIntConstant(value, null);
+  }
+
+  public ConstNumber createIntConstant(int value, DebugLocalInfo local) {
+    Value out = createValue(TypeLatticeElement.INT, local);
     return new ConstNumber(out, value);
   }
 
+  public ConstNumber createLongConstant(long value, DebugLocalInfo local) {
+    Value out = createValue(TypeLatticeElement.LONG, local);
+    return new ConstNumber(out, value);
+  }
+
+  public Phi createPhi(BasicBlock block, TypeLatticeElement type) {
+    return new Phi(valueNumberGenerator.next(), block, type, null, RegisterReadType.NORMAL);
+  }
+
   public final int getHighestBlockNumber() {
     return blocks.stream().max(Comparator.comparingInt(BasicBlock::getNumber)).get().getNumber();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index 9cc26c4..dfb1787 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -156,8 +156,12 @@
             continue;
           }
 
-          // We have a descriptor, get or create lambda class.
-          LambdaClass lambdaClass = getOrCreateLambdaClass(descriptor, currentType);
+          // We have a descriptor, get the lambda class. In D8, we synthesize the lambda classes
+          // during IR processing, and therefore we may need to create it now.
+          LambdaClass lambdaClass =
+              appView.enableWholeProgramOptimizations()
+                  ? getKnownLambdaClass(descriptor, currentType)
+                  : getOrCreateLambdaClass(descriptor, currentType);
           assert lambdaClass != null;
 
           // We rely on patch performing its work in a way which
@@ -325,6 +329,11 @@
     return lambdaClass;
   }
 
+  private LambdaClass getKnownLambdaClass(LambdaDescriptor descriptor, DexType accessedFrom) {
+    DexType lambdaClassType = LambdaClass.createLambdaClassType(this, accessedFrom, descriptor);
+    return getKnown(knownLambdaClasses, lambdaClassType);
+  }
+
   private void addRewritingPrefix(DexType type, DexType rewritten, DexType lambdaClassType) {
     String javaName = lambdaClassType.toString();
     String typeString = type.toString();
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 787cf33..62d5bd8 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
@@ -151,8 +151,8 @@
         return null;
       }
 
-      Value value = code.createValue(typeLattice, instruction.getLocalInfo());
-      ConstInstruction replacement = staticField.valueAsConstInstruction(code, value, appView);
+      ConstInstruction replacement =
+          staticField.valueAsConstInstruction(code, instruction.getLocalInfo(), appView);
       if (replacement == null) {
         reporter.warning(
             new StringDiagnostic(
@@ -369,10 +369,23 @@
       return;
     }
 
-    ConstInstruction replacement = target.valueAsConstInstruction(code, current.dest(), appView);
+    ConstInstruction replacement =
+        target.valueAsConstInstruction(code, current.outValue().getLocalInfo(), appView);
     if (replacement != null) {
       affectedValues.addAll(current.outValue().affectedValues());
-      iterator.replaceCurrentInstruction(replacement);
+      if (target.mayTriggerClassInitializationSideEffects(appView, code.method.method.holder)) {
+        // To preserve class initialization side effects, original static-get remains as-is, but its
+        // value is replaced with constant.
+        replacement.setPosition(current.getPosition());
+        current.outValue().replaceUsers(replacement.outValue());
+        if (current.getBlock().hasCatchHandlers()) {
+          iterator.split(code, blocks).listIterator(code).add(replacement);
+        } else {
+          iterator.add(replacement);
+        }
+      } else {
+        iterator.replaceCurrentInstruction(replacement);
+      }
       if (replacement.isDexItemBasedConstString()) {
         code.method.getMutableOptimizationInfo().markUseIdentifierNameString();
       }
@@ -398,7 +411,8 @@
     }
 
     // Check if a this value is known const.
-    ConstInstruction replacement = target.valueAsConstInstruction(code, current.dest(), appView);
+    ConstInstruction replacement =
+        target.valueAsConstInstruction(code, current.outValue().getLocalInfo(), appView);
     if (replacement != null) {
       affectedValues.add(replacement.outValue());
       iterator.replaceCurrentInstruction(replacement);
diff --git a/src/test/examples/shaking2/Shaking.java b/src/test/examples/shaking2/Shaking.java
index f99fd8c..d521c29 100644
--- a/src/test/examples/shaking2/Shaking.java
+++ b/src/test/examples/shaking2/Shaking.java
@@ -26,6 +26,7 @@
         " " + StaticFields.readBoolean+
         " " + StaticFields.readByte +
         " " + StaticFields.readChar +
+        " " + StaticFields.readFloat +
         " " + StaticFields.readObject +
         " " + StaticFields.readShort +
         " " + StaticFields.readDouble);
@@ -33,9 +34,10 @@
     StaticFields.writeBoolean = true;
     StaticFields.writeByte = 2;
     StaticFields.writeChar = 3;
+    StaticFields.writeFloat = 3.3f;
     StaticFields.writeObject = new Object();
     StaticFields.writeShort = 3;
-    StaticFields.writeDouble = 3.3;
+    StaticFields.writeDouble = 3.3d;
   }
 
   public static void main(String[] args) {
diff --git a/src/test/examples/shaking2/StaticFields.java b/src/test/examples/shaking2/StaticFields.java
index 80bf6ba..f685893 100644
--- a/src/test/examples/shaking2/StaticFields.java
+++ b/src/test/examples/shaking2/StaticFields.java
@@ -18,6 +18,8 @@
   public static byte writeByte;
   public static char readChar;
   public static char writeChar;
+  public static float readFloat;
+  public static float writeFloat;
   public static Object readObject;
   public static Object writeObject;
   public static short readShort;
diff --git a/src/test/examples/shaking2/keep-rules-printusage.txt b/src/test/examples/shaking2/keep-rules-printusage.txt
index 5db2d89..bbe7eb6 100644
--- a/src/test/examples/shaking2/keep-rules-printusage.txt
+++ b/src/test/examples/shaking2/keep-rules-printusage.txt
@@ -6,3 +6,10 @@
 
 -dontobfuscate
 -printusage
+
+# TODO(b/142571411): If the class becomes entirely dead in the second round of
+# tree shaking, we respond incorrectly to printusage.
+-neverpropagatevalue class shaking2.StaticFields {
+  float readDouble;
+  float readFloat;
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/corelib/desugar_jdk_libs.json b/src/test/java/com/android/tools/r8/desugar/corelib/desugar_jdk_libs.json
index fa917a3..79bc84f 100644
--- a/src/test/java/com/android/tools/r8/desugar/corelib/desugar_jdk_libs.json
+++ b/src/test/java/com/android/tools/r8/desugar/corelib/desugar_jdk_libs.json
@@ -1,6 +1,6 @@
 {
   "configuration_format_version": 1,
-  "version": "0.5.0",
+  "version": "0.6.0",
   "required_compilation_api_level": 26,
   "library_flags": [
     {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ClassInitializerDefaultsPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ClassInitializerDefaultsPropagationTest.java
new file mode 100644
index 0000000..28f75a7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ClassInitializerDefaultsPropagationTest.java
@@ -0,0 +1,81 @@
+// Copyright (c) 2019, 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;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+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.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ClassInitializerDefaultsPropagationTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ClassInitializerDefaultsPropagationTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("42.42", "42.42");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject classSubject = inspector.clazz(TestClass.class);
+    assertThat(classSubject, isPresent());
+
+    // Both fields end up being dead due to member value propagation.
+    assertEquals(0, classSubject.allFields().size());
+
+    // Verify that there are two distinct numbers in the code.
+    long floatValue = Float.floatToIntBits(42.42f);
+    long doubleValue = Double.doubleToLongBits(42.42d);
+    assertNotEquals(floatValue, doubleValue);
+    assertEquals(
+        2,
+        classSubject
+            .mainMethod()
+            .streamInstructions()
+            .filter(x -> x.isConstNumber(floatValue) || x.isConstNumber(doubleValue))
+            .count());
+  }
+
+  static class TestClass {
+
+    static float f = 42.42f;
+    static double d = 42.42d;
+
+    public static void main(String[] args) {
+      // Test that we correctly map from float bits to int bits during member value propagation.
+      System.out.println(f);
+
+      // Test that we correctly map from double bits to long bits during member value propagation.
+      System.out.println(d);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
new file mode 100644
index 0000000..9c32e92
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
@@ -0,0 +1,133 @@
+// Copyright (c) 2019, 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;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+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.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MemberValuePropagationWithClassInitializationTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public MemberValuePropagationWithClassInitializationTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(MemberValuePropagationWithClassInitializationTest.class)
+        .addKeepMainRule(TestClass.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("A!", "B!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    // A.field is present.
+    ClassSubject aClassSubject = inspector.clazz(A.class);
+    assertThat(aClassSubject, isPresent());
+
+    FieldSubject fieldSubject = aClassSubject.uniqueFieldWithName("field");
+    assertThat(fieldSubject, isPresent());
+
+    // B.method() is present.
+    ClassSubject bClassSubject = inspector.clazz(B.class);
+    assertThat(bClassSubject, isPresent());
+
+    MethodSubject methodSubject = bClassSubject.uniqueMethodWithName("method");
+    assertThat(methodSubject, isPresent());
+
+    // TestClass.missingFieldValuePropagation() and TestClass.missingMethodValuePropagation() are
+    // absent.
+    ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+    assertThat(testClassSubject, isPresent());
+    assertThat(
+        testClassSubject.uniqueMethodWithName("missingFieldValuePropagation"), not(isPresent()));
+    assertThat(
+        testClassSubject.uniqueMethodWithName("missingMethodValuePropagation"), not(isPresent()));
+
+    // TestClass.main() still accesses A.field and invokes B.method().
+    MethodSubject mainMethodSubject = testClassSubject.mainMethod();
+    assertThat(mainMethodSubject, isPresent());
+    assertTrue(
+        mainMethodSubject
+            .streamInstructions()
+            .filter(InstructionSubject::isStaticGet)
+            .anyMatch(x -> x.getField() == fieldSubject.getField().field));
+    assertTrue(
+        mainMethodSubject
+            .streamInstructions()
+            .filter(InstructionSubject::isInvokeStatic)
+            .anyMatch(x -> x.getMethod() == methodSubject.getMethod().method));
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      if (A.field) {
+        missingFieldValuePropagation();
+      }
+      if (B.method()) {
+        missingMethodValuePropagation();
+      }
+    }
+
+    @NeverInline
+    static void missingFieldValuePropagation() {
+      System.out.println("Missing field value propagation!");
+    }
+
+    @NeverInline
+    static void missingMethodValuePropagation() {
+      System.out.println("Missing method value propagation!");
+    }
+  }
+
+  static class A {
+
+    static boolean field = false;
+
+    static {
+      System.out.println("A!");
+    }
+  }
+
+  static class B {
+
+    static {
+      System.out.println("B!");
+    }
+
+    static boolean method() {
+      return false;
+    }
+  }
+}
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 e4bd7c8..327e1b5 100644
--- a/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
@@ -62,11 +62,10 @@
     testForR8(backend)
         .addProgramFiles(Paths.get(programFile))
         .addKeepRuleFiles(ListUtils.map(keepRulesFiles, Paths::get))
-        .addKeepRules(
-            "-printusage " + out.resolve(test + PRINT_USAGE_FILE_SUFFIX)
-        )
+        .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)
+        .enableProguardTestOptions()
         .compile();
   }
 
diff --git a/tools/create_maven_release.py b/tools/create_maven_release.py
index 30c14c8..6d7d8ab 100755
--- a/tools/create_maven_release.py
+++ b/tools/create_maven_release.py
@@ -98,7 +98,7 @@
   <dependencies>
     <groupId>com.android.tools</groupId>
     <artifactId>desugar_jdk_libs</artifactId>
-    <version>1.0.0</version>
+    <version>1.0.1</version>
   </dependencies>
   <developers>
     <developer>
diff --git a/tools/internal_test.py b/tools/internal_test.py
index f4f109f..9654b4b 100755
--- a/tools/internal_test.py
+++ b/tools/internal_test.py
@@ -69,24 +69,23 @@
         'find-xmx-min': 256,
         'find-xmx-max': 450,
         'find-xmx-range': 16,
-        'oom-threshold': 392,
+        'oom-threshold': 426,
     },
     {
         'app': 'youtube',
         'version': '12.22',
-        'find-xmx-min': 1200,
-        'find-xmx-max': 800,
+        'find-xmx-min': 800,
+        'find-xmx-max': 1200,
         'find-xmx-range': 32,
         'oom-threshold': 1000,
     },
-    # TODO(b/142375244): Narrow when run a few times.
     {
         'app': 'iosched',
         'version': '2019',
         'find-xmx-min': 128,
         'find-xmx-max': 1024,
         'find-xmx-range': 16,
-        'oom-threshold': 666, # will be changed after b/142375244 has run
+        'oom-threshold': 267,
     },
 ]