diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisContext.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisContext.java
index 8c05bf0..5f63f4c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisContext.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisContext.java
@@ -5,7 +5,7 @@
 package com.android.tools.r8.ir.optimize.classinliner.analysis;
 
 /**
- * The context used for the {@link AnalysisState} lattice.
+ * The context used for the {@link ParameterUsages} lattice.
  *
  * <p>By only using {@link DefaultAnalysisContext} a context-insensitive result is achieved.
  * Context-sensitive results can be achieved by forking different analysis contexts during the class
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/BottomParameterUsages.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/BottomParameterUsages.java
new file mode 100644
index 0000000..84bae0e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/BottomParameterUsages.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner.analysis;
+
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+public class BottomParameterUsages extends ParameterUsages {
+
+  private static final BottomParameterUsages INSTANCE = new BottomParameterUsages();
+
+  private BottomParameterUsages() {}
+
+  static BottomParameterUsages getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  ParameterUsages externalize() {
+    return this;
+  }
+
+  @Override
+  public ParameterUsagePerContext get(int parameter) {
+    return ParameterUsagePerContext.bottom();
+  }
+
+  @Override
+  public boolean isBottom() {
+    return true;
+  }
+
+  @Override
+  ParameterUsages put(int parameter, ParameterUsagePerContext usagePerContext) {
+    Int2ObjectOpenHashMap<ParameterUsagePerContext> backing = new Int2ObjectOpenHashMap<>();
+    backing.put(parameter, usagePerContext);
+    return NonEmptyParameterUsages.create(backing);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    return other == INSTANCE;
+  }
+
+  @Override
+  public int hashCode() {
+    return System.identityHashCode(this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java
index fee1048..677518c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java
@@ -17,20 +17,30 @@
 
   public static ClassInlinerMethodConstraint analyze(
       AppView<AppInfoWithLiveness> appView, ProgramMethod method, IRCode code) {
-    if (method.getDefinition().isClassInitializer()) {
+    if (method.getDefinition().isClassInitializer()
+        || method.getDefinition().getNumberOfArguments() == 0) {
       return ClassInlinerMethodConstraint.alwaysFalse();
     }
 
     // Analyze code.
-    IntraproceduralDataflowAnalysis<AnalysisState> analysis =
+    IntraproceduralDataflowAnalysis<ParameterUsages> analysis =
         new IntraproceduralDataflowAnalysis<>(
-            AnalysisState.bottom(), new TransferFunction(appView, method));
-    SuccessfulDataflowAnalysisResult<AnalysisState> result =
+            ParameterUsages.bottom(), new TransferFunction(appView, method));
+    SuccessfulDataflowAnalysisResult<ParameterUsages> result =
         analysis.run(code.entryBlock()).asSuccessfulAnalysisResult();
     if (result == null) {
       return ClassInlinerMethodConstraint.alwaysFalse();
     }
 
-    return new ConditionalClassInlinerMethodConstraint(result.join().externalize());
+    // TODO(b/181746071): This always returns a non-empty result, that should be transformed into
+    //  bottom or top.
+    ParameterUsages usages = result.join();
+    if (usages.isBottom()) {
+      return ClassInlinerMethodConstraint.alwaysTrue();
+    }
+    if (usages.isTop()) {
+      return ClassInlinerMethodConstraint.alwaysFalse();
+    }
+    return new ConditionalClassInlinerMethodConstraint(usages.externalize());
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisState.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/NonEmptyParameterUsages.java
similarity index 80%
rename from src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisState.java
rename to src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/NonEmptyParameterUsages.java
index a09ada2..2fb4a19 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/AnalysisState.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/NonEmptyParameterUsages.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.ir.optimize.classinliner.analysis;
 
-import com.android.tools.r8.ir.analysis.framework.intraprocedural.AbstractState;
 import com.android.tools.r8.ir.code.AssumeAndCheckCastAliasedValueConfiguration;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.utils.ArrayUtils;
@@ -12,7 +11,6 @@
 import com.android.tools.r8.utils.IntObjConsumer;
 import com.android.tools.r8.utils.IntObjToObjFunction;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
-import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -63,43 +61,34 @@
  * <p>Finally, to provide the information for each method parameter, this class provides a mapping
  * from parameters to {@link ParameterUsagePerContext}.
  */
