diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 6a8520e..5cf69c1 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -55,6 +55,7 @@
 import com.android.tools.r8.graph.ObjectAllocationInfoCollectionImpl;
 import com.android.tools.r8.graph.PresortedComparable;
 import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.graph.ProgramMember;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.graph.ResolutionResult.FailedResolutionResult;
@@ -89,6 +90,7 @@
 import com.android.tools.r8.shaking.KeepInfoCollection.MutableKeepInfoCollection;
 import com.android.tools.r8.shaking.RootSetBuilder.ConsequentRootSet;
 import com.android.tools.r8.shaking.RootSetBuilder.ItemsWithRules;
+import com.android.tools.r8.shaking.RootSetBuilder.MutableItemsWithRules;
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.shaking.ScopedDexMethodSet.AddMethodIfMoreVisibleResult;
 import com.android.tools.r8.utils.Action;
@@ -2336,6 +2338,8 @@
     // Add all dependent members to the workqueue.
     enqueueRootItems(rootSet.getDependentItems(field.getDefinition()));
 
+    checkMemberForSoftPinning(field);
+
     // Notify analyses.
     analyses.forEach(analysis -> analysis.processNewlyLiveField(field));
   }
@@ -2352,6 +2356,8 @@
     // Add all dependent members to the workqueue.
     enqueueRootItems(rootSet.getDependentItems(field.getDefinition()));
 
+    checkMemberForSoftPinning(field);
+
     // Notify analyses.
     analyses.forEach(analysis -> analysis.processNewlyLiveField(field));
   }
@@ -3337,12 +3343,26 @@
             enqueueRootItems(dependentItems);
           }
         });
+    consequentRootSet.dependentSoftPinned.forEach(
+        (reference, dependentItems) -> {
+          if (isLiveProgramReference(reference)) {
+            dependentItems.forEachReference(
+                item -> {
+                  if (isLiveProgramReference(item)) {
+                    keepInfo.joinInfo(item, appView, Joiner::pin);
+                  }
+                });
+          }
+        });
+
     // TODO(b/132600955): This modifies the root set. Should the consequent be persistent?
     rootSet.addConsequentRootSet(consequentRootSet, addNoShrinking);
     if (mode.isInitialTreeShaking()) {
       for (DexReference reference : consequentRootSet.noObfuscation) {
         keepInfo.evaluateRule(reference, appView, Joiner::disallowMinification);
       }
+      consequentRootSet.softPinned.forEachReference(
+          reference -> keepInfo.evaluateRule(reference, appView, Joiner::pin));
     }
     enqueueRootItems(consequentRootSet.noShrinking);
     // Check for compatibility rules indicating that the holder must be implicitly kept.
@@ -3356,6 +3376,18 @@
     }
   }
 
