diff --git a/src/main/java/com/android/tools/r8/ir/code/Assume.java b/src/main/java/com/android/tools/r8/ir/code/Assume.java
index f5d95bf..7978468 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Assume.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Assume.java
@@ -4,27 +4,39 @@
 package com.android.tools.r8.ir.code;
 
 import com.android.tools.r8.cf.LoadStoreHelper;
+import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
+import com.android.tools.r8.ir.code.Assume.Assumption;
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.ir.optimize.InliningConstraints;
 
-public class Assume extends Instruction {
-  private final static String ERROR_MESSAGE = "This fake IR should be removed after inlining.";
+public class Assume<An extends Assumption> extends Instruction {
 
-  final Instruction origin;
+  private static final String ERROR_MESSAGE =
+      "Expected Assume instructions to be removed after IR processing.";
 
-  public Assume(Value dest, Value src, Instruction origin) {
+  private final An assumption;
+  private final Instruction origin;
+
+  private Assume(An assumption, Value dest, Value src, Instruction origin) {
     super(dest, src);
-    assert !src.isNeverNull();
+    assert assumption != null;
+    assert assumption.verifyCorrectnessOfValues(dest, src);
+    this.assumption = assumption;
     this.origin = origin;
   }
 
+  public static Assume<NonNullAssumption> createAssumeNonNullInstruction(
+      Value dest, Value src, Instruction origin) {
+    return new Assume<>(NonNullAssumption.get(), dest, src, origin);
+  }
+
   @Override
   public <T> T accept(InstructionVisitor<T> visitor) {
     return visitor.visit(this);
@@ -43,16 +55,29 @@
   }
 
   @Override
-  public boolean isNonNull() {
+  public boolean isAssume() {
     return true;
   }
 
   @Override
-  public Assume asNonNull() {
+  public Assume<An> asAssume() {
     return this;
   }
 
   @Override
+  public boolean isAssumeNonNull() {
+    return assumption.isAssumeNonNull();
+  }
+
+  @Override
+  public Assume<NonNullAssumption> asAssumeNonNull() {
+    assert isAssumeNonNull();
+    @SuppressWarnings("unchecked")
+    Assume<NonNullAssumption> self = (Assume<NonNullAssumption>) this;
+    return self;
+  }
+
+  @Override
   public boolean isIntroducingAnAlias() {
     return true;
   }
@@ -94,19 +119,26 @@
 
   @Override
   public boolean identicalNonValueNonPositionParts(Instruction other) {
-    return other.isNonNull();
+    if (!other.isAssume()) {
+      return false;
+    }
+    Assume<?> assumeInstruction = other.asAssume();
+    return assumption.equals(assumeInstruction.assumption);
   }
 
   @Override
   public ConstraintWithTarget inliningConstraint(
       InliningConstraints inliningConstraints, DexType invocationContext) {
-    return inliningConstraints.forNonNull();
+    return inliningConstraints.forAssume();
   }
 
   @Override
   public TypeLatticeElement evaluate(AppView<? extends AppInfo> appView) {
-    assert src().getTypeLattice().isReference();
-    return src().getTypeLattice().asReferenceTypeLatticeElement().asNotNull();
+    if (assumption.isAssumeNonNull()) {
+      assert src().getTypeLattice().isReference();
+      return src().getTypeLattice().asReferenceTypeLatticeElement().asNotNull();
+    }
+    throw new Unimplemented();
   }
 
   @Override
@@ -118,4 +150,37 @@
   public void insertLoadAndStores(InstructionListIterator it, LoadStoreHelper helper) {
     throw new Unreachable(ERROR_MESSAGE);
   }
+
+  abstract static class Assumption {
+
+    public boolean isAssumeNonNull() {
+      return false;
+    }
+
+    public boolean verifyCorrectnessOfValues(Value dest, Value src) {
+      return true;
+    }
+  }
+
+  public static class NonNullAssumption extends Assumption {
+
+    private static final NonNullAssumption instance = new NonNullAssumption();
+
+    private NonNullAssumption() {}
+
+    public static NonNullAssumption get() {
+      return instance;
+    }
+
+    @Override
+    public boolean isAssumeNonNull() {
+      return true;
+    }
+
+    @Override
+    public boolean verifyCorrectnessOfValues(Value dest, Value src) {
+      assert !src.isNeverNull();
+      return true;
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java b/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java
index 5ec29e4..8a3fb3a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java
+++ b/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java
@@ -35,6 +35,11 @@
   }
 
   @Override
+  public T visit(Assume<?> instruction) {
+    return null;
+  }
+
+  @Override
   public T visit(And instruction) {
     return null;
   }
@@ -260,11 +265,6 @@
   }
 
   @Override
-  public T visit(Assume instruction) {
-    return null;
-  }
-
-  @Override
   public T visit(Not instruction) {
     return null;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index 7bf9eed..dcbef34 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.ir.analysis.constant.ConstRangeLatticeElement;
 import com.android.tools.r8.ir.analysis.constant.LatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
+import com.android.tools.r8.ir.code.Assume.NonNullAssumption;
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -604,6 +605,22 @@
     return null;
   }
 
+  public boolean isAssume() {
+    return false;
+  }
+
+  public Assume<?> asAssume() {
+    return null;
+  }
+
+  public boolean isAssumeNonNull() {
+    return false;
+  }
+
+  public Assume<NonNullAssumption> asAssumeNonNull() {
+    return null;
+  }
+
   public boolean isBinop() {
     return false;
   }
@@ -832,14 +849,6 @@
     return null;
   }
 
-  public boolean isNonNull() {
-    return false;
-  }
-
-  public Assume asNonNull() {
-    return null;
-  }
-
   public boolean isNot() {
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java b/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java
index d6160d7..d7f9ae3 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java
@@ -24,6 +24,8 @@
 
   T visit(ArrayPut instruction);
 
+  T visit(Assume<?> instruction);
+
   T visit(CheckCast instruction);
 
   T visit(Cmp instruction);
@@ -104,8 +106,6 @@
 
   T visit(NewInstance instruction);
 
-  T visit(Assume instruction);
-
   T visit(Not instruction);
 
   T visit(NumberConversion instruction);
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index 7c9fda8..5138bc1 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -236,8 +236,9 @@
 
   /**
    * If this value is defined by an instruction that defines an alias of another value, such as the
-   * NonNull instruction, then the incoming value to the NonNull instruction is returned (if the
-   * incoming value is not itself defined by an instruction that introduces an alias).
+   * {@link Assume} instruction, then the incoming value to the {@link Assume} instruction is
+   * returned (if the incoming value is not itself defined by an instruction that introduces an
+   * alias).
    *
    * <p>If a phi value is found, then that phi value is returned.
    *
@@ -260,7 +261,7 @@
         assert visited.add(aliasedValue);
       }
     } while (aliasedValue != lastAliasedValue);
-    assert aliasedValue.isPhi() || !aliasedValue.definition.isNonNull();
+    assert aliasedValue.isPhi() || !aliasedValue.definition.isAssume();
     return aliasedValue;
   }
 
@@ -783,7 +784,7 @@
    */
   public boolean isNeverNull() {
     assert typeLattice.isReference();
-    return (definition != null && definition.isNonNull())
+    return (definition != null && definition.isAssumeNonNull())
         || typeLattice.nullability().isDefinitelyNotNull();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
index 38f7d27..af2b34e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.Assume;
+import com.android.tools.r8.ir.code.Assume.NonNullAssumption;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.CheckCast;
 import com.android.tools.r8.ir.code.DominatorTree;
@@ -65,8 +66,8 @@
         // (out <-) invoke-virtual rcv_c, ... C#foo
         // ...
         // non_null_rcv <- non-null rcv_c  // <- Update the input rcv to the non-null, too.
-        if (current.isNonNull()) {
-          Assume nonNull = current.asNonNull();
+        if (current.isAssumeNonNull()) {
+          Assume<NonNullAssumption> nonNull = current.asAssumeNonNull();
           Instruction origin = nonNull.origin();
           if (origin.isInvokeInterface()
               && !origin.asInvokeInterface().getReceiver().hasLocalInfo()
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
index 2a66866..b5f8538 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
@@ -221,7 +221,7 @@
     return ConstraintWithTarget.classIsVisible(invocationContext, type, appView);
   }
 
-  public ConstraintWithTarget forNonNull() {
+  public ConstraintWithTarget forAssume() {
     return ConstraintWithTarget.ALWAYS;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
index 94bf914..fffd3da 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.Assume;
+import com.android.tools.r8.ir.code.Assume.NonNullAssumption;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.DominatorTree;
 import com.android.tools.r8.ir.code.IRCode;
@@ -225,7 +226,9 @@
                         typeLattice.asReferenceTypeLatticeElement().asNotNull(),
                         knownToBeNonNullValue.getLocalInfo());
                 affectedValues.addAll(knownToBeNonNullValue.affectedValues());
-                Assume nonNull = new Assume(nonNullValue, knownToBeNonNullValue, theIf);
+                Assume<NonNullAssumption> nonNull =
+                    Assume.createAssumeNonNullInstruction(
+                        nonNullValue, knownToBeNonNullValue, theIf);
                 InstructionListIterator targetIterator = target.listIterator();
                 nonNull.setPosition(targetIterator.next().getPosition());
                 targetIterator.previous();
@@ -318,7 +321,8 @@
                 typeLattice.asReferenceTypeLatticeElement().asNotNull(),
                 knownToBeNonNullValue.getLocalInfo());
         affectedValues.addAll(knownToBeNonNullValue.affectedValues());
-        Assume nonNull = new Assume(nonNullValue, knownToBeNonNullValue, current);
+        Assume<NonNullAssumption> nonNull =
+            Assume.createAssumeNonNullInstruction(nonNullValue, knownToBeNonNullValue, current);
         nonNull.setPosition(current.getPosition());
         if (blockWithNonNullInstruction != block) {
           // If we split, add non-null IR on top of the new split block.
@@ -387,8 +391,8 @@
       // Collect basic blocks that check nullability of the parameter.
       nullCheckedBlocks.clear();
       for (Instruction user : argument.uniqueUsers()) {
-        if (user.isNonNull()) {
-          nullCheckedBlocks.add(user.asNonNull().getBlock());
+        if (user.isAssumeNonNull()) {
+          nullCheckedBlocks.add(user.asAssumeNonNull().getBlock());
         }
         if (user.isIf()
             && user.asIf().isZeroTest()
@@ -483,8 +487,8 @@
       //  ~>
       //
       // rcv#foo
-      if (instruction.isNonNull()) {
-        Assume nonNull = instruction.asNonNull();
+      if (instruction.isAssumeNonNull()) {
+        Assume<NonNullAssumption> nonNull = instruction.asAssumeNonNull();
         Value src = nonNull.src();
         Value dest = nonNull.dest();
         affectedValues.addAll(dest.affectedValues());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java
index 5c55d31..7cd0a5b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java
@@ -111,10 +111,10 @@
             assert !couldBeVolatile(field);
             if (instruction.isInstanceGet() && !instruction.outValue().hasLocalInfo()) {
               Value object = instruction.asInstanceGet().object();
-              // Values from NonNull instructions will always be replaced with their original
-              // value before code is generated.
-              if (!object.isPhi() && object.definition.isNonNull()) {
-                object = object.definition.asNonNull().src();
+              // Values from Assume instructions will always be replaced with their original value
+              // before code is generated.
+              if (!object.isPhi() && object.definition.isAssume()) {
+                object = object.definition.asAssume().src();
               }
               FieldAndObject fieldAndObject = new FieldAndObject(field, object);
               if (activeInstanceFields.containsKey(fieldAndObject)) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
index e971cc1..3f3ccd2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
@@ -61,15 +61,15 @@
     while (it.hasNext()) {
       prev = curr != null && !curr.isGoto() ? curr : prev;
       curr = it.next();
-      if (curr.isNonNull()) {
+      if (curr.isAssumeNonNull()) {
         // Make sure non-null is added to the right place.
         assertTrue(prev == null
             || NonNullTracker.throwsOnNullInput(prev)
             || (prev.isIf() && prev.asIf().isZeroTest())
             || !curr.getBlock().getPredecessors().contains(prev.getBlock()));
         // Make sure non-null is used or inserted for arguments.
-        assertTrue(curr.outValue().numberOfAllUsers() > 0
-            || curr.asNonNull().src().isArgument());
+        assertTrue(
+            curr.outValue().numberOfAllUsers() > 0 || curr.asAssumeNonNull().src().isArgument());
         count++;
       }
     }
@@ -143,28 +143,33 @@
   public void avoidRedundantNonNull() throws Exception {
     MethodSignature signature = new MethodSignature("foo2", "int",
         new String[]{FieldAccessTest.class.getCanonicalName()});
-    buildAndTest(NonNullAfterFieldAccess.class, signature, 1, ircode -> {
-      // There are two InstancePut instructions of interest.
-      int count = 0;
-      InstructionIterator it = ircode.instructionIterator();
-      while (it.hasNext()) {
-        Instruction instruction = it.nextUntil(Instruction::isInstancePut);
-        if (instruction == null) {
-          break;
-        }
-        InstancePut iput = instruction.asInstancePut();
-        if (count == 0) {
-          // First one in the very first line: its value should not be replaced by NonNullMarker
-          // because this instruction will happen _before_ non-null.
-          assertFalse(iput.value().definition.isNonNull());
-        } else if (count == 1) {
-          // Second one after a safe invocation, which should use the value added by NonNullMarker.
-          assertTrue(iput.object().definition.isNonNull());
-        }
-        count++;
-      }
-      assertEquals(2, count);
-    });
+    buildAndTest(
+        NonNullAfterFieldAccess.class,
+        signature,
+        1,
+        ircode -> {
+          // There are two InstancePut instructions of interest.
+          int count = 0;
+          InstructionIterator it = ircode.instructionIterator();
+          while (it.hasNext()) {
+            Instruction instruction = it.nextUntil(Instruction::isInstancePut);
+            if (instruction == null) {
+              break;
+            }
+            InstancePut iput = instruction.asInstancePut();
+            if (count == 0) {
+              // First one in the very first line: its value should not be replaced by NonNullMarker
+              // because this instruction will happen _before_ non-null.
+              assertFalse(iput.value().definition.isAssumeNonNull());
+            } else if (count == 1) {
+              // Second one after a safe invocation, which should use the value added by
+              // NonNullMarker.
+              assertTrue(iput.object().definition.isAssumeNonNull());
+            }
+            count++;
+          }
+          assertEquals(2, count);
+        });
   }
 
   @Test