diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/BooleanFalseSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/BooleanFalseSimpleInliningConstraint.java
new file mode 100644
index 0000000..2c88a60
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/BooleanFalseSimpleInliningConstraint.java
@@ -0,0 +1,48 @@
+// 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.ir.analysis.inlining;
+
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import it.unimi.dsi.fastutil.ints.IntList;
+
+/** Constraint that is satisfied if a specific argument is always false. */
+public class BooleanFalseSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
+
+  private BooleanFalseSimpleInliningConstraint(int argumentIndex) {
+    super(argumentIndex);
+  }
+
+  static BooleanFalseSimpleInliningConstraint create(
+      int argumentIndex, SimpleInliningConstraintFactory witness) {
+    assert witness != null;
+    return new BooleanFalseSimpleInliningConstraint(argumentIndex);
+  }
+
+  @Override
+  public boolean isBooleanFalse() {
+    return true;
+  }
+
+  @Override
+  public boolean isSatisfied(InvokeMethod invoke) {
+    Value argument = getArgument(invoke);
+    assert argument.getType().isInt();
+    return argument.isConstBoolean(false);
+  }
+
+  @Override
+  public SimpleInliningConstraint fixupAfterRemovingThisParameter(
+      SimpleInliningConstraintFactory factory) {
+    assert getArgumentIndex() > 0;
+    return factory.createBooleanFalseConstraint(getArgumentIndex() - 1);
+  }
+
+  @Override
+  public SimpleInliningConstraint rewrittenWithUnboxedArguments(
+      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/BooleanTrueSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/BooleanTrueSimpleInliningConstraint.java
new file mode 100644
index 0000000..46c29b0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/BooleanTrueSimpleInliningConstraint.java
@@ -0,0 +1,48 @@
+// 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.ir.analysis.inlining;
+
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import it.unimi.dsi.fastutil.ints.IntList;
+
+/** Constraint that is satisfied if a specific argument is always true. */
+public class BooleanTrueSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
+
+  private BooleanTrueSimpleInliningConstraint(int argumentIndex) {
+    super(argumentIndex);
+  }
+
+  static BooleanTrueSimpleInliningConstraint create(
+      int argumentIndex, SimpleInliningConstraintFactory witness) {
+    assert witness != null;
+    return new BooleanTrueSimpleInliningConstraint(argumentIndex);
+  }
+
+  @Override
+  public boolean isBooleanTrue() {
+    return true;
+  }
+
+  @Override
+  public boolean isSatisfied(InvokeMethod invoke) {
+    Value argument = getArgument(invoke);
+    assert argument.getType().isInt();
+    return argument.isConstBoolean(true);
+  }
+
+  @Override
+  public SimpleInliningConstraint fixupAfterRemovingThisParameter(
+      SimpleInliningConstraintFactory factory) {
+    assert getArgumentIndex() > 0;
+    return factory.createBooleanTrueConstraint(getArgumentIndex() - 1);
+  }
+
+  @Override
+  public SimpleInliningConstraint rewrittenWithUnboxedArguments(
+      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToBooleanSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToBooleanSimpleInliningConstraint.java
deleted file mode 100644
index 4a98c53..0000000
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToBooleanSimpleInliningConstraint.java
+++ /dev/null
@@ -1,46 +0,0 @@
-// 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.ir.analysis.inlining;
-
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.Value;
-import it.unimi.dsi.fastutil.ints.IntList;
-
-/** Constraint that is satisfied if a specific argument is always true. */
-public class EqualToBooleanSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
-
-  private final boolean value;
-
-  private EqualToBooleanSimpleInliningConstraint(int argumentIndex, boolean value) {
-    super(argumentIndex);
-    this.value = value;
-  }
-
-  static EqualToBooleanSimpleInliningConstraint create(
-      int argumentIndex, boolean value, SimpleInliningConstraintFactory witness) {
-    assert witness != null;
-    return new EqualToBooleanSimpleInliningConstraint(argumentIndex, value);
-  }
-
-  @Override
-  public boolean isSatisfied(InvokeMethod invoke) {
-    Value argumentRoot = getArgument(invoke).getAliasedValue();
-    return argumentRoot.isDefinedByInstructionSatisfying(Instruction::isConstNumber)
-        && argumentRoot.getDefinition().asConstNumber().getBooleanValue() == value;
-  }
-
-  @Override
-  public SimpleInliningConstraint rewrittenWithUnboxedArguments(
-      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
-    return this;
-  }
-
-  @Override
-  SimpleInliningArgumentConstraint withArgumentIndex(
-      int argumentIndex, SimpleInliningConstraintFactory factory) {
-    return factory.createEqualToTrueConstraint(argumentIndex);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToNumberSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToNumberSimpleInliningConstraint.java
index 236e57b..a321670 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToNumberSimpleInliningConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/EqualToNumberSimpleInliningConstraint.java
@@ -4,10 +4,18 @@
 
 package com.android.tools.r8.ir.analysis.inlining;
 
-public class EqualToNumberSimpleInliningConstraint extends NumberSimpleInliningConstraint {
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import it.unimi.dsi.fastutil.ints.IntList;
+
+public class EqualToNumberSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
+
+  private final long rawValue;
 
   private EqualToNumberSimpleInliningConstraint(int argumentIndex, long rawValue) {
-    super(argumentIndex, rawValue);
+    super(argumentIndex);
+    this.rawValue = rawValue;
   }
 
   static EqualToNumberSimpleInliningConstraint create(
@@ -17,13 +25,22 @@
   }
 
   @Override
-  boolean test(long argumentValue) {
-    return argumentValue == getRawValue();
+  public boolean isSatisfied(InvokeMethod invoke) {
+    Value argumentRoot = getArgument(invoke).getAliasedValue();
+    return argumentRoot.isDefinedByInstructionSatisfying(Instruction::isConstNumber)
+        && argumentRoot.getDefinition().asConstNumber().getRawValue() == rawValue;
   }
 
   @Override
-  SimpleInliningArgumentConstraint withArgumentIndex(
-      int argumentIndex, SimpleInliningConstraintFactory factory) {
-    return factory.createEqualToNumberConstraint(argumentIndex, getRawValue());
+  public SimpleInliningConstraint fixupAfterRemovingThisParameter(
+      SimpleInliningConstraintFactory factory) {
+    assert getArgumentIndex() > 0;
+    return factory.createNumberConstraint(getArgumentIndex() - 1, rawValue);
+  }
+
+  @Override
+  public SimpleInliningConstraint rewrittenWithUnboxedArguments(
+      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
+    return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotEqualToNumberSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotEqualToNumberSimpleInliningConstraint.java
index 5f83db7..4739231 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotEqualToNumberSimpleInliningConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotEqualToNumberSimpleInliningConstraint.java
@@ -4,10 +4,18 @@
 
 package com.android.tools.r8.ir.analysis.inlining;
 
-public class NotEqualToNumberSimpleInliningConstraint extends NumberSimpleInliningConstraint {
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import it.unimi.dsi.fastutil.ints.IntList;
+
+public class NotEqualToNumberSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
+
+  private final long rawValue;
 
   private NotEqualToNumberSimpleInliningConstraint(int argumentIndex, long rawValue) {
-    super(argumentIndex, rawValue);
+    super(argumentIndex);
+    this.rawValue = rawValue;
   }
 
   static NotEqualToNumberSimpleInliningConstraint create(
@@ -17,13 +25,22 @@
   }
 
   @Override
-  boolean test(long argumentValue) {
-    return argumentValue != getRawValue();
+  public boolean isSatisfied(InvokeMethod invoke) {
+    Value argumentRoot = getArgument(invoke).getAliasedValue();
+    return argumentRoot.isDefinedByInstructionSatisfying(Instruction::isConstNumber)
+        && argumentRoot.getDefinition().asConstNumber().getRawValue() != rawValue;
   }
 
   @Override
-  SimpleInliningArgumentConstraint withArgumentIndex(
-      int argumentIndex, SimpleInliningConstraintFactory factory) {
-    return factory.createNotEqualToNumberConstraint(argumentIndex, getRawValue());
+  public SimpleInliningConstraint fixupAfterRemovingThisParameter(
+      SimpleInliningConstraintFactory factory) {
+    assert getArgumentIndex() > 0;
+    return factory.createNotNumberConstraint(getArgumentIndex() - 1, rawValue);
+  }
+
+  @Override
+  public SimpleInliningConstraint rewrittenWithUnboxedArguments(
+      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
+    return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotNullSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotNullSimpleInliningConstraint.java
new file mode 100644
index 0000000..00288f8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NotNullSimpleInliningConstraint.java
@@ -0,0 +1,51 @@
+// 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.ir.analysis.inlining;
+
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import it.unimi.dsi.fastutil.ints.IntList;
+
+/** Constraint that is satisfied if a specific argument is always non-null. */
+public class NotNullSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
+
+  private NotNullSimpleInliningConstraint(int argumentIndex) {
+    super(argumentIndex);
+  }
+
+  static NotNullSimpleInliningConstraint create(
+      int argumentIndex, SimpleInliningConstraintFactory witness) {
+    assert witness != null;
+    return new NotNullSimpleInliningConstraint(argumentIndex);
+  }
+
+  @Override
+  public boolean isNotNull() {
+    return true;
+  }
+
+  @Override
+  public boolean isSatisfied(InvokeMethod invoke) {
+    Value argument = getArgument(invoke);
+    assert argument.getType().isReferenceType() : invoke;
+    return argument.isNeverNull();
+  }
+
+  @Override
+  public SimpleInliningConstraint fixupAfterRemovingThisParameter(
+      SimpleInliningConstraintFactory factory) {
+    assert getArgumentIndex() > 0;
+    return factory.createNotNullConstraint(getArgumentIndex() - 1);
+  }
+
+  @Override
+  public SimpleInliningConstraint rewrittenWithUnboxedArguments(
+      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
+    if (unboxedArgumentIndices.contains(getArgumentIndex())) {
+      return factory.createNotNumberConstraint(getArgumentIndex(), 0);
+    }
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NullSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NullSimpleInliningConstraint.java
index 55c442e..5a0d3cf 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NullSimpleInliningConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NullSimpleInliningConstraint.java
@@ -4,8 +4,6 @@
 
 package com.android.tools.r8.ir.analysis.inlining;
 
-import com.android.tools.r8.ir.analysis.type.Nullability;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.Value;
 import it.unimi.dsi.fastutil.ints.IntList;
@@ -13,43 +11,45 @@
 /** Constraint that is satisfied if a specific argument is always null. */
 public class NullSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
 
-  private final Nullability nullability;
-
-  private NullSimpleInliningConstraint(int argumentIndex, Nullability nullability) {
+  private NullSimpleInliningConstraint(int argumentIndex) {
     super(argumentIndex);
-    assert nullability.isDefinitelyNull() || nullability.isDefinitelyNotNull();
-    this.nullability = nullability;
   }
 
   static NullSimpleInliningConstraint create(
-      int argumentIndex, Nullability nullability, SimpleInliningConstraintFactory witness) {
+      int argumentIndex, SimpleInliningConstraintFactory witness) {
     assert witness != null;
-    return new NullSimpleInliningConstraint(argumentIndex, nullability);
+    return new NullSimpleInliningConstraint(argumentIndex);
   }
 
   @Override
-  public final boolean isSatisfied(InvokeMethod invoke) {
+  public boolean isNull() {
+    return true;
+  }
+
+  @Override
+  public boolean isSatisfied(InvokeMethod invoke) {
     // Take the root value to also deal with the following case, which may happen in dead code,
     // where v1 is actually guaranteed to be null, despite the value's type being non-null:
     //   v0 <- ConstNumber 0
     //   v1 <- AssumeNotNull v0
     Value argumentRoot = getArgument(invoke).getAliasedValue();
-    TypeElement argumentType = argumentRoot.getType();
-    assert argumentType.isReferenceType();
-    return argumentType.nullability() == nullability;
+    assert argumentRoot.getType().isReferenceType();
+    return argumentRoot.getType().isDefinitelyNull();
+  }
+
+  @Override
+  public SimpleInliningConstraint fixupAfterRemovingThisParameter(
+      SimpleInliningConstraintFactory factory) {
+    assert getArgumentIndex() > 0;
+    return factory.createNullConstraint(getArgumentIndex() - 1);
   }
 
   @Override
   public SimpleInliningConstraint rewrittenWithUnboxedArguments(
       IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
-    return unboxedArgumentIndices.contains(getArgumentIndex())
-        ? factory.createEqualToNumberConstraint(getArgumentIndex(), 0)
-        : this;
-  }
-
-  @Override
-  SimpleInliningArgumentConstraint withArgumentIndex(
-      int argumentIndex, SimpleInliningConstraintFactory factory) {
-    return factory.createNullConstraint(argumentIndex, nullability);
+    if (unboxedArgumentIndices.contains(getArgumentIndex())) {
+      return factory.createNumberConstraint(getArgumentIndex(), 0);
+    }
+    return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NumberSimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/NumberSimpleInliningConstraint.java
deleted file mode 100644
index 4f6ee2c..0000000
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/NumberSimpleInliningConstraint.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// 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.analysis.inlining;
-
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.Value;
-import it.unimi.dsi.fastutil.ints.IntList;
-
-public abstract class NumberSimpleInliningConstraint extends SimpleInliningArgumentConstraint {
-
-  private final long rawValue;
-
-  NumberSimpleInliningConstraint(int argumentIndex, long rawValue) {
-    super(argumentIndex);
-    this.rawValue = rawValue;
-  }
-
-  long getRawValue() {
-    return rawValue;
-  }
-
-  @Override
-  public final boolean isSatisfied(InvokeMethod invoke) {
-    Value argumentRoot = getArgument(invoke).getAliasedValue();
-    return argumentRoot.isDefinedByInstructionSatisfying(Instruction::isConstNumber)
-        && test(argumentRoot.getDefinition().asConstNumber().getRawValue());
-  }
-
-  abstract boolean test(long argumentValue);
-
-  @Override
-  public final SimpleInliningConstraint rewrittenWithUnboxedArguments(
-      IntList unboxedArgumentIndices, SimpleInliningConstraintFactory factory) {
-    return this;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningArgumentConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningArgumentConstraint.java
index 78bf329..749d6f4 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningArgumentConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningArgumentConstraint.java
@@ -15,13 +15,6 @@
     this.argumentIndex = argumentIndex;
   }
 
-  @Override
-  public final SimpleInliningConstraint fixupAfterRemovingThisParameter(
-      SimpleInliningConstraintFactory factory) {
-    assert getArgumentIndex() > 0;
-    return withArgumentIndex(getArgumentIndex() - 1, factory);
-  }
-
   Value getArgument(InvokeMethod invoke) {
     return invoke.getArgument(argumentIndex);
   }
@@ -34,7 +27,4 @@
   public boolean isArgumentConstraint() {
     return true;
   }
-
-  abstract SimpleInliningArgumentConstraint withArgumentIndex(
-      int argumentIndex, SimpleInliningConstraintFactory factory);
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraint.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraint.java
index c9978cb..82c3f7d 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraint.java
@@ -19,6 +19,14 @@
     return false;
   }
 
+  public boolean isBooleanFalse() {
+    return false;
+  }
+
+  public boolean isBooleanTrue() {
+    return false;
+  }
+
   public boolean isConjunction() {
     return false;
   }
@@ -39,6 +47,14 @@
     return false;
   }
 
+  public boolean isNotNull() {
+    return false;
+  }
+
+  public boolean isNull() {
+    return false;
+  }
+
   public abstract boolean isSatisfied(InvokeMethod invoke);
 
   public final SimpleInliningConstraint meet(SimpleInliningConstraint other) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java
index 3d74f82..6d79b82 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java
@@ -173,15 +173,15 @@
       case EQ:
         if (isZeroTest) {
           if (argumentType.isReferenceType()) {
-            return factory.createEqualToNullConstraint(argumentIndex);
+            return factory.createNullConstraint(argumentIndex);
           }
           if (argumentType.isBooleanType()) {
-            return factory.createEqualToFalseConstraint(argumentIndex);
+            return factory.createBooleanFalseConstraint(argumentIndex);
           }
         } else if (argumentType.isPrimitiveType()) {
           OptionalLong rawValue = getRawNumberValue(otherOperand);
           if (rawValue.isPresent()) {
-            return factory.createEqualToNumberConstraint(argumentIndex, rawValue.getAsLong());
+            return factory.createNumberConstraint(argumentIndex, rawValue.getAsLong());
           }
         }
         return NeverSimpleInliningConstraint.getInstance();
@@ -189,15 +189,15 @@
       case NE:
         if (isZeroTest) {
           if (argumentType.isReferenceType()) {
-            return factory.createNotEqualToNullConstraint(argumentIndex);
+            return factory.createNotNullConstraint(argumentIndex);
           }
           if (argumentType.isBooleanType()) {
-            return factory.createEqualToTrueConstraint(argumentIndex);
+            return factory.createBooleanTrueConstraint(argumentIndex);
           }
         } else if (argumentType.isPrimitiveType()) {
           OptionalLong rawValue = getRawNumberValue(otherOperand);
           if (rawValue.isPresent()) {
-            return factory.createNotEqualToNumberConstraint(argumentIndex, rawValue.getAsLong());
+            return factory.createNotNumberConstraint(argumentIndex, rawValue.getAsLong());
           }
         }
         return NeverSimpleInliningConstraint.getInstance();
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintFactory.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintFactory.java
index 5b60ccd..ed3cd55 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintFactory.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintFactory.java
@@ -4,10 +4,6 @@
 
 package com.android.tools.r8.ir.analysis.inlining;
 
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNull;
-
-import com.android.tools.r8.ir.analysis.type.Nullability;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
@@ -15,81 +11,78 @@
 public class SimpleInliningConstraintFactory {
 
   // Immutable argument constraints for low argument indices to avoid overhead of ConcurrentHashMap.
-  private final EqualToBooleanSimpleInliningConstraint[] lowEqualToFalseConstraints =
-      new EqualToBooleanSimpleInliningConstraint[5];
-  private final EqualToBooleanSimpleInliningConstraint[] lowEqualToTrueConstraints =
-      new EqualToBooleanSimpleInliningConstraint[5];
-  private final NullSimpleInliningConstraint[] lowNotEqualToNullConstraints =
-      new NullSimpleInliningConstraint[5];
-  private final NullSimpleInliningConstraint[] lowEqualToNullConstraints =
+  private final BooleanFalseSimpleInliningConstraint[] lowBooleanFalseConstraints =
+      new BooleanFalseSimpleInliningConstraint[5];
+  private final BooleanTrueSimpleInliningConstraint[] lowBooleanTrueConstraints =
+      new BooleanTrueSimpleInliningConstraint[5];
+  private final NotNullSimpleInliningConstraint[] lowNotNullConstraints =
+      new NotNullSimpleInliningConstraint[5];
+  private final NullSimpleInliningConstraint[] lowNullConstraints =
       new NullSimpleInliningConstraint[5];
 
   // Argument constraints for high argument indices.
-  private final Map<Integer, EqualToBooleanSimpleInliningConstraint> highEqualToFalseConstraints =
+  private final Map<Integer, BooleanFalseSimpleInliningConstraint> highBooleanFalseConstraints =
       new ConcurrentHashMap<>();
-  private final Map<Integer, EqualToBooleanSimpleInliningConstraint> highEqualToTrueConstraints =
+  private final Map<Integer, BooleanTrueSimpleInliningConstraint> highBooleanTrueConstraints =
       new ConcurrentHashMap<>();
-  private final Map<Integer, NullSimpleInliningConstraint> highNotEqualToNullConstraints =
+  private final Map<Integer, NotNullSimpleInliningConstraint> highNotNullConstraints =
       new ConcurrentHashMap<>();
-  private final Map<Integer, NullSimpleInliningConstraint> highEqualToNullConstraints =
+  private final Map<Integer, NullSimpleInliningConstraint> highNullConstraints =
       new ConcurrentHashMap<>();
 
   public SimpleInliningConstraintFactory() {
-    for (int i = 0; i < lowEqualToFalseConstraints.length; i++) {
-      lowEqualToFalseConstraints[i] = EqualToBooleanSimpleInliningConstraint.create(i, false, this);
+    for (int i = 0; i < lowBooleanFalseConstraints.length; i++) {
+      lowBooleanFalseConstraints[i] = BooleanFalseSimpleInliningConstraint.create(i, this);
     }
-    for (int i = 0; i < lowEqualToTrueConstraints.length; i++) {
-      lowEqualToTrueConstraints[i] = EqualToBooleanSimpleInliningConstraint.create(i, true, this);
+    for (int i = 0; i < lowBooleanTrueConstraints.length; i++) {
+      lowBooleanTrueConstraints[i] = BooleanTrueSimpleInliningConstraint.create(i, this);
     }
-    for (int i = 0; i < lowNotEqualToNullConstraints.length; i++) {
-      lowNotEqualToNullConstraints[i] =
-          NullSimpleInliningConstraint.create(i, definitelyNotNull(), this);
+    for (int i = 0; i < lowNotNullConstraints.length; i++) {
+      lowNotNullConstraints[i] = NotNullSimpleInliningConstraint.create(i, this);
     }
-    for (int i = 0; i < lowEqualToNullConstraints.length; i++) {
-      lowEqualToNullConstraints[i] = NullSimpleInliningConstraint.create(i, definitelyNull(), this);
+    for (int i = 0; i < lowNullConstraints.length; i++) {
+      lowNullConstraints[i] = NullSimpleInliningConstraint.create(i, this);
     }
   }
 
-  public EqualToBooleanSimpleInliningConstraint createEqualToFalseConstraint(int argumentIndex) {
-    return createEqualToBooleanConstraint(argumentIndex, false);
-  }
-
-  public EqualToBooleanSimpleInliningConstraint createEqualToTrueConstraint(int argumentIndex) {
-    return createEqualToBooleanConstraint(argumentIndex, true);
-  }
-
-  public EqualToBooleanSimpleInliningConstraint createEqualToBooleanConstraint(
-      int argumentIndex, boolean value) {
+  public BooleanFalseSimpleInliningConstraint createBooleanFalseConstraint(int argumentIndex) {
     return createArgumentConstraint(
         argumentIndex,
-        value ? lowEqualToTrueConstraints : lowEqualToFalseConstraints,
-        value ? highEqualToTrueConstraints : highEqualToFalseConstraints,
-        () -> EqualToBooleanSimpleInliningConstraint.create(argumentIndex, value, this));
+        lowBooleanFalseConstraints,
+        highBooleanFalseConstraints,
+        () -> BooleanFalseSimpleInliningConstraint.create(argumentIndex, this));
   }
 
-  public NullSimpleInliningConstraint createEqualToNullConstraint(int argumentIndex) {
-    return createNullConstraint(argumentIndex, definitelyNull());
-  }
-
-  public NullSimpleInliningConstraint createNotEqualToNullConstraint(int argumentIndex) {
-    return createNullConstraint(argumentIndex, definitelyNotNull());
-  }
-
-  public NullSimpleInliningConstraint createNullConstraint(
-      int argumentIndex, Nullability nullability) {
+  public BooleanTrueSimpleInliningConstraint createBooleanTrueConstraint(int argumentIndex) {
     return createArgumentConstraint(
         argumentIndex,
-        nullability.isDefinitelyNull() ? lowEqualToNullConstraints : lowNotEqualToNullConstraints,
-        nullability.isDefinitelyNull() ? highEqualToNullConstraints : highNotEqualToNullConstraints,
-        () -> NullSimpleInliningConstraint.create(argumentIndex, nullability, this));
+        lowBooleanTrueConstraints,
+        highBooleanTrueConstraints,
+        () -> BooleanTrueSimpleInliningConstraint.create(argumentIndex, this));
   }
 
-  public NotEqualToNumberSimpleInliningConstraint createNotEqualToNumberConstraint(
+  public NotNullSimpleInliningConstraint createNotNullConstraint(int argumentIndex) {
+    return createArgumentConstraint(
+        argumentIndex,
+        lowNotNullConstraints,
+        highNotNullConstraints,
+        () -> NotNullSimpleInliningConstraint.create(argumentIndex, this));
+  }
+
+  public NullSimpleInliningConstraint createNullConstraint(int argumentIndex) {
+    return createArgumentConstraint(
+        argumentIndex,
+        lowNullConstraints,
+        highNullConstraints,
+        () -> NullSimpleInliningConstraint.create(argumentIndex, this));
+  }
+
+  public NotEqualToNumberSimpleInliningConstraint createNotNumberConstraint(
       int argumentIndex, long rawValue) {
     return NotEqualToNumberSimpleInliningConstraint.create(argumentIndex, rawValue, this);
   }
 
-  public EqualToNumberSimpleInliningConstraint createEqualToNumberConstraint(
+  public EqualToNumberSimpleInliningConstraint createNumberConstraint(
       int argumentIndex, long rawValue) {
     return EqualToNumberSimpleInliningConstraint.create(argumentIndex, rawValue, this);
   }