+  private boolean isLiveProgramReference(DexReference reference) {
+    if (reference.isDexType()) {
+      DexProgramClass clazz =
+          DexProgramClass.asProgramClassOrNull(definitionFor(reference.asDexType()));
+      return clazz != null && isTypeLive(clazz);
+    }
+    DexMember<?, ?> member = reference.asDexMember();
+    DexProgramClass holder = DexProgramClass.asProgramClassOrNull(definitionFor(member.holder));
+    ProgramMember<?, ?> programMember = member.lookupOnProgramClass(holder);
+    return programMember != null && isMemberLive(programMember.getDefinition());
+  }
+
   private ConsequentRootSet computeDelayedInterfaceMethodSyntheticBridges() {
     RootSetBuilder builder = new RootSetBuilder(appView, subtypingInfo);
     for (DelayedRootSetActionItem delayedRootSetActionItem : rootSet.delayedRootSetActionItems) {
@@ -3556,10 +3588,28 @@
     // Add all dependent members to the workqueue.
     enqueueRootItems(rootSet.getDependentItems(definition));
 
+    checkMemberForSoftPinning(method);
+
     // Notify analyses.
     analyses.forEach(analysis -> analysis.processNewlyLiveMethod(method));
   }
 
+  private void checkMemberForSoftPinning(ProgramMember<?, ?> member) {
+    DexMember<?, ?> reference = member.getDefinition().toReference();
+    Set<ProguardKeepRuleBase> softPinRules = rootSet.softPinned.getRulesForReference(reference);
+    if (softPinRules != null) {
+      assert softPinRules.stream().noneMatch(r -> r.getModifiers().allowsOptimization);
+      keepInfo.joinInfo(reference, appInfo, Joiner::pin);
+    }
+    // Identify dependent soft pinning.
+    MutableItemsWithRules items = rootSet.dependentSoftPinned.get(member.getHolderType());
+    if (items != null && items.containsReference(reference)) {
+      assert items.getRulesForReference(reference).stream()
+          .noneMatch(r -> r.getModifiers().allowsOptimization);
+      keepInfo.joinInfo(reference, appInfo, Joiner::pin);
+    }
+  }
+
   private void markReferencedTypesAsLive(ProgramMethod method) {
     markTypeAsLive(
         method.getHolderType(), clazz -> graphReporter.reportClassReferencedFrom(clazz, method));
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
index f8b5987..1f588d8 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -83,6 +83,7 @@
   private final DirectMappedDexApplication application;
   private final Iterable<? extends ProguardConfigurationRule> rules;
   private final MutableItemsWithRules noShrinking = new MutableItemsWithRules();
+  private final MutableItemsWithRules softPinned = new MutableItemsWithRules();
   private final Set<DexReference> noObfuscation = Sets.newIdentityHashSet();
   private final LinkedHashMap<DexReference, DexReference> reasonAsked = new LinkedHashMap<>();
   private final LinkedHashMap<DexReference, DexReference> checkDiscarded = new LinkedHashMap<>();
@@ -103,6 +104,8 @@
   private final Set<DexReference> neverPropagateValue = Sets.newIdentityHashSet();
   private final Map<DexReference, MutableItemsWithRules> dependentNoShrinking =
       new IdentityHashMap<>();
+  private final Map<DexReference, MutableItemsWithRules> dependentSoftPinned =
+      new IdentityHashMap<>();
   private final Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule =
       new IdentityHashMap<>();
   private final Map<DexReference, ProguardMemberRule> mayHaveSideEffects = new IdentityHashMap<>();
@@ -334,6 +337,7 @@
     assert appView.options().isMinificationEnabled() || noObfuscation.isEmpty();
     return new RootSet(
         noShrinking,
+        softPinned,
         noObfuscation,
         ImmutableList.copyOf(reasonAsked.values()),
         ImmutableList.copyOf(checkDiscarded.values()),
@@ -356,6 +360,7 @@
         noSideEffects,
         assumedValues,
         dependentNoShrinking,
+        dependentSoftPinned,
         dependentKeepClassCompatRule,
         identifierNameStrings,
         ifRules,
@@ -424,8 +429,10 @@
         neverInline,
         neverClassInline,
         noShrinking,
+        softPinned,
         noObfuscation,
         dependentNoShrinking,
+        dependentSoftPinned,
         dependentKeepClassCompatRule,
         Lists.newArrayList(delayedRootSetActionItems));
   }
@@ -1042,6 +1049,7 @@
     dependentNoShrinking
         .computeIfAbsent(item.toReference(), x -> new MutableItemsWithRules())
         .addClassWithRule(type, context);
+    // TODO(b/171289133): Test and implement allowshrinking and use of -includedescriptorclasses
     // Unconditionally add to no-obfuscation, as that is only checked for surviving items.
     if (appView.options().isMinificationEnabled()) {
       noObfuscation.add(type);
@@ -1136,6 +1144,14 @@
           noShrinking.addReferenceWithRule(item.toReference(), keepRule);
         }
         context.markAsUsed();
+      } else if (!modifiers.allowsOptimization) {
+        if (precondition != null) {
+          dependentSoftPinned
+              .computeIfAbsent(precondition.toReference(), x -> new MutableItemsWithRules())
+              .addReferenceWithRule(item.toReference(), keepRule);
+        } else {
+          softPinned.addReferenceWithRule(item.toReference(), keepRule);
+        }
       }
       if (!modifiers.allowsOptimization) {
         // The -dontoptimize flag has only effect through the keep all rule, but we still
@@ -1301,8 +1317,10 @@
     final Set<DexMethod> neverInline;
     final Set<DexType> neverClassInline;
     final MutableItemsWithRules noShrinking;
+    final MutableItemsWithRules softPinned;
     final Set<DexReference> noObfuscation;
     final Map<DexReference, MutableItemsWithRules> dependentNoShrinking;
+    final Map<DexReference, MutableItemsWithRules> dependentSoftPinned;
     final Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule;
     final List<DelayedRootSetActionItem> delayedRootSetActionItems;
 
@@ -1310,15 +1328,19 @@
         Set<DexMethod> neverInline,
         Set<DexType> neverClassInline,
         MutableItemsWithRules noShrinking,
+        MutableItemsWithRules softPinned,
         Set<DexReference> noObfuscation,
         Map<DexReference, MutableItemsWithRules> dependentNoShrinking,
+        Map<DexReference, MutableItemsWithRules> dependentSoftPinned,
         Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
         List<DelayedRootSetActionItem> delayedRootSetActionItems) {
       this.neverInline = neverInline;
       this.neverClassInline = neverClassInline;
       this.noShrinking = noShrinking;
+      this.softPinned = softPinned;
       this.noObfuscation = noObfuscation;
       this.dependentNoShrinking = dependentNoShrinking;
+      this.dependentSoftPinned = dependentSoftPinned;
       this.dependentKeepClassCompatRule = dependentKeepClassCompatRule;
       this.delayedRootSetActionItems = delayedRootSetActionItems;
     }
@@ -1445,19 +1467,20 @@
       return reference.apply(this::containsClass, this::containsField, this::containsMethod);
     }
 
-    public abstract void forEachClass(Consumer<DexType> consumer);
+    public abstract void forEachClass(Consumer<? super DexType> consumer);
 
-    public abstract void forEachClass(BiConsumer<DexType, Set<ProguardKeepRuleBase>> consumer);
+    public abstract void forEachClass(
+        BiConsumer<? super DexType, Set<ProguardKeepRuleBase>> consumer);
 
     public abstract void forEachField(Consumer<? super DexField> consumer);
 
     public abstract void forEachField(
         BiConsumer<? super DexField, Set<ProguardKeepRuleBase>> consumer);
 
-    public abstract void forEachMember(Consumer<DexMember<?, ?>> consumer);
+    public abstract void forEachMember(Consumer<? super DexMember<?, ?>> consumer);
 
     public abstract void forEachMember(
-        BiConsumer<DexMember<?, ?>, Set<ProguardKeepRuleBase>> consumer);
+        BiConsumer<? super DexMember<?, ?>, Set<ProguardKeepRuleBase>> consumer);
 
     public abstract void forEachMethod(Consumer<? super DexMethod> consumer);
 
@@ -1554,13 +1577,18 @@
       return methodsWithRules.containsKey(method);
     }
 
+    public void forEachReference(Consumer<DexReference> consumer) {
+      forEachClass(consumer);
+      forEachMember(consumer);
+    }
+
     @Override