-public class AnalysisState extends AbstractState<AnalysisState> {
+public class NonEmptyParameterUsages extends ParameterUsages {
 
-  private static final AnalysisState BOTTOM = new AnalysisState();
   private static final AssumeAndCheckCastAliasedValueConfiguration aliasedValueConfiguration =
       AssumeAndCheckCastAliasedValueConfiguration.getInstance();
 
   private final Int2ObjectMap<ParameterUsagePerContext> backing;
 
-  private AnalysisState() {
-    this.backing = Int2ObjectMaps.emptyMap();
-  }
-
-  private AnalysisState(Int2ObjectMap<ParameterUsagePerContext> backing) {
+  private NonEmptyParameterUsages(Int2ObjectMap<ParameterUsagePerContext> backing) {
     assert !backing.isEmpty() : "Should use bottom() instead";
     this.backing = backing;
   }
 
-  static AnalysisState bottom() {
-    return BOTTOM;
+  public static ParameterUsages create(Int2ObjectMap<ParameterUsagePerContext> backing) {
+    return backing.isEmpty() ? bottom() : new NonEmptyParameterUsages(backing);
   }
 
-  public static AnalysisState create(Int2ObjectMap<ParameterUsagePerContext> backing) {
-    return backing.isEmpty() ? bottom() : new AnalysisState(backing);
+  @Override
+  public NonEmptyParameterUsages asNonEmpty() {
+    return this;
   }
 
-  /**
-   * Converts instances of {@link InternalNonEmptyParameterUsage} to {@link NonEmptyParameterUsage}.
-   *
-   * <p>This is needed because {@link InternalNonEmptyParameterUsage} is not suitable for being
-   * stored in {@link com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo}, since it
-   * contains references to IR instructions.
-   */
-  AnalysisState externalize() {
+  @Override
+  NonEmptyParameterUsages externalize() {
     return rebuildParameters((parameter, usagePerContext) -> usagePerContext.externalize());
   }
 
-  AnalysisState put(int parameter, ParameterUsagePerContext parameterUsagePerContext) {
+  @Override
+  ParameterUsages put(int parameter, ParameterUsagePerContext parameterUsagePerContext) {
     Int2ObjectOpenHashMap<ParameterUsagePerContext> newBacking =
         new Int2ObjectOpenHashMap<>(backing);
     newBacking.put(parameter, parameterUsagePerContext);
@@ -110,22 +99,18 @@
     Int2ObjectMapUtils.forEach(backing, consumer);
   }
 
+  @Override
   public ParameterUsagePerContext get(int parameter) {
     assert backing.containsKey(parameter);
     ParameterUsagePerContext value = backing.get(parameter);
     return value != null ? value : ParameterUsagePerContext.bottom();
   }
 
-  public boolean isBottom() {
-    assert !backing.isEmpty() || this == bottom();
-    return backing.isEmpty();
-  }
-
-  AnalysisState abandonClassInliningInCurrentContexts(Value value) {
+  NonEmptyParameterUsages abandonClassInliningInCurrentContexts(Value value) {
     return rebuildParameter(value, (context, usage) -> ParameterUsage.top());
   }
 
-  AnalysisState abandonClassInliningInCurrentContexts(Collection<Value> values) {
+  NonEmptyParameterUsages abandonClassInliningInCurrentContexts(Collection<Value> values) {
     if (values.isEmpty()) {
       return this;
     }
@@ -141,7 +126,7 @@
                 : usagePerContext);
   }
 
-  AnalysisState abandonClassInliningInCurrentContexts(
+  NonEmptyParameterUsages abandonClassInliningInCurrentContexts(
       Iterable<Value> values, Predicate<Value> predicate) {
     List<Value> filtered = new ArrayList<>();
     for (Value value : values) {
@@ -153,7 +138,7 @@
     return abandonClassInliningInCurrentContexts(filtered);
   }
 
-  AnalysisState rebuildParameter(
+  NonEmptyParameterUsages rebuildParameter(
       Value value, BiFunction<AnalysisContext, ParameterUsage, ParameterUsage> transformation) {
     Value valueRoot = value.getAliasedValue(aliasedValueConfiguration);
     assert valueRoot.isArgument();
@@ -165,7 +150,7 @@
                 : usagePerContext);
   }
 
-  AnalysisState rebuildParameters(
+  NonEmptyParameterUsages rebuildParameters(
       IntObjToObjFunction<ParameterUsagePerContext, ParameterUsagePerContext> transformation) {
     Int2ObjectMap<ParameterUsagePerContext> rebuiltBacking = null;
     for (Int2ObjectMap.Entry<ParameterUsagePerContext> entry : backing.int2ObjectEntrySet()) {
@@ -190,16 +175,10 @@
         rebuiltBacking.put(parameter, newUsagePerContext);
       }
     }
-    return rebuiltBacking != null ? create(rebuiltBacking) : this;
+    return rebuiltBacking != null ? new NonEmptyParameterUsages(rebuiltBacking) : this;
   }
 
-  @Override
-  public AnalysisState asAbstractState() {
-    return this;
-  }
-
-  @Override
-  public AnalysisState join(AnalysisState otherAnalysisState) {
+  public NonEmptyParameterUsages join(NonEmptyParameterUsages otherAnalysisState) {
     if (isBottom()) {
       return otherAnalysisState;
     }
@@ -214,7 +193,7 @@
                 parameterUsagePerContext.join(
                     Int2ObjectMapUtils.getOrDefault(
                         newBacking, parameter, ParameterUsagePerContext.bottom()))));
-    return AnalysisState.create(newBacking);
+    return new NonEmptyParameterUsages(newBacking);
   }
 
   @Override
@@ -222,7 +201,7 @@
     if (other == null || getClass() != other.getClass()) {
       return false;
     }
-    AnalysisState analysisState = (AnalysisState) other;
+    NonEmptyParameterUsages analysisState = (NonEmptyParameterUsages) other;
     return backing.equals(analysisState.backing);
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsage.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsage.java
index 4c5c2c2..e2ad8da 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsage.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsage.java
@@ -80,7 +80,7 @@
 
   abstract ParameterUsage setParameterUsedAsLock();
 
-  static BottomParameterUsage bottom() {
+  public static BottomParameterUsage bottom() {
     return BottomParameterUsage.getInstance();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsages.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsages.java
new file mode 100644
index 0000000..6b4cffb
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ParameterUsages.java
@@ -0,0 +1,65 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner.analysis;
+
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.AbstractState;
+
+public abstract class ParameterUsages extends AbstractState<ParameterUsages> {
+
+  @Override
+  public ParameterUsages asAbstractState() {
+    return this;
+  }
+
+  public NonEmptyParameterUsages asNonEmpty() {
+    return null;
+  }
+
+  /**
+   * This converts instances inside this {@link ParameterUsages} instance that are not suitable for
+   * being stored in optimization info into instances that can be stored in the optimization info.
+   *
+   * <p>For example, converts instances of {@link InternalNonEmptyParameterUsage} to {@link
+   * NonEmptyParameterUsage}. This is needed because {@link InternalNonEmptyParameterUsage} is not
+   * suitable for being stored in {@link
+   * com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo}, since it contains references to
+   * IR instructions.
+   */
+  abstract ParameterUsages externalize();
+
+  public abstract ParameterUsagePerContext get(int parameter);
+
+  public boolean isBottom() {
+    return false;
+  }
+
+  public boolean isTop() {
+    return false;
+  }
+
+  @Override
+  public ParameterUsages join(ParameterUsages state) {
+    if (isBottom()) {
+      return state;
+    }
+    if (state.isBottom()) {
+      return this;
+    }
+    if (isTop() || state.isTop()) {
+      return top();
+    }
+    return asNonEmpty().join(state.asNonEmpty());
+  }
+
+  abstract ParameterUsages put(int parameter, ParameterUsagePerContext usagePerContext);
+
+  public static BottomParameterUsages bottom() {
+    return BottomParameterUsages.getInstance();
+  }
+
+  public static UnknownParameterUsages top() {
+    return UnknownParameterUsages.getInstance();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java
index c501bbe..740a8cd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java
@@ -22,7 +22,6 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.ir.analysis.framework.intraprocedural.AbstractTransferFunction;
-import com.android.tools.r8.ir.analysis.framework.intraprocedural.TransferFunctionResult;
 import com.android.tools.r8.ir.code.AliasedValueConfiguration;
 import com.android.tools.r8.ir.code.Argument;
 import com.android.tools.r8.ir.code.Assume;
@@ -45,7 +44,7 @@
 import com.google.common.collect.Sets;
 import java.util.Set;
 
-class TransferFunction implements AbstractTransferFunction<AnalysisState> {
+class TransferFunction implements AbstractTransferFunction<ParameterUsages> {
 
   private static final AliasedValueConfiguration aliasedValueConfiguration =
       AssumeAndCheckCastAliasedValueConfiguration.getInstance();
@@ -73,7 +72,7 @@
   }
 
   @Override
-  public TransferFunctionResult<AnalysisState> apply(Instruction instruction, AnalysisState state) {
+  public ParameterUsages apply(Instruction instruction, ParameterUsages state) {
     if (instruction.isArgument()) {
       return analyzeArgument(instruction.asArgument(), state);
     }
@@ -82,6 +81,12 @@
       // purpose of class inlining we can ignore this instruction.
       return state;
     }
+    assert !state.isBottom();
+    assert !state.isTop();
+    return apply(instruction, state.asNonEmpty());
+  }
+
+  private ParameterUsages apply(Instruction instruction, NonEmptyParameterUsages state) {
     switch (instruction.opcode()) {
       case ASSUME:
         return analyzeAssume(instruction.asAssume(), state);
@@ -111,8 +116,8 @@
   }
 
   @Override
-  public AnalysisState computeBlockEntryState(
-      BasicBlock block, BasicBlock predecessor, AnalysisState predecessorExitState) {
+  public ParameterUsages computeBlockEntryState(
+      BasicBlock block, BasicBlock predecessor, ParameterUsages predecessorExitState) {
     // TODO(b/173337498): Fork a new `FIELD=x` analysis context for the successor block if the
     //  predecessor ends with an if or switch instruction, and the successor block is the
     //  `FIELD=x` target of the predecessor. To avoid an excessive number of contexts being
@@ -121,8 +126,7 @@
     return predecessorExitState;
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeArgument(
-      Argument argument, AnalysisState state) {
+  private ParameterUsages analyzeArgument(Argument argument, ParameterUsages state) {
     // Only consider arguments that could store an instance eligible for class inlining. Note that
     // we can't ignore parameters with a library type, since instances of program classes could
     // still flow into such parameters.
@@ -138,18 +142,17 @@
     return state.put(argument.getIndex(), NonEmptyParameterUsagePerContext.createInitial());
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeAssume(Assume assume, AnalysisState state) {
+  private ParameterUsages analyzeAssume(Assume assume, NonEmptyParameterUsages state) {
     // Mark the value as ineligible for class inlining if it has phi users.
     return assume.outValue().hasPhiUsers() ? fail(assume, state) : state;
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeCheckCast(
-      CheckCast checkCast, AnalysisState state) {
+  private ParameterUsages analyzeCheckCast(CheckCast checkCast, NonEmptyParameterUsages state) {
     // Mark the value as ineligible for class inlining if it has phi users.
     return checkCast.outValue().hasPhiUsers() ? fail(checkCast, state) : state;
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeIf(If theIf, AnalysisState state) {
+  private ParameterUsages analyzeIf(If theIf, NonEmptyParameterUsages state) {
     // Null/not-null tests are ok.
     if (theIf.isZeroTest()) {
       assert argumentsOfInterest.contains(theIf.lhs().getAliasedValue(aliasedValueConfiguration));
@@ -160,8 +163,8 @@
     return fail(theIf, state);
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeInstanceGet(
-      InstanceGet instanceGet, AnalysisState state) {
+  private ParameterUsages analyzeInstanceGet(
+      InstanceGet instanceGet, NonEmptyParameterUsages state) {
     // Instance field reads are OK, as long as the field resolves, since the class inliner will
     // just replace the field read by the value of the field.
     FieldResolutionResult resolutionResult = appView.appInfo().resolveField(instanceGet.getField());
@@ -176,8 +179,8 @@
     return fail(instanceGet, state);
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeInstancePut(
-      InstancePut instancePut, AnalysisState state) {
+  private ParameterUsages analyzeInstancePut(
+      InstancePut instancePut, NonEmptyParameterUsages state) {
     // Instance field writes are OK, as long as the field resolves and the receiver is not being
     // assigned (in that case the receiver escapes, and thus it is not eligible for class
     // inlining).
@@ -199,8 +202,7 @@
     }
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeInvokeDirect(
-      InvokeDirect invoke, AnalysisState state) {
+  private ParameterUsages analyzeInvokeDirect(InvokeDirect invoke, NonEmptyParameterUsages state) {
     // We generally don't class inline instances that escape through invoke-direct calls, but we
     // make an exception for forwarding/parent constructor calls that does not leak the receiver.
     state =
@@ -242,8 +244,8 @@
     return state;
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeInvokeInterface(
-      InvokeInterface invoke, AnalysisState state) {
+  private ParameterUsages analyzeInvokeInterface(
+      InvokeInterface invoke, NonEmptyParameterUsages state) {
     // We only allow invoke-interface instructions where the parameter is in the receiver position.
     state =
         state.abandonClassInliningInCurrentContexts(
@@ -264,8 +266,7 @@
         receiverRoot, (context, usage) -> usage.addMethodCallWithParameterAsReceiver(invoke));
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeInvokeStatic(
-      InvokeStatic invoke, AnalysisState state) {
+  private ParameterUsages analyzeInvokeStatic(InvokeStatic invoke, NonEmptyParameterUsages state) {
     // We generally don't class inline instances that escape through invoke-static calls, but we
     // make an exception for calls to Objects.requireNonNull().
     SingleResolutionResult resolutionResult =
@@ -282,8 +283,8 @@
     return fail(invoke, state);
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeInvokeVirtual(
-      InvokeVirtual invoke, AnalysisState state) {
+  private ParameterUsages analyzeInvokeVirtual(
+      InvokeVirtual invoke, NonEmptyParameterUsages state) {
     // We only allow invoke-virtual instructions where the parameter is in the receiver position.
     state =
         state.abandonClassInliningInCurrentContexts(
@@ -304,21 +305,19 @@
         receiverRoot, (context, usage) -> usage.addMethodCallWithParameterAsReceiver(invoke));
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeMonitor(
-      Monitor monitor, AnalysisState state) {
+  private ParameterUsages analyzeMonitor(Monitor monitor, NonEmptyParameterUsages state) {
     // Record that the receiver is used as a lock in each context that may reach this monitor
     // instruction.
     return state.rebuildParameter(
         monitor.object(), (context, usage) -> usage.setParameterUsedAsLock());
   }
 
-  private TransferFunctionResult<AnalysisState> analyzeReturn(
-      Return theReturn, AnalysisState state) {
+  private ParameterUsages analyzeReturn(Return theReturn, NonEmptyParameterUsages state) {
     return state.rebuildParameter(
         theReturn.returnValue(), (context, usage) -> usage.setParameterReturned());
   }
 
-  private TransferFunctionResult<AnalysisState> fail(Instruction instruction, AnalysisState state) {
+  private ParameterUsages fail(Instruction instruction, NonEmptyParameterUsages state) {
     return state.abandonClassInliningInCurrentContexts(
         instruction.inValues(), this::isArgumentOfInterest);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/UnknownParameterUsages.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/UnknownParameterUsages.java
new file mode 100644
index 0000000..13e32a7
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/UnknownParameterUsages.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner.analysis;
+
+public class UnknownParameterUsages extends ParameterUsages {
+
+  private static final UnknownParameterUsages INSTANCE = new UnknownParameterUsages();
+
+  private UnknownParameterUsages() {}
+
+  static UnknownParameterUsages getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  ParameterUsages externalize() {
+    return this;
+  }
+
+  @Override
+  public ParameterUsagePerContext get(int parameter) {
+    return ParameterUsagePerContext.top();
+  }
+
+  @Override
+  public boolean isTop() {
+    return true;
+  }
+
+  @Override
+  ParameterUsages put(int parameter, ParameterUsagePerContext usagePerContext) {
+    return this;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    return other == INSTANCE;
+  }
+
+  @Override
+  public int hashCode() {
+    return System.identityHashCode(this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/AlwaysTrueClassInlinerMethodConstraint.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/AlwaysTrueClassInlinerMethodConstraint.java
new file mode 100644
index 0000000..30ae12b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/AlwaysTrueClassInlinerMethodConstraint.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner.constraint;
+
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.optimize.classinliner.analysis.ParameterUsage;
+
+public class AlwaysTrueClassInlinerMethodConstraint implements ClassInlinerMethodConstraint {
+
+  private static final AlwaysTrueClassInlinerMethodConstraint INSTANCE =
+      new AlwaysTrueClassInlinerMethodConstraint();
+
+  private AlwaysTrueClassInlinerMethodConstraint() {}
+
+  static AlwaysTrueClassInlinerMethodConstraint getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public ClassInlinerMethodConstraint fixupAfterRemovingThisParameter() {
+    return this;
+  }
+
+  @Override
+  public ParameterUsage getParameterUsage(int parameter) {
+    return ParameterUsage.bottom();
+  }
+
+  @Override
+  public boolean isEligibleForNewInstanceClassInlining(ProgramMethod method, int parameter) {
+    return true;
+  }
+
+  @Override
+  public boolean isEligibleForStaticGetClassInlining(ProgramMethod method, int parameter) {
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ClassInlinerMethodConstraint.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ClassInlinerMethodConstraint.java
index c86f373..9b04087 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ClassInlinerMethodConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ClassInlinerMethodConstraint.java
@@ -20,4 +20,8 @@
   static AlwaysFalseClassInlinerMethodConstraint alwaysFalse() {
     return AlwaysFalseClassInlinerMethodConstraint.getInstance();
   }
+
+  static AlwaysTrueClassInlinerMethodConstraint alwaysTrue() {
+    return AlwaysTrueClassInlinerMethodConstraint.getInstance();
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ConditionalClassInlinerMethodConstraint.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ConditionalClassInlinerMethodConstraint.java
index 5c384e8..be9d99a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ConditionalClassInlinerMethodConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/constraint/ConditionalClassInlinerMethodConstraint.java
@@ -6,35 +6,38 @@
 
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.optimize.classinliner.analysis.AnalysisContext;
-import com.android.tools.r8.ir.optimize.classinliner.analysis.AnalysisState;
 import com.android.tools.r8.ir.optimize.classinliner.analysis.NonEmptyParameterUsage;
+import com.android.tools.r8.ir.optimize.classinliner.analysis.NonEmptyParameterUsages;
 import com.android.tools.r8.ir.optimize.classinliner.analysis.ParameterUsage;
 import com.android.tools.r8.ir.optimize.classinliner.analysis.ParameterUsagePerContext;
+import com.android.tools.r8.ir.optimize.classinliner.analysis.ParameterUsages;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 
 public class ConditionalClassInlinerMethodConstraint implements ClassInlinerMethodConstraint {
 
-  private final AnalysisState usages;
+  private final ParameterUsages usages;
 
-  public ConditionalClassInlinerMethodConstraint(AnalysisState usages) {
+  public ConditionalClassInlinerMethodConstraint(ParameterUsages usages) {
+    assert !usages.isTop();
     this.usages = usages;
   }
 
   @Override
   public ClassInlinerMethodConstraint fixupAfterRemovingThisParameter() {
-    // TODO(b/181746071): Introduce a 'TOP' variant to reduce memory usage and add check here.
     if (usages.isBottom()) {
       return this;
     }
     Int2ObjectMap<ParameterUsagePerContext> backing = new Int2ObjectOpenHashMap<>();
-    usages.forEach(
-        (parameter, usagePerContext) -> {
-          if (parameter > 0) {
-            backing.put(parameter - 1, usagePerContext);
-          }
-        });
-    return new ConditionalClassInlinerMethodConstraint(AnalysisState.create(backing));
+    usages
+        .asNonEmpty()
+        .forEach(
+            (parameter, usagePerContext) -> {
+              if (parameter > 0) {
+                backing.put(parameter - 1, usagePerContext);
+              }
+            });
+    return new ConditionalClassInlinerMethodConstraint(NonEmptyParameterUsages.create(backing));
   }
 
   @Override