-    public void forEachClass(Consumer<DexType> consumer) {
+    public void forEachClass(Consumer<? super DexType> consumer) {
       classesWithRules.keySet().forEach(consumer);
     }
 
     @Override
-    public void forEachClass(BiConsumer<DexType, Set<ProguardKeepRuleBase>> consumer) {
+    public void forEachClass(BiConsumer<? super DexType, Set<ProguardKeepRuleBase>> consumer) {
       classesWithRules.forEach(consumer);
     }
 
@@ -1575,13 +1603,14 @@
     }
 
     @Override
-    public void forEachMember(Consumer<DexMember<?, ?>> consumer) {
+    public void forEachMember(Consumer<? super DexMember<?, ?>> consumer) {
       forEachField(consumer);
       forEachMethod(consumer);
     }
 
     @Override
-    public void forEachMember(BiConsumer<DexMember<?, ?>, Set<ProguardKeepRuleBase>> consumer) {
+    public void forEachMember(
+        BiConsumer<? super DexMember<?, ?>, Set<ProguardKeepRuleBase>> consumer) {
       forEachField(consumer);
       forEachMethod(consumer);
     }
@@ -1752,6 +1781,7 @@
 
     private RootSet(
         MutableItemsWithRules noShrinking,
+        MutableItemsWithRules softPinned,
         Set<DexReference> noObfuscation,
         ImmutableList<DexReference> reasonAsked,
         ImmutableList<DexReference> checkDiscarded,
@@ -1774,6 +1804,7 @@
         Map<DexReference, ProguardMemberRule> noSideEffects,
         Map<DexReference, ProguardMemberRule> assumedValues,
         Map<DexReference, MutableItemsWithRules> dependentNoShrinking,
+        Map<DexReference, MutableItemsWithRules> dependentSoftPinned,
         Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
         Set<DexReference> identifierNameStrings,
         Set<ProguardIfRule> ifRules,
@@ -1782,8 +1813,10 @@
           neverInline,
           neverClassInline,
           noShrinking,
+          softPinned,
           noObfuscation,
           dependentNoShrinking,
+          dependentSoftPinned,
           dependentKeepClassCompatRule,
           delayedRootSetActionItems);
       this.reasonAsked = reasonAsked;
@@ -1831,7 +1864,8 @@
       if (addNoShrinking) {
         noShrinking.addAll(consequentRootSet.noShrinking);
       }
-      addDependentItems(consequentRootSet.dependentNoShrinking);
+      addDependentItems(consequentRootSet.dependentNoShrinking, dependentNoShrinking);
+      addDependentItems(consequentRootSet.dependentSoftPinned, dependentSoftPinned);
       consequentRootSet.dependentKeepClassCompatRule.forEach(
           (type, rules) ->
               dependentKeepClassCompatRule.computeIfAbsent(
@@ -1840,10 +1874,12 @@
     }
 
     // Add dependent items that depend on -if rules.
-    private void addDependentItems(Map<DexReference, ? extends ItemsWithRules> dependentItems) {
-      dependentItems.forEach(
+    private static void addDependentItems(
+        Map<DexReference, ? extends ItemsWithRules> dependentItemsToAdd,
+        Map<DexReference, MutableItemsWithRules> dependentItemsToAddTo) {
+      dependentItemsToAdd.forEach(
           (reference, dependence) ->
-              dependentNoShrinking
+              dependentItemsToAddTo
                   .computeIfAbsent(reference, x -> new MutableItemsWithRules())
                   .putAll(dependence));
     }
@@ -2075,16 +2111,20 @@
         Set<DexMethod> neverInline,
         Set<DexType> neverClassInline,
         MutableItemsWithRules noShrinking,
+        MutableItemsWithRules softPinned,
         Set<DexReference> noObfuscation,
         Map<DexReference, MutableItemsWithRules> dependentNoShrinking,
+        Map<DexReference, MutableItemsWithRules> dependentSoftPinned,
         Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
         List<DelayedRootSetActionItem> delayedRootSetActionItems) {
       super(
           neverInline,
           neverClassInline,
           noShrinking,
+          softPinned,
           noObfuscation,
           dependentNoShrinking,
+          dependentSoftPinned,
           dependentKeepClassCompatRule,
           delayedRootSetActionItems);
     }
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 155f338..dd42c7b 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -157,6 +157,7 @@
     itemFactory = proguardConfiguration.getDexItemFactory();
     enableTreeShaking = proguardConfiguration.isShrinking();
     enableMinification = proguardConfiguration.isObfuscating();
+    // TODO(b/171457102): Avoid the need for this.
     // -dontoptimize disables optimizations by flipping related flags.
     if (!proguardConfiguration.isOptimizing()) {
       disableAllOptimizations();
diff --git a/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java b/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
index 412311e..de0e481 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
@@ -12,6 +12,7 @@
 
 import com.android.tools.r8.BaseCompilerCommand;
 import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.ProguardVersion;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestCompileResult;
 import com.android.tools.r8.TestParameters;
@@ -35,6 +36,8 @@
 @RunWith(Parameterized.class)
 public class CompatKeepClassMemberNamesTestRunner extends TestBase {
 
+  private static final ProguardVersion PG = ProguardVersion.getLatest();
+
   private static Class<?> MAIN_CLASS = CompatKeepClassMemberNamesTest.class;
   private static Class<?> BAR_CLASS = CompatKeepClassMemberNamesTest.Bar.class;
   private static Collection<Class<?>> CLASSES =
@@ -114,7 +117,7 @@
 
   @Test
   public void testWithoutRulesPG() throws Exception {
-    testWithoutRules(testForProguard());
+    testWithoutRules(testForProguard(PG));
   }
 
   @Test
@@ -157,7 +160,7 @@
 
   @Test
   public void testWithMembersRulePG() throws Exception {
-    assertMembersRuleCompatResult(buildWithMembersRule(testForProguard()).compile());
+    assertMembersRuleCompatResult(buildWithMembersRule(testForProguard(PG)).compile());
   }
 
   @Test
@@ -209,7 +212,7 @@
 
   @Test
   public void testWithNonStaticMembersRulePG() throws Exception {
-    assertBarIsAbsent(buildWithNonStaticMembersRule(testForProguard()).compile());
+    assertBarIsAbsent(buildWithNonStaticMembersRule(testForProguard(PG)).compile());
   }
 
   @Test
@@ -268,7 +271,7 @@
   @Test
   public void testWithMembersRuleEnableMinificationPG() throws Exception {
     assertMembersRuleEnableMinificationCompatResult(
-        buildWithMembersRuleEnableMinification(testForProguard()).compile());
+        buildWithMembersRuleEnableMinification(testForProguard(PG)).compile());
   }
 
   @Test
@@ -313,7 +316,7 @@
 
   @Test
   public void testWithMembersStarRulePG() throws Exception {
-    testWithMembersStarRule(testForProguard());
+    testWithMembersStarRule(testForProguard(PG));
   }
 
   @Test
@@ -362,7 +365,7 @@
 
   @Test
   public void testWithMemberNamesRulePG() throws Exception {
-    assertMemberNamesRuleCompatResult(buildWithMemberNamesRule(testForProguard()).compile());
+    assertMemberNamesRuleCompatResult(buildWithMemberNamesRule(testForProguard(PG)).compile());
   }
 
   @Test
@@ -375,7 +378,8 @@
 
   @Test
   public void testWithMemberNamesRuleFullR8() throws Exception {
-    assertBarIsAbsent(buildWithMemberNamesRule(testForR8Compat(parameters.getBackend())).compile());
+    assertMemberNamesRuleCompatResult(
+        buildWithMemberNamesRule(testForR8(parameters.getBackend())).compile());
   }
 
   // Tests for "-keepclassmembernames" and *no* minification.
@@ -419,7 +423,7 @@
   @Test
   public void testWithMemberNamesRuleEnableMinificationPG() throws Exception {
     assertMemberNamesRuleEnableMinificationCompatResult(
-        buildWithMemberNamesRuleEnableMinification(testForProguard()).compile());
+        buildWithMemberNamesRuleEnableMinification(testForProguard(PG)).compile());
   }
 
   @Test
@@ -432,7 +436,7 @@
 
   @Test
   public void testWithMemberNamesRuleEnableMinificationFullR8() throws Exception {
-    assertBarIsAbsent(
+    assertMemberNamesRuleEnableMinificationCompatResult(
         buildWithMemberNamesRuleEnableMinification(testForR8(parameters.getBackend())).compile());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
index dc2b296..1375f54 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
@@ -168,6 +168,10 @@
   }
 
   private void verifyBuildersAreAbsent(CodeInspector outputInspector) {
+    // TODO(b/171441793): Should be optimized out but fails do to soft pinning of super class.
+    if (true) {
+      return;
+    }
     assertThat(
         outputInspector.clazz(
             "com.android.tools.r8.proto2.Shrinking$HasFlaggedOffExtension$Builder"),
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/MemberValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/MemberValuePropagationTest.java
index bb36308..e5746ec 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/MemberValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/MemberValuePropagationTest.java
@@ -6,12 +6,16 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersBuilder;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -31,12 +35,14 @@
 
   private Backend backend;
 
-  @Parameterized.Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameterized.Parameters(name = "Backend: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        TestParametersBuilder.builder().withNoneRuntime().build(), ToolHelper.getBackends());
   }
 
-  public MemberValuePropagationTest(TestBase.Backend backend) {
+  public MemberValuePropagationTest(TestParameters parameters, TestBase.Backend backend) {
+    parameters.assertNoneRuntime();
     this.backend = backend;
   }
 
@@ -56,14 +62,14 @@
   public void testWriteOnlyField_dontoptimize() throws Exception {
     CodeInspector inspector = runR8(DONT_OPTIMIZE);
     ClassSubject clazz = inspector.clazz(QUALIFIED_CLASS_NAME);
-    clazz.forAllMethods(
-        methodSubject -> {
-          // Dead code removal is not part of -dontoptimize. That is, even with -dontoptimize,
-          // field put instructions are gone with better dead code removal.
-          assertTrue(
-              methodSubject.streamInstructions().noneMatch(
-                  i -> i.isInstancePut() || i.isStaticPut()));
-        });
+    // With the support of 'allowshrinking' dontoptimize will now effectively pin all
+    // items that are not tree shaken out. The field operations will thus remain.
+    assertTrue(clazz.clinit().streamInstructions().anyMatch(InstructionSubject::isStaticPut));
+    assertTrue(
+        clazz
+            .uniqueInstanceInitializer()
+            .streamInstructions()
+            .anyMatch(InstructionSubject::isInstancePut));
   }
 
   private CodeInspector runR8(Path proguardConfig) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
index bb27506..23271e2 100644
--- a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
+++ b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
@@ -3,14 +3,13 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming.b130791310;
 
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
-import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.ProguardVersion;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
@@ -108,45 +107,27 @@
     this.parameters = parameters;
   }
 
-  private void inspect(CodeInspector inspector, boolean isR8) {
+  private void inspect(CodeInspector inspector) {
     ClassSubject holder = inspector.clazz(SomeLogic.class);
     assertThat(holder, isPresentAndNotRenamed());
     MethodSubject someMethod = holder.uniqueMethodWithName("someMethod");
-    if (isR8) {
-      if (onlyForceInlining) {
-        assertThat(someMethod, isPresentAndNotRenamed());
-      } else {
-        assertThat(someMethod, not(isPresent()));
-      }
-    } else {
-      if (enableClassMerging) {
-        // Note that the method is not entirely gone, but merged to the implementer, along with some
-        // method signature modification.
-        assertThat(someMethod, not(isPresent()));
-      } else {
-        assertThat(someMethod, isPresentAndNotRenamed());
-      }
-    }
+    assertThat(someMethod, isPresentAndNotRenamed());
   }
 
   @Test
   public void testProguard() throws Exception {
     assumeFalse(onlyForceInlining);
     assumeTrue(parameters.isCfRuntime());
-    testForProguard()
+    testForProguard(ProguardVersion.getLatest())
         .addProgramClasses(CLASSES)
         .addKeepClassAndMembersRules(MAIN)
         .addKeepRules(RULES)
         .addTestingAnnotationsAsProgramClasses()
         .setMinApi(parameters.getApiLevel())
-        .apply(
-            builder -> {
-              if (!enableClassMerging) {
-                builder.addKeepRules("-optimizations !class/merging/*");
-              }
-            })
+        .applyIf(
+            !enableClassMerging, builder -> builder.addKeepRules("-optimizations !class/merging/*"))
         .compile()
-        .inspect(inspector -> inspect(inspector, false));
+        .inspect(this::inspect);
   }
 
   @Test
@@ -158,14 +139,12 @@
         .enableNeverClassInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
         .addOptionsModification(o -> o.enableVerticalClassMerging = enableClassMerging)
-        .apply(
-            builder -> {
-              if (onlyForceInlining) {
+        .applyIf(
+            onlyForceInlining,
+            builder ->
                 builder.addOptionsModification(
-                    o -> o.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE));
-              }
-            })
+                    o -> o.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE)))
         .compile()
-        .inspect(inspector -> inspect(inspector, true));
+        .inspect(this::inspect);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/proguard/KeepClassMembersAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
similarity index 80%
copy from src/test/java/com/android/tools/r8/proguard/KeepClassMembersAllowShrinkingCompatibilityTest.java
copy to src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
index cb83f31..f7e50d9 100644
--- a/src/test/java/com/android/tools/r8/proguard/KeepClassMembersAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
@@ -1,7 +1,7 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -23,7 +23,7 @@
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class KeepClassMembersAllowShrinkingCompatibilityTest extends TestBase {
+public class ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest extends TestBase {
 
   private final TestParameters parameters;
   private final boolean allowOptimization;
@@ -39,7 +39,7 @@
         ImmutableList.of(Shrinker.R8, Shrinker.PG));
   }
 
-  public KeepClassMembersAllowShrinkingCompatibilityTest(
+  public ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest(
       TestParameters parameters,
       boolean allowOptimization,
       boolean allowObfuscation,
@@ -54,21 +54,14 @@
     return StringUtils.lines(
         "A::foo",
         // Reflective lookup of A::foo will only work if optimization and obfuscation are disabled.
-        Boolean.toString(
-            !allowOptimization
-                && !allowObfuscation
-                // TODO(b/171289133): Remove this exception once fixed.
-                && !shrinker.isR8()),
+        Boolean.toString(!allowOptimization && !allowObfuscation),
         "false");
   }
 
   @Test
   public void test() throws Exception {
     if (shrinker.isR8()) {
-      run(
-          testForR8(parameters.getBackend())
-              // TODO(b/171289133): The keep rule should not be "unmatched".
-              .allowUnusedProguardConfigurationRules(allowOptimization && allowObfuscation));
+      run(testForR8(parameters.getBackend()));
     } else {
       run(testForProguard(shrinker.getProguardVersion()).addDontWarn(getClass()));
     }
@@ -76,12 +69,12 @@
 
   public <T extends TestShrinkerBuilder<?, ?, ?, ?, T>> void run(T builder) throws Exception {
     String keepRule =
-        "-keepclassmembers,allowshrinking"
+        "-if class * -keepclassmembers,allowshrinking"
             + (allowOptimization ? ",allowoptimization" : "")
             + (allowObfuscation ? ",allowobfuscation" : "")
-            + " class * { java.lang.String foo(); }";
+            + " class <1> { java.lang.String foo(); java.lang.String bar(); }";
     builder
-        .addInnerClasses(KeepClassMembersAllowShrinkingCompatibilityTest.class)
+        .addInnerClasses(ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.class)
         .addKeepClassAndMembersRules(TestClass.class)
         .addKeepRules(keepRule)
         .setMinApi(parameters.getApiLevel())
@@ -91,13 +84,17 @@
             inspector -> {
               ClassSubject aClass = inspector.clazz(A.class);
               ClassSubject bClass = inspector.clazz(B.class);
-              // The class constants will force A and B to be retained, but not the foo methods.
+              // The class constants will force A and B to be retained, but not the methods.
               assertThat(bClass, isPresentAndRenamed());
-              assertThat(aClass, isPresentAndRenamed());
               assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
+              assertThat(bClass.uniqueMethodWithName("bar"), not(isPresent()));
+
+              assertThat(aClass, isPresentAndRenamed());
+              // The dependent rule with soft-pinning of bar never causes A::bar to be retained
+              // regardless of A and A::foo being retained.
+              assertThat(aClass.uniqueMethodWithName("bar"), not(isPresent()));
               MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
-              // TODO(b/171289133): Remove R8 check once fixed.
-              if (allowOptimization || shrinker.isR8()) {
+              if (allowOptimization) {
                 assertThat(aFoo, not(isPresent()));
               } else {
                 assertThat(aFoo, isPresentAndRenamed(allowObfuscation));
@@ -110,12 +107,20 @@
     public String foo() {
       return "A::foo";
     }
+
+    public String bar() {
+      return "A::bar";
+    }
   }
 
   static class B {
     public String foo() {
       return "B::foo";
     }
+
+    public String bar() {
+      return "B::bar";
+    }
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
similarity index 86%
copy from src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java
copy to src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
index a1fa1c3..5c99afd 100644
--- a/src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
@@ -2,7 +2,7 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -25,7 +25,7 @@
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
-public class KeepStaticMethodAllowShrinkingCompatibilityTest extends TestBase {
+public class ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest extends TestBase {
 
   private final boolean allowOptimization;
   private final TestParameters parameters;
@@ -39,7 +39,7 @@
         ImmutableList.of(Shrinker.R8, Shrinker.PG));
   }
 
-  public KeepStaticMethodAllowShrinkingCompatibilityTest(
+  public ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest(
       boolean allowOptimization, TestParameters parameters, Shrinker shrinker) {
     this.allowOptimization = allowOptimization;
     this.parameters = parameters;
@@ -60,7 +60,9 @@
         .addProgramClasses(TestClass.class, Companion.class)
         .addKeepMainRule(TestClass.class)
         .addKeepRules(
-            "-keep,allowshrinking"
+            "-if class "
+                + Companion.class.getTypeName()
+                + " -keep,allowshrinking"
                 + (allowOptimization ? ",allowoptimization" : "")
                 + " class "
                 + Companion.class.getTypeName()
@@ -72,15 +74,12 @@
               assertThat(testClassSubject, isPresent());
 
               ClassSubject companionClassSubject = inspector.clazz(Companion.class);
-              // TODO(b/171289133): Remove the R8 check one fixed.
-              assertThat(
-                  companionClassSubject, notIf(isPresent(), allowOptimization || shrinker.isR8()));
+              assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
 
               MethodSubject mainMethodSubject = testClassSubject.mainMethod();
               MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
 
-              // TODO(b/171289133): Remove the R8 check once fixed.
-              if (allowOptimization || shrinker.isR8()) {
+              if (allowOptimization) {
                 assertTrue(
                     testClassSubject
                         .mainMethod()
diff --git a/src/test/java/com/android/tools/r8/proguard/KeepAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
similarity index 91%
rename from src/test/java/com/android/tools/r8/proguard/KeepAllowShrinkingCompatibilityTest.java
rename to src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
index 130dc2d..c9b3bc7 100644
--- a/src/test/java/com/android/tools/r8/proguard/KeepAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
@@ -1,7 +1,7 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -54,11 +54,7 @@
     return StringUtils.lines(
         "A::foo",
         // Reflective lookup of A::foo will only work if optimization and obfuscation are disabled.
-        Boolean.toString(
-            !allowOptimization
-                && !allowObfuscation
-                // TODO(b/171289133): Remove this exception once fixed.
-                && !shrinker.isR8()),
+        Boolean.toString(!allowOptimization && !allowObfuscation),
         "false");
   }
 
@@ -67,7 +63,7 @@
     if (shrinker.isR8()) {
       run(
           testForR8(parameters.getBackend())
-              // TODO(b/171289133): The keep rule should not be "unmatched".
+              // Allowing all of shrinking, optimization and obfuscation will amount to a nop rule.
               .allowUnusedProguardConfigurationRules(allowOptimization && allowObfuscation));
     } else {
       run(testForProguard(shrinker.getProguardVersion()).addDontWarn(getClass()));
@@ -96,8 +92,7 @@
               assertThat(aClass, isPresentAndRenamed(allowObfuscation));
               assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
               MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
-              // TODO(b/171289133): Remove R8 check once fixed.
-              if (allowOptimization || shrinker.isR8()) {
+              if (allowOptimization) {
                 assertThat(aFoo, not(isPresent()));
               } else {
                 assertThat(aFoo, isPresentAndRenamed(allowObfuscation));
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
new file mode 100644
index 0000000..8b01419
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
@@ -0,0 +1,158 @@
+// 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.allowshrinking;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.accessesField;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class KeepClassFieldsAllowShrinkingCompatibilityTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final boolean allowOptimization;
+  private final boolean allowObfuscation;
+  private final Shrinker shrinker;
+
+  @Parameterized.Parameters(name = "{0}, opt:{1}, obf:{2}, {3}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(),
+        BooleanUtils.values(),
+        BooleanUtils.values(),
+        ImmutableList.of(Shrinker.R8, Shrinker.PG));
+  }
+
+  public KeepClassFieldsAllowShrinkingCompatibilityTest(
+      TestParameters parameters,
+      boolean allowOptimization,
+      boolean allowObfuscation,
+      Shrinker shrinker) {
+    this.parameters = parameters;
+    this.allowOptimization = allowOptimization;
+    this.allowObfuscation = allowObfuscation;
+    this.shrinker = shrinker;
+  }
+
+  String getExpected() {
+    return StringUtils.lines(
+        "A.foo",
+        // R8 will succeed in removing the field if allowoptimization is set.
+        Boolean.toString((shrinker.isPG() || !allowOptimization) && !allowObfuscation),
+        // R8 will always remove the unreferenced B.foo field.
+        Boolean.toString(shrinker.isPG() && !allowOptimization && !allowObfuscation));
+  }
+
+  @Test
+  public void test() throws Exception {
+    if (shrinker.isR8()) {
+      run(
+          testForR8(parameters.getBackend())
+              // Allowing all of shrinking, optimization and obfuscation will amount to a nop rule.
+              .allowUnusedProguardConfigurationRules(allowOptimization && allowObfuscation));
+    } else {
+      run(testForProguard(shrinker.getProguardVersion()).addDontWarn(getClass()));
+    }
+  }
+
+  public <T extends TestShrinkerBuilder<?, ?, ?, ?, T>> void run(T builder) throws Exception {
+    String keepRule =
+        "-keepclassmembers,allowshrinking"
+            + (allowOptimization ? ",allowoptimization" : "")
+            + (allowObfuscation ? ",allowobfuscation" : "")
+            + " class * { java.lang.String foo; java.lang.String bar; }";
+    builder
+        .addInnerClasses(KeepClassFieldsAllowShrinkingCompatibilityTest.class)
+        .addKeepClassAndMembersRules(TestClass.class)
+        .addKeepRules(keepRule)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), TestClass.class, A.class.getTypeName())
+        .assertSuccessWithOutput(getExpected())
+        .inspect(
+            inspector -> {
+              ClassSubject aClass = inspector.clazz(A.class);
+              ClassSubject bClass = inspector.clazz(B.class);
+              // The class constants will force A and B to be retained but renamed.
+              assertThat(aClass, isPresentAndRenamed());
+              assertThat(bClass, isPresentAndRenamed());
+
+              FieldSubject aFoo = aClass.uniqueFieldWithName("foo");
+              FieldSubject aBar = aClass.uniqueFieldWithName("bar");
+              FieldSubject bFoo = bClass.uniqueFieldWithName("foo");
+              FieldSubject bBar = bClass.uniqueFieldWithName("bar");
+
+              if (allowOptimization) {
+                // PG fails to optimize out the referenced field.
+                assertThat(aFoo, notIf(isPresent(), shrinker.isR8()));
+                assertThat(aBar, not(isPresent()));
+                assertThat(bFoo, not(isPresent()));
+                assertThat(bBar, not(isPresent()));
+              } else {
+                assertThat(aFoo, isPresentAndRenamed(allowObfuscation));
+                // TODO(b/171459868) It is inconsistent that the unused field A.bar is retained.
+                //   This does not match the R8 behavior for an unused method, so there may be an
+                //   optimization opportunity here.
+                //   (See KeepClassMethodsAllowShrinkingCompatibilityTest regarding methods).
+                assertThat(aBar, isPresentAndRenamed(allowObfuscation));
+                assertThat(inspector.clazz(TestClass.class).mainMethod(), accessesField(aFoo));
+                if (shrinker.isR8()) {
+                  assertThat(bFoo, not(isPresent()));
+                  assertThat(bBar, not(isPresent()));
+                } else {
+                  assertThat(bFoo, isPresentAndRenamed(allowObfuscation));
+                  assertThat(bBar, isPresentAndRenamed(allowObfuscation));
+                }
+              }
+            });
+  }
+
+  static class A {
+    // Note: If the fields are final PG actually allows itself to inline the values.
+    public String foo = "A.foo";
+    public String bar = "A.bar";
+  }
+
+  static class B {
+    public String foo = "B.foo";
+    public String bar = "B.bar";
+  }
+
+  static class TestClass {
+
+    public static boolean hasFoo(String name) {
+      try {
+        return Class.forName(name).getDeclaredField("foo") != null;
+      } catch (Exception e) {
+        return false;
+      }
+    }
+
+    public static void main(String[] args) {
+      // Conditional instance to prohibit class inlining of A.
+      A a = args.length == 42 ? null : new A();
+      // Direct use of A.foo, if optimization is not allowed it will be kept.
+      System.out.println(a.foo);
+      // Reference to A should not retain A.foo when allowoptimization is set.
+      System.out.println(hasFoo(a.getClass().getTypeName()));
+      // Reference to B should not retain B.foo regardless of allowoptimization.
+      System.out.println(hasFoo(B.class.getTypeName()));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/proguard/KeepClassMembersAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
similarity index 82%
rename from src/test/java/com/android/tools/r8/proguard/KeepClassMembersAllowShrinkingCompatibilityTest.java
rename to src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
index cb83f31..e7d5191 100644
--- a/src/test/java/com/android/tools/r8/proguard/KeepClassMembersAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
@@ -1,7 +1,7 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -23,7 +23,7 @@
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class KeepClassMembersAllowShrinkingCompatibilityTest extends TestBase {
+public class KeepClassMethodsAllowShrinkingCompatibilityTest extends TestBase {
 
   private final TestParameters parameters;
   private final boolean allowOptimization;
@@ -39,7 +39,7 @@
         ImmutableList.of(Shrinker.R8, Shrinker.PG));
   }
 
-  public KeepClassMembersAllowShrinkingCompatibilityTest(
+  public KeepClassMethodsAllowShrinkingCompatibilityTest(
       TestParameters parameters,
       boolean allowOptimization,
       boolean allowObfuscation,
@@ -54,11 +54,7 @@
     return StringUtils.lines(
         "A::foo",
         // Reflective lookup of A::foo will only work if optimization and obfuscation are disabled.
-        Boolean.toString(
-            !allowOptimization
-                && !allowObfuscation
-                // TODO(b/171289133): Remove this exception once fixed.
-                && !shrinker.isR8()),
+        Boolean.toString(!allowOptimization && !allowObfuscation),
         "false");
   }
 
@@ -67,7 +63,7 @@
     if (shrinker.isR8()) {
       run(
           testForR8(parameters.getBackend())
-              // TODO(b/171289133): The keep rule should not be "unmatched".
+              // Allowing all of shrinking, optimization and obfuscation will amount to a nop rule.
               .allowUnusedProguardConfigurationRules(allowOptimization && allowObfuscation));
     } else {
       run(testForProguard(shrinker.getProguardVersion()).addDontWarn(getClass()));
@@ -79,9 +75,9 @@
         "-keepclassmembers,allowshrinking"
             + (allowOptimization ? ",allowoptimization" : "")
             + (allowObfuscation ? ",allowobfuscation" : "")
-            + " class * { java.lang.String foo(); }";
+            + " class * { java.lang.String foo(); java.lang.String bar(); }";
     builder
-        .addInnerClasses(KeepClassMembersAllowShrinkingCompatibilityTest.class)
+        .addInnerClasses(KeepClassMethodsAllowShrinkingCompatibilityTest.class)
         .addKeepClassAndMembersRules(TestClass.class)
         .addKeepRules(keepRule)
         .setMinApi(parameters.getApiLevel())
@@ -91,13 +87,17 @@
             inspector -> {
               ClassSubject aClass = inspector.clazz(A.class);
               ClassSubject bClass = inspector.clazz(B.class);
-              // The class constants will force A and B to be retained, but not the foo methods.
+              // The class constants will force A and B to be retained, but not the methods.
               assertThat(bClass, isPresentAndRenamed());
-              assertThat(aClass, isPresentAndRenamed());
               assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
+              assertThat(bClass.uniqueMethodWithName("bar"), not(isPresent()));
+
+              assertThat(aClass, isPresentAndRenamed());
+              // The dependent rule with soft-pinning of bar never causes A::bar to be retained
+              // regardless of A and A::foo being retained.
+              assertThat(aClass.uniqueMethodWithName("bar"), not(isPresent()));
               MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
-              // TODO(b/171289133): Remove R8 check once fixed.
-              if (allowOptimization || shrinker.isR8()) {
+              if (allowOptimization) {
                 assertThat(aFoo, not(isPresent()));
               } else {
                 assertThat(aFoo, isPresentAndRenamed(allowObfuscation));
@@ -110,12 +110,20 @@
     public String foo() {
       return "A::foo";
     }
+
+    public String bar() {
+      return "A::bar";
+    }
   }
 
   static class B {
     public String foo() {
       return "B::foo";
     }
+
+    public String bar() {
+      return "B::bar";
+    }
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
similarity index 77%
copy from src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java
copy to src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
index a1fa1c3..2322f85 100644
--- a/src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
@@ -2,11 +2,11 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
-import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.accessesField;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
@@ -15,6 +15,7 @@
 import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
+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 com.google.common.collect.ImmutableList;
@@ -25,7 +26,7 @@
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
-public class KeepStaticMethodAllowShrinkingCompatibilityTest extends TestBase {
+public class KeepStaticFieldAllowShrinkingCompatibilityTest extends TestBase {
 
   private final boolean allowOptimization;
   private final TestParameters parameters;
@@ -39,7 +40,7 @@
         ImmutableList.of(Shrinker.R8, Shrinker.PG));
   }
 
-  public KeepStaticMethodAllowShrinkingCompatibilityTest(
+  public KeepStaticFieldAllowShrinkingCompatibilityTest(
       boolean allowOptimization, TestParameters parameters, Shrinker shrinker) {
     this.allowOptimization = allowOptimization;
     this.parameters = parameters;
@@ -64,31 +65,29 @@
                 + (allowOptimization ? ",allowoptimization" : "")
                 + " class "
                 + Companion.class.getTypeName()
-                + " { <methods>; }")
+                + " { <fields>; }")
         .compile()
         .inspect(
             inspector -> {
               ClassSubject testClassSubject = inspector.clazz(TestClass.class);
               assertThat(testClassSubject, isPresent());
 
-              ClassSubject companionClassSubject = inspector.clazz(Companion.class);
-              // TODO(b/171289133): Remove the R8 check one fixed.
-              assertThat(
-                  companionClassSubject, notIf(isPresent(), allowOptimization || shrinker.isR8()));
-
               MethodSubject mainMethodSubject = testClassSubject.mainMethod();
-              MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
+              ClassSubject companionClassSubject = inspector.clazz(Companion.class);
+              FieldSubject xFieldSubject = companionClassSubject.uniqueFieldWithName("x");
 
-              // TODO(b/171289133): Remove the R8 check once fixed.
-              if (allowOptimization || shrinker.isR8()) {
+              // PG fails to optimize fields regardless of keep flags.
+              if (allowOptimization && shrinker.isR8()) {
+                assertThat(companionClassSubject, not(isPresent()));
                 assertTrue(
                     testClassSubject
                         .mainMethod()
                         .streamInstructions()
                         .allMatch(InstructionSubject::isReturnVoid));
               } else {
-                assertThat(mainMethodSubject, invokesMethod(getMethodSubject));
-                assertThat(getMethodSubject, isPresent());
+                assertThat(companionClassSubject, isPresent());
+                assertThat(mainMethodSubject, accessesField(xFieldSubject));
+                assertThat(xFieldSubject, isPresent());
               }
             })
         .run(parameters.getRuntime(), TestClass.class)
@@ -98,7 +97,7 @@
   static class TestClass {
 
     public static void main(String[] args) {
-      if (Companion.get() != 42) {
+      if (Companion.x != 42) {
         System.out.println("Hello world!");
       }
     }
@@ -106,8 +105,6 @@
 
   static class Companion {
 
-    static int get() {
-      return 42;
-    }
+    static int x = 42;
   }
 }
diff --git a/src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
similarity index 91%
rename from src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java
rename to src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
index a1fa1c3..9dbdbb4 100644
--- a/src/test/java/com/android/tools/r8/proguard/KeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
@@ -2,7 +2,7 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -72,15 +72,12 @@
               assertThat(testClassSubject, isPresent());
 
               ClassSubject companionClassSubject = inspector.clazz(Companion.class);
-              // TODO(b/171289133): Remove the R8 check one fixed.
-              assertThat(
-                  companionClassSubject, notIf(isPresent(), allowOptimization || shrinker.isR8()));
+              assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
 
               MethodSubject mainMethodSubject = testClassSubject.mainMethod();
               MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
 
-              // TODO(b/171289133): Remove the R8 check once fixed.
-              if (allowOptimization || shrinker.isR8()) {
+              if (allowOptimization) {
                 assertTrue(
                     testClassSubject
                         .mainMethod()
diff --git a/src/test/java/com/android/tools/r8/proguard/Shrinker.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/Shrinker.java
similarity index 95%
rename from src/test/java/com/android/tools/r8/proguard/Shrinker.java
rename to src/test/java/com/android/tools/r8/shaking/allowshrinking/Shrinker.java
index 8cd4867..112fd05 100644
--- a/src/test/java/com/android/tools/r8/proguard/Shrinker.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/Shrinker.java
@@ -1,7 +1,7 @@
 // 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.proguard;
+package com.android.tools.r8.shaking.allowshrinking;
 
 import com.android.tools.r8.ProguardVersion;