[clang][dataflow][NFC] Remove `SkipPast` param from `getValue(const ValueDecl &)`.

[mboehme]

Summary

This parameter was already a no-op, so removing it doesn't change behavior.

[ymandel]

Thanks! It's really exciting to see this concept being erased from the API!

clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h

public:
   void setValue(const StorageLocation &Loc, Value &Val);
 
   /// Returns the value assigned to `Loc` in the environment or null if `Loc`
   /// isn't assigned a value in the environment.
   Value *getValue(const StorageLocation &Loc) const;
 
   /// Equivalent to `getValue(getStorageLocation(D, SP), SkipPast::None)` if `D`
   /// is assigned a storage location in the environment, otherwise returns null.
-  ///
-  /// The `SP` parameter is deprecated and has no effect. In addition, it is
-  /// not permitted to pass `SkipPast::ReferenceThenPointer` for this parameter.
-  /// New uses of this function should use the default argument for `SP`.
-  Value *getValue(const ValueDecl &D, SkipPast SP = SkipPast::None) const;
+  Value *getValue(const ValueDecl &D) const;
 
   /// Equivalent to `getValue(getStorageLocation(E, SP), SkipPast::None)` if `E`
   /// is assigned a storage location in the environment, otherwise returns null.
   Value *getValue(const Expr &E, SkipPast SP) const;
 
   // FIXME: should we deprecate the following & call arena().create() directly?
 
   /// Creates a `T` (some subclass of `Value`), forwarding `args` to the

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

void Environment::setValue(const StorageLocation &Loc, Value &Val) {
   }
 }
 
 Value *Environment::getValue(const StorageLocation &Loc) const {
   auto It = LocToVal.find(&Loc);
   return It == LocToVal.end() ? nullptr : It->second;
 }
 
-Value *Environment::getValue(const ValueDecl &D, SkipPast SP) const {
-  assert(SP != SkipPast::ReferenceThenPointer);
-
+Value *Environment::getValue(const ValueDecl &D) const {
   auto *Loc = getStorageLocation(D);
   if (Loc == nullptr)
     return nullptr;
   return getValue(*Loc);
 }
 
 Value *Environment::getValue(const Expr &E, SkipPast SP) const {
   auto *Loc = getStorageLocation(E, SP);

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

auto Expectations =
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl));
 
         EXPECT_TRUE(Env.flowConditionImplies(*FooVal));
       };
 
   std::string Code = R"(
     #include "check.h"
 
     void target(bool Foo) {
auto Expectations =
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl));
 
         EXPECT_FALSE(Env.flowConditionImplies(*FooVal));
       };
 
   std::string Code = R"(
     #include "othercheck.h"
 
     void target(bool Foo) {

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

auto Results =
             Context);
   const auto *Fun = selectFirst<FunctionDecl>("target", Results);
   const auto *Var = selectFirst<VarDecl>("global", Results);
   ASSERT_THAT(Fun, NotNull());
   ASSERT_THAT(Var, NotNull());
 
   // Verify the global variable is populated when we analyze `Target`.
   Environment Env(DAContext, *Fun);
-  EXPECT_THAT(Env.getValue(*Var, SkipPast::None), NotNull());
+  EXPECT_THAT(Env.getValue(*Var), NotNull());
 }
 
 // Tests that fields mentioned only in default member initializers are included
 // in the set of tracked fields.
 TEST_F(EnvironmentTest, IncludeFieldsFromDefaultInitializers) {
   using namespace ast_matchers;
 
   std::string Code = R"cc(
auto Results =
             Context);
   const auto *Ctor = selectFirst<CXXConstructorDecl>("target", Results);
   const auto *Var = selectFirst<VarDecl>("global", Results);
   ASSERT_TRUE(Ctor != nullptr);
   ASSERT_THAT(Var, NotNull());
 
   // Verify the global variable is populated when we analyze `Target`.
   Environment Env(DAContext, *Ctor);
-  EXPECT_THAT(Env.getValue(*Var, SkipPast::None), NotNull());
+  EXPECT_THAT(Env.getValue(*Var), NotNull());
 }
 
 } // namespace

clang/unittests/Analysis/FlowSensitive/SignAnalysisTest.cpp

 // it hadn't have any previously.
 std::tuple<Value *, SignProperties, SignProperties>
 getValueAndSignProperties(const UnaryOperator *UO,
                           const MatchFinder::MatchResult &M,
                           LatticeTransferState &State) {
   // The DeclRefExpr refers to this variable in the operand.
   const auto *OperandVar = M.Nodes.getNodeAs<clang::VarDecl>(kVar);
   assert(OperandVar != nullptr);
-  const auto *OperandValue = State.Env.getValue(*OperandVar, SkipPast::None);
+  const auto *OperandValue = State.Env.getValue(*OperandVar);
   if (!OperandValue)
     return {nullptr, {}, {}};
 
   // Value of the unary op.
   auto *UnaryOpValue = State.Env.getValue(*UO, SkipPast::None);
   if (!UnaryOpValue) {
     auto &Loc = State.Env.createStorageLocation(*UO);
     State.Env.setStorageLocation(*UO, Loc);

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

 /// Requirements:
 ///
 ///   `Name` must be unique in `ASTCtx`.
 template <class ValueT>
 ValueT &getValueForDecl(ASTContext &ASTCtx, const Environment &Env,
                         llvm::StringRef Name) {
   const ValueDecl *VD = findValueDecl(ASTCtx, Name);
   assert(VD != nullptr);
-  return *cast<ValueT>(Env.getValue(*VD, SkipPast::None));
+  return *cast<ValueT>(Env.getValue(*VD));
 }
 
 /// Creates and owns constraints which are boolean values.
 class ConstraintContext {
 public:
   // Creates an atomic boolean value.
   BoolValue *atom() {
     Vals.push_back(std::make_unique<AtomicBoolValue>());

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
-        auto *FooValue = dyn_cast_or_null<PointerValue>(
-            Env.getValue(*FooDecl, SkipPast::None));
+        auto *FooValue = dyn_cast_or_null<PointerValue>(Env.getValue(*FooDecl));
         ASSERT_THAT(FooValue, NotNull());
 
         EXPECT_TRUE(isa<AggregateStorageLocation>(FooValue->getPointeeLoc()));
         auto *FooPointeeValue = Env.getValue(FooValue->getPointeeLoc());
         ASSERT_THAT(FooPointeeValue, NotNull());
         EXPECT_TRUE(isa<StructValue>(FooPointeeValue));
       });
 }
runDataflow(
         const auto *FooLoc =
             cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
         const auto *UnmodeledLoc = &FooLoc->getChild(*UnmodeledDecl);
         ASSERT_TRUE(isa<ScalarStorageLocation>(UnmodeledLoc));
         ASSERT_THAT(Env.getValue(*UnmodeledLoc), IsNull());
 
         const ValueDecl *ZabDecl = findValueDecl(ASTCtx, "Zab");
         ASSERT_THAT(ZabDecl, NotNull());
-        EXPECT_THAT(Env.getValue(*ZabDecl, SkipPast::None), NotNull());
+        EXPECT_THAT(Env.getValue(*ZabDecl), NotNull());
       });
 }
 
 TEST(TransferTest, StructVarDecl) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
+        const Value *FooVal = Env.getValue(*FooDecl);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
+        EXPECT_EQ(Env.getValue(*BarDecl), FooVal);
       });
 }
 
 TEST(TransferTest, VarDeclInitAssign) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar = Foo;
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
+        const Value *FooVal = Env.getValue(*FooDecl);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
+        EXPECT_EQ(Env.getValue(*BarDecl), FooVal);
       });
 }
 
 TEST(TransferTest, VarDeclInitAssignChained) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar;
       int Baz = (Bar = Foo);
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
+        const Value *FooVal = Env.getValue(*FooDecl);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
-        EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal);
+        EXPECT_EQ(Env.getValue(*BarDecl), FooVal);
+        EXPECT_EQ(Env.getValue(*BazDecl), FooVal);
       });
 }
 
 TEST(TransferTest, VarDeclInitAssignPtrDeref) {
   std::string Code = R"(
     void target() {
       int Foo;
       int *Bar;
       *(Bar) = Foo;
       int Baz = *(Bar);
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
+        const Value *FooVal = Env.getValue(*FooDecl);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *BarVal =
-            cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto *BarVal = cast<PointerValue>(Env.getValue(*BarDecl));
         EXPECT_EQ(Env.getValue(BarVal->getPointeeLoc()), FooVal);
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal);
+        EXPECT_EQ(Env.getValue(*BazDecl), FooVal);
       });
 }
 
 TEST(TransferTest, AssignToAndFromReference) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar;
runDataflow(
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const Value *FooVal = Env1.getValue(*FooDecl, SkipPast::None);
+        const Value *FooVal = Env1.getValue(*FooDecl);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const Value *BarVal = Env1.getValue(*BarDecl, SkipPast::None);
+        const Value *BarVal = Env1.getValue(*BarDecl);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        EXPECT_EQ(Env1.getValue(*BazDecl, SkipPast::Reference), FooVal);
+        EXPECT_EQ(Env1.getValue(*BazDecl), FooVal);
 
-        EXPECT_EQ(Env2.getValue(*BazDecl, SkipPast::Reference), BarVal);
-        EXPECT_EQ(Env2.getValue(*FooDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env2.getValue(*BazDecl), BarVal);
+        EXPECT_EQ(Env2.getValue(*FooDecl), BarVal);
 
         const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
         ASSERT_THAT(QuxDecl, NotNull());
-        EXPECT_EQ(Env2.getValue(*QuxDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env2.getValue(*QuxDecl), BarVal);
 
         const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
         ASSERT_THAT(QuuxDecl, NotNull());
-        EXPECT_EQ(Env2.getValue(*QuuxDecl, SkipPast::Reference), BarVal);
+        EXPECT_EQ(Env2.getValue(*QuuxDecl), BarVal);
       });
 }
 
 TEST(TransferTest, MultipleParamDecls) {
   std::string Code = R"(
     void target(int Foo, int Bar) {
       (void)0;
       // [[p]]
runDataflow(
         const auto *FooLoc =
             cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env.getValue(*BazDecl), BarVal);
       });
 }
 
 TEST(TransferTest, StructMemberEnum) {
   std::string Code = R"(
     struct A {
       int Bar;
       enum E { ONE, TWO };
runDataflow(
         const auto *FooLoc =
             cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env.getValue(*BazDecl), BarVal);
       });
 }
 
 TEST(TransferTest, BaseClassInitializer) {
   using ast_matchers::cxxConstructorDecl;
   using ast_matchers::hasName;
   using ast_matchers::ofClass;
 
runDataflow(
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<ReferenceValue>(FooVal->getChild(*BarDecl));
         const auto *BarReferentVal =
             cast<IntegerValue>(Env.getValue(BarVal->getReferentLoc()));
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), BarReferentVal);
+        EXPECT_EQ(Env.getValue(*BazDecl), BarReferentVal);
       });
 }
 
 TEST(TransferTest, StructThisMember) {
   std::string Code = R"(
     struct A {
       int Bar;
 
runDataflow(
             cast<ScalarStorageLocation>(&ThisLoc->getChild(*BarDecl));
         ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
 
         const Value *BarVal = Env.getValue(*BarLoc);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env.getValue(*FooDecl), BarVal);
 
         const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
         ASSERT_THAT(QuxDecl, NotNull());
 
         ASSERT_TRUE(QuxDecl->getType()->isStructureType());
         auto QuxFields = QuxDecl->getType()->getAsRecordDecl()->fields();
 
         FieldDecl *BazDecl = nullptr;
runDataflow(
 
         const auto *BazLoc =
             cast<ScalarStorageLocation>(&QuxLoc->getChild(*BazDecl));
         const auto *BazVal = cast<IntegerValue>(QuxVal->getChild(*BazDecl));
         EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
 
         const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
         ASSERT_THAT(QuuxDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*QuuxDecl, SkipPast::None), BazVal);
+        EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal);
       });
 }
 
 TEST(TransferTest, ClassThisMember) {
   std::string Code = R"(
     class A {
       int Bar;
 
runDataflow(
             cast<ScalarStorageLocation>(&ThisLoc->getChild(*BarDecl));
         ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
 
         const Value *BarVal = Env.getValue(*BarLoc);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env.getValue(*FooDecl), BarVal);
 
         const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
         ASSERT_THAT(QuxDecl, NotNull());
 
         ASSERT_TRUE(QuxDecl->getType()->isClassType());
         auto QuxFields = QuxDecl->getType()->getAsRecordDecl()->fields();
 
         FieldDecl *BazDecl = nullptr;
runDataflow(
 
         const auto *BazLoc =
             cast<ScalarStorageLocation>(&QuxLoc->getChild(*BazDecl));
         const auto *BazVal = cast<IntegerValue>(QuxVal->getChild(*BazDecl));
         EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
 
         const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
         ASSERT_THAT(QuuxDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*QuuxDecl, SkipPast::None), BazVal);
+        EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal);
       });
 }
 
 TEST(TransferTest, UnionThisMember) {
   std::string Code = R"(
     union A {
       int Foo;
       int Bar;
runDataflow(
             cast<ScalarStorageLocation>(&ThisLoc->getChild(*BarDecl));
         ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
 
         const Value *BarVal = Env.getValue(*BarLoc);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env.getValue(*FooDecl), BarVal);
       },
       LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator()");
 
   std::string RefCaptureDefaultCode = R"(
     struct A {
       void frob() {
         [&]() {
           int Foo = Bar;
runDataflow(
             cast<ScalarStorageLocation>(&ThisLoc->getChild(*BarDecl));
         ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
 
         const Value *BarVal = Env.getValue(*BarLoc);
         ASSERT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), BarVal);
+        EXPECT_EQ(Env.getValue(*FooDecl), BarVal);
       },
       LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator()");
 
   std::string FreeFunctionLambdaCode = R"(
     void foo() {
       int Bar;
       [&]() {
         int Foo = Bar;
runDataflow(
 
         const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
             Env.getThisPointeeStorageLocation());
         ASSERT_THAT(ThisLoc, NotNull());
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const auto *FooVal =
-            cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None));
+        const auto *FooVal = cast<IntegerValue>(Env.getValue(*FooDecl));
 
         const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
         ASSERT_THAT(QuxDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal);
+        EXPECT_EQ(Env.getValue(*QuxDecl), FooVal);
       });
 }
 
 TEST(TransferTest, DefaultInitializer) {
   std::string Code = R"(
     struct target {
       int Bar;
       int Baz = Bar;
runDataflow(
 
         const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
             Env.getThisPointeeStorageLocation());
         ASSERT_THAT(ThisLoc, NotNull());
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const auto *FooVal =
-            cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None));
+        const auto *FooVal = cast<IntegerValue>(Env.getValue(*FooDecl));
 
         const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
         ASSERT_THAT(QuxDecl, NotNull());
-        EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal);
+        EXPECT_EQ(Env.getValue(*QuxDecl), FooVal);
       });
 }
 
 TEST(TransferTest, DefaultInitializerReference) {
   std::string Code = R"(
     struct target {
       int &Bar;
       int &Baz = Bar;
runDataflow(
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        const auto &FooVal =
-            *cast<StructValue>(Env.getValue(*FooDecl, SkipPast::None));
-        const auto *BarVal =
-            cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto &FooVal = *cast<StructValue>(Env.getValue(*FooDecl));
+        const auto *BarVal = cast<IntegerValue>(Env.getValue(*BarDecl));
         EXPECT_EQ(BarVal, FooVal.getChild(*BazDecl));
       });
 }
 
 TEST(TransferTest, StaticCast) {
   std::string Code = R"(
     void target(int Foo) {
       int Bar = static_cast<int>(Foo);
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
-        const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
+        const auto *FooVal = Env.getValue(*FooDecl);
+        const auto *BarVal = Env.getValue(*BarDecl);
         EXPECT_TRUE(isa<IntegerValue>(FooVal));
         EXPECT_TRUE(isa<IntegerValue>(BarVal));
         EXPECT_EQ(FooVal, BarVal);
       });
 }
 
 TEST(TransferTest, IntegralCast) {
   std::string Code = R"(
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
-        const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
+        const auto *FooVal = Env.getValue(*FooDecl);
+        const auto *BarVal = Env.getValue(*BarDecl);
         EXPECT_TRUE(isa<IntegerValue>(FooVal));
         EXPECT_TRUE(isa<IntegerValue>(BarVal));
         EXPECT_EQ(FooVal, BarVal);
       });
 }
 
 TEST(TransferTest, IntegraltoBooleanCast) {
   std::string Code = R"(
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
-        const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
+        const auto *FooVal = Env.getValue(*FooDecl);
+        const auto *BarVal = Env.getValue(*BarDecl);
         EXPECT_TRUE(isa<IntegerValue>(FooVal));
         EXPECT_TRUE(isa<BoolValue>(BarVal));
       });
 }
 
 TEST(TransferTest, IntegralToBooleanCastFromBool) {
   std::string Code = R"(
     void target(bool Foo) {
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
-        const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
+        const auto *FooVal = Env.getValue(*FooDecl);
+        const auto *BarVal = Env.getValue(*BarDecl);
         EXPECT_TRUE(isa<BoolValue>(FooVal));
         EXPECT_TRUE(isa<BoolValue>(BarVal));
         EXPECT_EQ(FooVal, BarVal);
       });
 }
 
 TEST(TransferTest, NullToPointerCast) {
   std::string Code = R"(
runDataflow(
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
         const ValueDecl *NullDecl = findValueDecl(ASTCtx, "Null");
         ASSERT_THAT(NullDecl, NotNull());
 
-        const auto *FooXVal =
-            cast<PointerValue>(Env.getValue(*FooXDecl, SkipPast::None));
-        const auto *FooYVal =
-            cast<PointerValue>(Env.getValue(*FooYDecl, SkipPast::None));
-        const auto *BarVal =
-            cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
-        const auto *BazVal =
-            cast<PointerValue>(Env.getValue(*BazDecl, SkipPast::None));
-        const auto *NullVal =
-            cast<PointerValue>(Env.getValue(*NullDecl, SkipPast::None));
+        const auto *FooXVal = cast<PointerValue>(Env.getValue(*FooXDecl));
+        const auto *FooYVal = cast<PointerValue>(Env.getValue(*FooYDecl));
+        const auto *BarVal = cast<PointerValue>(Env.getValue(*BarDecl));
+        const auto *BazVal = cast<PointerValue>(Env.getValue(*BazDecl));
+        const auto *NullVal = cast<PointerValue>(Env.getValue(*NullDecl));
 
         EXPECT_EQ(FooXVal, FooYVal);
         EXPECT_NE(FooXVal, BarVal);
         EXPECT_NE(FooXVal, BazVal);
         EXPECT_NE(BarVal, BazVal);
 
         const StorageLocation &FooPointeeLoc = FooXVal->getPointeeLoc();
         EXPECT_TRUE(isa<ScalarStorageLocation>(FooPointeeLoc));
runDataflow(
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *MemberPointerDecl =
             findValueDecl(ASTCtx, "MemberPointer");
         ASSERT_THAT(MemberPointerDecl, NotNull());
 
-        const auto *MemberPointerVal = cast<PointerValue>(
-            Env.getValue(*MemberPointerDecl, SkipPast::None));
+        const auto *MemberPointerVal =
+            cast<PointerValue>(Env.getValue(*MemberPointerDecl));
 
         const StorageLocation &MemberLoc = MemberPointerVal->getPointeeLoc();
         EXPECT_THAT(Env.getValue(MemberLoc), IsNull());
       });
 }
 
 TEST(TransferTest, AddrOfValue) {
   std::string Code = R"(
runDataflow(
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const auto *FooLoc =
             cast<ScalarStorageLocation>(Env.getStorageLocation(*FooDecl));
-        const auto *BarVal =
-            cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto *BarVal = cast<PointerValue>(Env.getValue(*BarDecl));
         EXPECT_EQ(&BarVal->getPointeeLoc(), FooLoc);
       });
 }
 
 TEST(TransferTest, AddrOfReference) {
   std::string Code = R"(
     void target(int *Foo) {
       int *Bar = &(*Foo);
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *FooVal =
-            cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None));
-        const auto *BarVal =
-            cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto *FooVal = cast<PointerValue>(Env.getValue(*FooDecl));
+        const auto *BarVal = cast<PointerValue>(Env.getValue(*BarDecl));
         EXPECT_EQ(&BarVal->getPointeeLoc(), &FooVal->getPointeeLoc());
       });
 }
 
 TEST(TransferTest, DerefDependentPtr) {
   std::string Code = R"(
     template <typename T>
     void target(T *Foo) {
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *FooVal =
-            cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None));
+        const auto *FooVal = cast<PointerValue>(Env.getValue(*FooDecl));
         const auto *BarLoc = Env.getStorageLocation(*BarDecl);
         EXPECT_EQ(BarLoc, &FooVal->getPointeeLoc());
       });
 }
 
 TEST(TransferTest, VarDeclInitAssignConditionalOperator) {
   std::string Code = R"(
     struct A {};
runDataflow(
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        const auto *FooVal =
-            cast<StructValue>(Env.getValue(*FooDecl, SkipPast::None));
-        const auto *BarVal =
-            cast<StructValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto *FooVal = cast<StructValue>(Env.getValue(*FooDecl));
+        const auto *BarVal = cast<StructValue>(Env.getValue(*BarDecl));
 
-        const auto *BazVal =
-            dyn_cast<StructValue>(Env.getValue(*BazDecl, SkipPast::None));
+        const auto *BazVal = dyn_cast<StructValue>(Env.getValue(*BazDecl));
         ASSERT_THAT(BazVal, NotNull());
 
         EXPECT_NE(BazVal, FooVal);
         EXPECT_NE(BazVal, BarVal);
       });
 }
 
 TEST(TransferTest, VarDeclInDoWhile) {
runDataflow(
           ASSERT_THAT(BarArgDecl, NotNull());
 
           const ValueDecl *QuxArgDecl = findValueDecl(ASTCtx, "QuxArg");
           ASSERT_THAT(QuxArgDecl, NotNull());
 
           const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
           ASSERT_THAT(QuuxDecl, NotNull());
 
-          const auto *FooArgVal =
-              cast<IntegerValue>(Env.getValue(*FooArgDecl, SkipPast::None));
-          const auto *BarArgVal =
-              cast<IntegerValue>(Env.getValue(*BarArgDecl, SkipPast::None));
-          const auto *QuxArgVal =
-              cast<IntegerValue>(Env.getValue(*QuxArgDecl, SkipPast::None));
+          const auto *FooArgVal = cast<IntegerValue>(Env.getValue(*FooArgDecl));
+          const auto *BarArgVal = cast<IntegerValue>(Env.getValue(*BarArgDecl));
+          const auto *QuxArgVal = cast<IntegerValue>(Env.getValue(*QuxArgDecl));
 
-          const auto *QuuxVal =
-              cast<StructValue>(Env.getValue(*QuuxDecl, SkipPast::None));
+          const auto *QuuxVal = cast<StructValue>(Env.getValue(*QuuxDecl));
           ASSERT_THAT(QuuxVal, NotNull());
 
           const auto *BazVal = cast<StructValue>(QuuxVal->getChild(*BazDecl));
           ASSERT_THAT(BazVal, NotNull());
 
           EXPECT_EQ(QuuxVal->getChild(*BarDecl), BarArgVal);
           EXPECT_EQ(BazVal->getChild(*FooDecl), FooArgVal);
           EXPECT_EQ(QuuxVal->getChild(*QuxDecl), QuxArgVal);
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const auto *FooVal = dyn_cast_or_null<AtomicBoolValue>(
-            Env.getValue(*FooDecl, SkipPast::None));
+        const auto *FooVal =
+            dyn_cast_or_null<AtomicBoolValue>(Env.getValue(*FooDecl));
         ASSERT_THAT(FooVal, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *BarVal = dyn_cast_or_null<AtomicBoolValue>(
-            Env.getValue(*BarDecl, SkipPast::None));
+        const auto *BarVal =
+            dyn_cast_or_null<AtomicBoolValue>(Env.getValue(*BarDecl));
         ASSERT_THAT(BarVal, NotNull());
 
         EXPECT_EQ(FooVal, &Env.getBoolLiteralValue(true));
         EXPECT_EQ(BarVal, &Env.getBoolLiteralValue(false));
       });
 }
 
 TEST(TransferTest, AssignFromCompositeBoolExpression) {
runDataflow(
         [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
            ASTContext &ASTCtx) {
           ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
           const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
           const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
           ASSERT_THAT(FooDecl, NotNull());
 
-          const auto *FooVal = dyn_cast_or_null<BoolValue>(
-              Env.getValue(*FooDecl, SkipPast::None));
+          const auto *FooVal =
+              dyn_cast_or_null<BoolValue>(Env.getValue(*FooDecl));
           ASSERT_THAT(FooVal, NotNull());
 
           const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
           ASSERT_THAT(BarDecl, NotNull());
 
-          const auto *BarVal = dyn_cast_or_null<BoolValue>(
-              Env.getValue(*BarDecl, SkipPast::None));
+          const auto *BarVal =
+              dyn_cast_or_null<BoolValue>(Env.getValue(*BarDecl));
           ASSERT_THAT(BarVal, NotNull());
 
           const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
           ASSERT_THAT(QuxDecl, NotNull());
 
-          const auto *QuxVal = dyn_cast_or_null<BoolValue>(
-              Env.getValue(*QuxDecl, SkipPast::None));
+          const auto *QuxVal =
+              dyn_cast_or_null<BoolValue>(Env.getValue(*QuxDecl));
           ASSERT_THAT(QuxVal, NotNull());
 
           const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
           ASSERT_THAT(BazDecl, NotNull());
 
-          const auto *BazVal = dyn_cast_or_null<ConjunctionValue>(
-              Env.getValue(*BazDecl, SkipPast::None));
+          const auto *BazVal =
+              dyn_cast_or_null<ConjunctionValue>(Env.getValue(*BazDecl));
           ASSERT_THAT(BazVal, NotNull());
           EXPECT_EQ(&BazVal->getLeftSubValue(), FooVal);
 
           const auto *BazRightSubValVal =
               cast<DisjunctionValue>(&BazVal->getRightSubValue());
           EXPECT_EQ(&BazRightSubValVal->getLeftSubValue(), BarVal);
           EXPECT_EQ(&BazRightSubValVal->getRightSubValue(), QuxVal);
         });
runDataflow(
         [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
            ASTContext &ASTCtx) {
           ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
           const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
           const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
           ASSERT_THAT(FooDecl, NotNull());
 
-          const auto *FooVal = dyn_cast_or_null<BoolValue>(
-              Env.getValue(*FooDecl, SkipPast::None));
+          const auto *FooVal =
+              dyn_cast_or_null<BoolValue>(Env.getValue(*FooDecl));
           ASSERT_THAT(FooVal, NotNull());
 
           const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
           ASSERT_THAT(BarDecl, NotNull());
 
-          const auto *BarVal = dyn_cast_or_null<BoolValue>(
-              Env.getValue(*BarDecl, SkipPast::None));
+          const auto *BarVal =
+              dyn_cast_or_null<BoolValue>(Env.getValue(*BarDecl));
           ASSERT_THAT(BarVal, NotNull());
 
           const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
           ASSERT_THAT(QuxDecl, NotNull());
 
-          const auto *QuxVal = dyn_cast_or_null<BoolValue>(
-              Env.getValue(*QuxDecl, SkipPast::None));
+          const auto *QuxVal =
+              dyn_cast_or_null<BoolValue>(Env.getValue(*QuxDecl));
           ASSERT_THAT(QuxVal, NotNull());
 
           const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
           ASSERT_THAT(BazDecl, NotNull());
 
-          const auto *BazVal = dyn_cast_or_null<DisjunctionValue>(
-              Env.getValue(*BazDecl, SkipPast::None));
+          const auto *BazVal =
+              dyn_cast_or_null<DisjunctionValue>(Env.getValue(*BazDecl));
           ASSERT_THAT(BazVal, NotNull());
 
           const auto *BazLeftSubValVal =
               cast<ConjunctionValue>(&BazVal->getLeftSubValue());
           EXPECT_EQ(&BazLeftSubValVal->getLeftSubValue(), FooVal);
           EXPECT_EQ(&BazLeftSubValVal->getRightSubValue(), QuxVal);
 
           EXPECT_EQ(&BazVal->getRightSubValue(), BarVal);
runDataflow(
         [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
            ASTContext &ASTCtx) {
           ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
           const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
           const ValueDecl *ADecl = findValueDecl(ASTCtx, "A");
           ASSERT_THAT(ADecl, NotNull());
 
-          const auto *AVal =
-              dyn_cast_or_null<BoolValue>(Env.getValue(*ADecl, SkipPast::None));
+          const auto *AVal = dyn_cast_or_null<BoolValue>(Env.getValue(*ADecl));
           ASSERT_THAT(AVal, NotNull());
 
           const ValueDecl *BDecl = findValueDecl(ASTCtx, "B");
           ASSERT_THAT(BDecl, NotNull());
 
-          const auto *BVal =
-              dyn_cast_or_null<BoolValue>(Env.getValue(*BDecl, SkipPast::None));
+          const auto *BVal = dyn_cast_or_null<BoolValue>(Env.getValue(*BDecl));
           ASSERT_THAT(BVal, NotNull());
 
           const ValueDecl *CDecl = findValueDecl(ASTCtx, "C");
           ASSERT_THAT(CDecl, NotNull());
 
-          const auto *CVal =
-              dyn_cast_or_null<BoolValue>(Env.getValue(*CDecl, SkipPast::None));
+          const auto *CVal = dyn_cast_or_null<BoolValue>(Env.getValue(*CDecl));
           ASSERT_THAT(CVal, NotNull());
 
           const ValueDecl *DDecl = findValueDecl(ASTCtx, "D");
           ASSERT_THAT(DDecl, NotNull());
 
-          const auto *DVal =
-              dyn_cast_or_null<BoolValue>(Env.getValue(*DDecl, SkipPast::None));
+          const auto *DVal = dyn_cast_or_null<BoolValue>(Env.getValue(*DDecl));
           ASSERT_THAT(DVal, NotNull());
 
           const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
           ASSERT_THAT(FooDecl, NotNull());
 
-          const auto *FooVal = dyn_cast_or_null<ConjunctionValue>(
-              Env.getValue(*FooDecl, SkipPast::None));
+          const auto *FooVal =
+              dyn_cast_or_null<ConjunctionValue>(Env.getValue(*FooDecl));
           ASSERT_THAT(FooVal, NotNull());
 
           const auto &FooLeftSubVal =
               cast<ConjunctionValue>(FooVal->getLeftSubValue());
           const auto &FooLeftLeftSubVal =
               cast<ConjunctionValue>(FooLeftSubVal.getLeftSubValue());
           EXPECT_EQ(&FooLeftLeftSubVal.getLeftSubValue(), AVal);
           EXPECT_EQ(&FooLeftLeftSubVal.getRightSubValue(), BVal);
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const auto *FooVal = dyn_cast_or_null<AtomicBoolValue>(
-            Env.getValue(*FooDecl, SkipPast::None));
+        const auto *FooVal =
+            dyn_cast_or_null<AtomicBoolValue>(Env.getValue(*FooDecl));
         ASSERT_THAT(FooVal, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        const auto *BarVal = dyn_cast_or_null<NegationValue>(
-            Env.getValue(*BarDecl, SkipPast::None));
+        const auto *BarVal =
+            dyn_cast_or_null<NegationValue>(Env.getValue(*BarDecl));
         ASSERT_THAT(BarVal, NotNull());
 
         EXPECT_EQ(&BarVal->getSubVal(), FooVal);
       });
 }
 
 TEST(TransferTest, BuiltinExpect) {
   std::string Code = R"(
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
-                  Env.getValue(*BarDecl, SkipPast::None));
+        EXPECT_EQ(Env.getValue(*FooDecl), Env.getValue(*BarDecl));
       });
 }
 
 // `__builtin_expect` takes and returns a `long` argument, so other types
 // involve casts. This verifies that we identify the input and output in that
 // case.
 TEST(TransferTest, BuiltinExpectBoolArg) {
   std::string Code = R"(
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
-                  Env.getValue(*BarDecl, SkipPast::None));
+        EXPECT_EQ(Env.getValue(*FooDecl), Env.getValue(*BarDecl));
       });
 }
 
 TEST(TransferTest, BuiltinUnreachable) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = false;
       if (Foo)
runDataflow(
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         // `__builtin_unreachable` promises that the code is
         // unreachable, so the compiler treats the "then" branch as the
         // only possible predecessor of this statement.
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
-                  Env.getValue(*BarDecl, SkipPast::None));
+        EXPECT_EQ(Env.getValue(*FooDecl), Env.getValue(*BarDecl));
       });
 }
 
 TEST(TransferTest, BuiltinTrap) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = false;
       if (Foo)
runDataflow(
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         // `__builtin_trap` ensures program termination, so only the
         // "then" branch is a predecessor of this statement.
-        EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
-                  Env.getValue(*BarDecl, SkipPast::None));
+        EXPECT_EQ(Env.getValue(*FooDecl), Env.getValue(*BarDecl));
       });
 }
 
 TEST(TransferTest, BuiltinDebugTrap) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = false;
       if (Foo)
runDataflow(
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         // `__builtin_debugtrap` doesn't ensure program termination.
-        EXPECT_NE(Env.getValue(*FooDecl, SkipPast::None),
-                  Env.getValue(*BarDecl, SkipPast::None));
+        EXPECT_NE(Env.getValue(*FooDecl), Env.getValue(*BarDecl));
       });
 }
 
 TEST(TransferTest, StaticIntSingleVarDecl) {
   std::string Code = R"(
     void target() {
       static int Foo;
       // [[p]]
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        const Value *BarVal =
-            cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
-        const Value *BazVal =
-            cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
+        const Value *BarVal = cast<IntegerValue>(Env.getValue(*BarDecl));
+        const Value *BazVal = cast<IntegerValue>(Env.getValue(*BazDecl));
         EXPECT_EQ(BarVal, BazVal);
       });
 }
 
 TEST(TransferTest, StaticMemberIntVarDecl) {
   std::string Code = R"(
     struct A {
       static int Foo;
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        const Value *BarVal =
-            cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
-        const Value *BazVal =
-            cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
+        const Value *BarVal = cast<IntegerValue>(Env.getValue(*BarDecl));
+        const Value *BazVal = cast<IntegerValue>(Env.getValue(*BazDecl));
         EXPECT_EQ(BarVal, BazVal);
       });
 }
 
 TEST(TransferTest, StaticMemberRefVarDecl) {
   std::string Code = R"(
     struct A {
       static int &Foo;
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        const Value *BarVal =
-            cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
-        const Value *BazVal =
-            cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
+        const Value *BarVal = cast<IntegerValue>(Env.getValue(*BarDecl));
+        const Value *BazVal = cast<IntegerValue>(Env.getValue(*BazDecl));
         EXPECT_EQ(BarVal, BazVal);
       });
 }
 
 TEST(TransferTest, AssignMemberBeforeCopy) {
   std::string Code = R"(
     struct A {
       int Foo;
runDataflow(
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *A1Decl = findValueDecl(ASTCtx, "A1");
         ASSERT_THAT(A1Decl, NotNull());
 
         const ValueDecl *A2Decl = findValueDecl(ASTCtx, "A2");
         ASSERT_THAT(A2Decl, NotNull());
 
-        const auto *BarVal =
-            cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto *BarVal = cast<IntegerValue>(Env.getValue(*BarDecl));
 
-        const auto *A2Val =
-            cast<StructValue>(Env.getValue(*A2Decl, SkipPast::None));
+        const auto *A2Val = cast<StructValue>(Env.getValue(*A2Decl));
         EXPECT_EQ(A2Val->getChild(*FooDecl), BarVal);
       });
 }
 
 TEST(TransferTest, BooleanEquality) {
   std::string Code = R"(
     void target(bool Bar) {
       bool Foo = true;
runDataflow(
         const Environment &EnvThen =
             getEnvironmentAtAnnotation(Results, "p-then");
         const Environment &EnvElse =
             getEnvironmentAtAnnotation(Results, "p-else");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarValThen =
-            *cast<BoolValue>(EnvThen.getValue(*BarDecl, SkipPast::None));
+        auto &BarValThen = *cast<BoolValue>(EnvThen.getValue(*BarDecl));
         EXPECT_TRUE(EnvThen.flowConditionImplies(BarValThen));
 
-        auto &BarValElse =
-            *cast<BoolValue>(EnvElse.getValue(*BarDecl, SkipPast::None));
+        auto &BarValElse = *cast<BoolValue>(EnvElse.getValue(*BarDecl));
         EXPECT_FALSE(EnvElse.flowConditionImplies(BarValElse));
       });
 }
 
 TEST(TransferTest, BooleanInequality) {
   std::string Code = R"(
     void target(bool Bar) {
       bool Foo = true;
runDataflow(
         const Environment &EnvThen =
             getEnvironmentAtAnnotation(Results, "p-then");
         const Environment &EnvElse =
             getEnvironmentAtAnnotation(Results, "p-else");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarValThen =
-            *cast<BoolValue>(EnvThen.getValue(*BarDecl, SkipPast::None));
+        auto &BarValThen = *cast<BoolValue>(EnvThen.getValue(*BarDecl));
         EXPECT_FALSE(EnvThen.flowConditionImplies(BarValThen));
 
-        auto &BarValElse =
-            *cast<BoolValue>(EnvElse.getValue(*BarDecl, SkipPast::None));
+        auto &BarValElse = *cast<BoolValue>(EnvElse.getValue(*BarDecl));
         EXPECT_TRUE(EnvElse.flowConditionImplies(BarValElse));
       });
 }
 
 TEST(TransferTest, CorrelatedBranches) {
   std::string Code = R"(
     void target(bool B, bool C) {
       if (B) {
runDataflow(
 
         const ValueDecl *CDecl = findValueDecl(ASTCtx, "C");
         ASSERT_THAT(CDecl, NotNull());
 
         {
           const Environment &Env = getEnvironmentAtAnnotation(Results, "p0");
           const ValueDecl *BDecl = findValueDecl(ASTCtx, "B");
           ASSERT_THAT(BDecl, NotNull());
-          auto &BVal = *cast<BoolValue>(Env.getValue(*BDecl, SkipPast::None));
+          auto &BVal = *cast<BoolValue>(Env.getValue(*BDecl));
 
           EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BVal)));
         }
 
         {
           const Environment &Env = getEnvironmentAtAnnotation(Results, "p1");
-          auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None));
+          auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl));
           EXPECT_TRUE(Env.flowConditionImplies(CVal));
         }
 
         {
           const Environment &Env = getEnvironmentAtAnnotation(Results, "p2");
-          auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None));
+          auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl));
           EXPECT_TRUE(Env.flowConditionImplies(CVal));
         }
       });
 }
 
 TEST(TransferTest, LoopWithAssignmentConverges) {
   std::string Code = R"(
     bool foo();
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
       });
 }
 
 TEST(TransferTest, LoopWithStagedAssignments) {
   std::string Code = R"(
     bool foo();
 
runDataflow(
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
         const ValueDecl *ErrDecl = findValueDecl(ASTCtx, "Err");
         ASSERT_THAT(ErrDecl, NotNull());
 
-        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
-        auto &ErrVal = *cast<BoolValue>(Env.getValue(*ErrDecl, SkipPast::None));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
+        auto &ErrVal = *cast<BoolValue>(Env.getValue(*ErrDecl));
         EXPECT_TRUE(Env.flowConditionImplies(BarVal));
         // An unsound analysis, for example only evaluating the loop once, can
         // conclude that `Err` is false. So, we test that this conclusion is not
         // reached.
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(ErrVal)));
       });
 }
 
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarVal =
-            *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
       });
 }
 
 TEST(TransferTest, LoopWithStructReferenceAssignmentConverges) {
   std::string Code = R"(
     struct Lookup {
       int x;
runDataflow(
 
         const ValueDecl *ValDecl = findValueDecl(ASTCtx, "val");
         ASSERT_THAT(ValDecl, NotNull());
 
         const ValueDecl *LDecl = findValueDecl(ASTCtx, "l");
         ASSERT_THAT(LDecl, NotNull());
 
         // Inner.
-        auto *LVal =
-            dyn_cast<PointerValue>(InnerEnv.getValue(*LDecl, SkipPast::None));
+        auto *LVal = dyn_cast<PointerValue>(InnerEnv.getValue(*LDecl));
         ASSERT_THAT(LVal, NotNull());
 
         EXPECT_EQ(&LVal->getPointeeLoc(),
                   InnerEnv.getStorageLocation(*ValDecl));
 
         // Outer.
-        LVal =
-            dyn_cast<PointerValue>(OuterEnv.getValue(*LDecl, SkipPast::None));
+        LVal = dyn_cast<PointerValue>(OuterEnv.getValue(*LDecl));
         ASSERT_THAT(LVal, NotNull());
 
         // The loop body may not have been executed, so we should not conclude
         // that `l` points to `val`.
         EXPECT_NE(&LVal->getPointeeLoc(),
                   OuterEnv.getStorageLocation(*ValDecl));
       });
 }
runDataflow(
         ASSERT_THAT(BoundBarRefDecl, NotNull());
 
         const StorageLocation *FooRefLoc = Env.getStorageLocation(*FooRefDecl);
         ASSERT_THAT(FooRefLoc, NotNull());
 
         const StorageLocation *BarRefLoc = Env.getStorageLocation(*BarRefDecl);
         ASSERT_THAT(BarRefLoc, NotNull());
 
-        const Value *QuxVal = Env.getValue(*QuxDecl, SkipPast::None);
+        const Value *QuxVal = Env.getValue(*QuxDecl);
         ASSERT_THAT(QuxVal, NotNull());
 
         const StorageLocation *BoundFooRefLoc =
             Env.getStorageLocation(*BoundFooRefDecl);
         EXPECT_EQ(BoundFooRefLoc, FooRefLoc);
 
         const StorageLocation *BoundBarRefLoc =
             Env.getStorageLocation(*BoundBarRefDecl);
         EXPECT_EQ(BoundBarRefLoc, BarRefLoc);
 
-        EXPECT_EQ(Env.getValue(*BoundFooRefDecl, SkipPast::Reference), QuxVal);
+        EXPECT_EQ(Env.getValue(*BoundFooRefDecl), QuxVal);
       });
 }
 
 TEST(TransferTest, StructuredBindingAssignFromStructRefMembersToRefs) {
   std::string Code = R"(
     struct A {
       int &Foo;
       int &Bar;
runDataflow(
         ASSERT_THAT(BoundBarRefDecl, NotNull());
 
         const StorageLocation *FooRefLoc = Env.getStorageLocation(*FooRefDecl);
         ASSERT_THAT(FooRefLoc, NotNull());
 
         const StorageLocation *BarRefLoc = Env.getStorageLocation(*BarRefDecl);
         ASSERT_THAT(BarRefLoc, NotNull());
 
-        const Value *QuxVal = Env.getValue(*QuxDecl, SkipPast::None);
+        const Value *QuxVal = Env.getValue(*QuxDecl);
         ASSERT_THAT(QuxVal, NotNull());
 
         const StorageLocation *BoundFooRefLoc =
             Env.getStorageLocation(*BoundFooRefDecl);
         EXPECT_EQ(BoundFooRefLoc, FooRefLoc);
 
         const StorageLocation *BoundBarRefLoc =
             Env.getStorageLocation(*BoundBarRefDecl);
         EXPECT_EQ(BoundBarRefLoc, BarRefLoc);
 
-        EXPECT_EQ(Env.getValue(*BoundFooRefDecl, SkipPast::Reference), QuxVal);
+        EXPECT_EQ(Env.getValue(*BoundFooRefDecl), QuxVal);
       });
 }
 
 TEST(TransferTest, StructuredBindingAssignFromStructIntMembersToInts) {
   std::string Code = R"(
     struct A {
       int Foo;
       int Bar;
runDataflow(
         ASSERT_THAT(QuxDecl, NotNull());
 
         const StorageLocation *FooRefLoc = Env.getStorageLocation(*FooRefDecl);
         ASSERT_THAT(FooRefLoc, NotNull());
 
         const StorageLocation *BarRefLoc = Env.getStorageLocation(*BarRefDecl);
         ASSERT_THAT(BarRefLoc, NotNull());
 
-        const Value *QuxVal = Env.getValue(*QuxDecl, SkipPast::None);
+        const Value *QuxVal = Env.getValue(*QuxDecl);
         ASSERT_THAT(QuxVal, NotNull());
 
         const StorageLocation *BoundFooLoc =
             Env.getStorageLocation(*BoundFooDecl);
         EXPECT_NE(BoundFooLoc, FooRefLoc);
 
         const StorageLocation *BoundBarLoc =
             Env.getStorageLocation(*BoundBarDecl);
         EXPECT_NE(BoundBarLoc, BarRefLoc);
 
-        EXPECT_EQ(Env.getValue(*BoundFooDecl, SkipPast::Reference), QuxVal);
+        EXPECT_EQ(Env.getValue(*BoundFooDecl), QuxVal);
       });
 }
 
 TEST(TransferTest, StructuredBindingAssignFromTupleLikeType) {
   std::string Code = R"(
     namespace std {
     using size_t = int;
     template <class> struct tuple_size;
runDataflow(
         const ValueDecl *BoundBarDecl = findValueDecl(ASTCtx, "BoundBar");
         ASSERT_THAT(BoundBarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
         // BindingDecls always map to references -- either lvalue or rvalue, so
         // we still need to skip here.
-        const Value *BoundFooValue =
-            Env1.getValue(*BoundFooDecl, SkipPast::Reference);
+        const Value *BoundFooValue = Env1.getValue(*BoundFooDecl);
         ASSERT_THAT(BoundFooValue, NotNull());
         EXPECT_TRUE(isa<BoolValue>(BoundFooValue));
 
-        const Value *BoundBarValue =
-            Env1.getValue(*BoundBarDecl, SkipPast::Reference);
+        const Value *BoundBarValue = Env1.getValue(*BoundBarDecl);
         ASSERT_THAT(BoundBarValue, NotNull());
         EXPECT_TRUE(isa<IntegerValue>(BoundBarValue));
 
         // Test that a `DeclRefExpr` to a `BindingDecl` works as expected.
-        EXPECT_EQ(Env1.getValue(*BazDecl, SkipPast::None), BoundFooValue);
+        EXPECT_EQ(Env1.getValue(*BazDecl), BoundFooValue);
 
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         // Test that `BoundFooDecl` retains the value we expect, after the join.
-        BoundFooValue = Env2.getValue(*BoundFooDecl, SkipPast::Reference);
-        EXPECT_EQ(Env2.getValue(*BazDecl, SkipPast::None), BoundFooValue);
+        BoundFooValue = Env2.getValue(*BoundFooDecl);
+        EXPECT_EQ(Env2.getValue(*BazDecl), BoundFooValue);
       });
 }
 
 TEST(TransferTest, StructuredBindingAssignRefFromTupleLikeType) {
   std::string Code = R"(
     namespace std {
     using size_t = int;
     template <class> struct tuple_size;
runDataflow(
         ASSERT_THAT(BoundFooDecl, NotNull());
 
         const ValueDecl *BoundBarDecl = findValueDecl(ASTCtx, "BoundBar");
         ASSERT_THAT(BoundBarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        const Value *BoundFooValue =
-            Env1.getValue(*BoundFooDecl, SkipPast::Reference);
+        const Value *BoundFooValue = Env1.getValue(*BoundFooDecl);
         ASSERT_THAT(BoundFooValue, NotNull());
         EXPECT_TRUE(isa<BoolValue>(BoundFooValue));
 
-        const Value *BoundBarValue =
-            Env1.getValue(*BoundBarDecl, SkipPast::Reference);
+        const Value *BoundBarValue = Env1.getValue(*BoundBarDecl);
         ASSERT_THAT(BoundBarValue, NotNull());
         EXPECT_TRUE(isa<IntegerValue>(BoundBarValue));
 
         // Test that a `DeclRefExpr` to a `BindingDecl` (with reference type)
         // works as expected. We don't test aliasing properties of the
         // reference, because we don't model `std::get` and so have no way to
         // equate separate references into the tuple.
-        EXPECT_EQ(Env1.getValue(*BazDecl, SkipPast::None), BoundFooValue);
+        EXPECT_EQ(Env1.getValue(*BazDecl), BoundFooValue);
 
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         // Test that `BoundFooDecl` retains the value we expect, after the join.
-        BoundFooValue = Env2.getValue(*BoundFooDecl, SkipPast::Reference);
-        EXPECT_EQ(Env2.getValue(*BazDecl, SkipPast::None), BoundFooValue);
+        BoundFooValue = Env2.getValue(*BoundFooDecl);
+        EXPECT_EQ(Env2.getValue(*BazDecl), BoundFooValue);
       });
 }
 
 TEST(TransferTest, BinaryOperatorComma) {
   std::string Code = R"(
     void target(int Foo, int Bar) {
       int &Baz = (Foo, Bar);
       // [[p]]
runDataflow(
         const Environment &ThenEnv =
             getEnvironmentAtAnnotation(Results, "if_then");
         const Environment &ElseEnv =
             getEnvironmentAtAnnotation(Results, "if_else");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        BoolValue &ThenFooVal =
-            *cast<BoolValue>(ThenEnv.getValue(*FooDecl, SkipPast::None));
+        BoolValue &ThenFooVal = *cast<BoolValue>(ThenEnv.getValue(*FooDecl));
         EXPECT_TRUE(ThenEnv.flowConditionImplies(ThenFooVal));
 
-        BoolValue &ElseFooVal =
-            *cast<BoolValue>(ElseEnv.getValue(*FooDecl, SkipPast::None));
+        BoolValue &ElseFooVal = *cast<BoolValue>(ElseEnv.getValue(*FooDecl));
         EXPECT_TRUE(ElseEnv.flowConditionImplies(ElseEnv.makeNot(ElseFooVal)));
       });
 }
 
 TEST(TransferTest, WhileStmtBranchExtendsFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
       while (Foo) {
runDataflow(
             getEnvironmentAtAnnotation(Results, "loop_body");
         const Environment &AfterLoopEnv =
             getEnvironmentAtAnnotation(Results, "after_loop");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         BoolValue &LoopBodyFooVal =
-            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl));
         EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal));
 
         BoolValue &AfterLoopFooVal =
-            *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopFooVal)));
       });
 }
 
 TEST(TransferTest, DoWhileStmtBranchExtendsFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
runDataflow(
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         BoolValue &LoopBodyFooVal =
-            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl));
         BoolValue &LoopBodyBarVal =
-            *cast<BoolValue>(LoopBodyEnv.getValue(*BarDecl, SkipPast::None));
+            *cast<BoolValue>(LoopBodyEnv.getValue(*BarDecl));
         EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(
             LoopBodyEnv.makeOr(LoopBodyBarVal, LoopBodyFooVal)));
 
         BoolValue &AfterLoopFooVal =
-            *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl));
         BoolValue &AfterLoopBarVal =
-            *cast<BoolValue>(AfterLoopEnv.getValue(*BarDecl, SkipPast::None));
+            *cast<BoolValue>(AfterLoopEnv.getValue(*BarDecl));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopFooVal)));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopBarVal)));
       });
 }
 
 TEST(TransferTest, ForStmtBranchExtendsFlowCondition) {
runDataflow(
             getEnvironmentAtAnnotation(Results, "loop_body");
         const Environment &AfterLoopEnv =
             getEnvironmentAtAnnotation(Results, "after_loop");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         BoolValue &LoopBodyFooVal =
-            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl));
         EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal));
 
         BoolValue &AfterLoopFooVal =
-            *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopFooVal)));
       });
 }
 
 TEST(TransferTest, ForStmtBranchWithoutConditionDoesNotExtendFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
runDataflow(
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("loop_body"));
         const Environment &LoopBodyEnv =
             getEnvironmentAtAnnotation(Results, "loop_body");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         BoolValue &LoopBodyFooVal =
-            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
+            *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl));
         EXPECT_FALSE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal));
       });
 }
 
 TEST(TransferTest, ContextSensitiveOptionDisabled) {
   std::string Code = R"(
     bool GiveBool();
     void SetBool(bool &Var) { Var = true; }
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_FALSE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{/*.ContextSensitiveOpts=*/std::nullopt}});
 }
 
 // This test is a regression test, based on a real crash.
 TEST(TransferTest, ContextSensitiveReturnReferenceFromNonReferenceLvalue) {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_FALSE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{/*.Depth=*/0}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetTrue) {
   std::string Code = R"(
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetFalse) {
   std::string Code = R"(
     bool GiveBool();
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetBothTrueAndFalse) {
   std::string Code = R"(
     bool GiveBool();
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
 
-        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
         EXPECT_FALSE(Env.flowConditionImplies(BarVal));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetTwoLayersDepthOne) {
   std::string Code = R"(
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_FALSE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{/*.Depth=*/1}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetTwoLayersDepthTwo) {
   std::string Code = R"(
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{/*.Depth=*/2}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetThreeLayersDepthTwo) {
   std::string Code = R"(
     bool GiveBool();
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_FALSE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{/*.Depth=*/2}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetThreeLayersDepthThree) {
   std::string Code = R"(
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{/*.Depth=*/3}}});
 }
 
 TEST(TransferTest, ContextSensitiveMutualRecursion) {
   std::string Code = R"(
     bool Pong(bool X, bool Y);
runDataflow(
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         // The analysis doesn't crash...
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         // ... but it also can't prove anything here.
         EXPECT_FALSE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{/*.Depth=*/4}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetMultipleLines) {
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
 
-        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
         EXPECT_FALSE(Env.flowConditionImplies(BarVal));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveSetMultipleBlocks) {
   std::string Code = R"(
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
         EXPECT_FALSE(Env.flowConditionImplies(BarVal));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
 
-        auto &BazVal = *cast<BoolValue>(Env.getValue(*BazDecl, SkipPast::None));
+        auto &BazVal = *cast<BoolValue>(Env.getValue(*BazDecl));
         EXPECT_TRUE(Env.flowConditionImplies(BazVal));
         EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(BazVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveReturnVoid) {
   std::string Code = R"(
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveReturnFalse) {
   std::string Code = R"(
     bool GiveBool() { return false; }
 
     void target() {
       bool Foo = GiveBool();
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(FooVal)));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveReturnArg) {
   std::string Code = R"(
     bool GiveBool();
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
-        auto &BazVal = *cast<BoolValue>(Env.getValue(*BazDecl, SkipPast::None));
+        auto &BazVal = *cast<BoolValue>(Env.getValue(*BazDecl));
         EXPECT_TRUE(Env.flowConditionImplies(BazVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveReturnInt) {
   std::string Code = R"(
     int identity(int x) { return x; }
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveMethodGetter) {
   std::string Code = R"(
     class MyClass {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveMethodSetter) {
   std::string Code = R"(
     class MyClass {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveMethodGetterAndSetter) {
   std::string Code = R"(
     class MyClass {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 
 TEST(TransferTest, ContextSensitiveMethodTwoLayersVoid) {
   std::string Code = R"(
runDataflow(
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         ;
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveMethodTwoLayersReturn) {
   std::string Code = R"(
     class MyClass {
runDataflow(
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         ;
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveConstructorBody) {
   std::string Code = R"(
     class MyClass {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveConstructorInitializer) {
   std::string Code = R"(
     class MyClass {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, ContextSensitiveConstructorDefault) {
   std::string Code = R"(
     class MyClass {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(FooVal));
       },
       {BuiltinOptions{ContextSensitiveOptions{}}});
 }
 
 TEST(TransferTest, UnnamedBitfieldInitializer) {
   std::string Code = R"(
     struct B {};

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

runDataflow(
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
         const Environment &Env3 = getEnvironmentAtAnnotation(Results, "p3");
         const Environment &Env4 = getEnvironmentAtAnnotation(Results, "p4");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return cast<BoolValue>(
-              Env.getValue(*FooDecl, SkipPast::None)->getProperty("is_set"));
+          return cast<BoolValue>(Env.getValue(*FooDecl)->getProperty("is_set"));
         };
 
         EXPECT_FALSE(Env1.flowConditionImplies(*GetFooValue(Env1)));
         EXPECT_TRUE(Env2.flowConditionImplies(*GetFooValue(Env2)));
         EXPECT_TRUE(Env3.flowConditionImplies(*GetFooValue(Env3)));
         EXPECT_TRUE(Env4.flowConditionImplies(*GetFooValue(Env4)));
       });
 }
runDataflow(
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
         const Environment &Env3 = getEnvironmentAtAnnotation(Results, "p3");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         EXPECT_EQ(GetFooValue(Env1)->getProperty("has_value"),
                   &Env1.getBoolLiteralValue(false));
         EXPECT_EQ(GetFooValue(Env2)->getProperty("has_value"),
                   &Env2.getBoolLiteralValue(true));
         EXPECT_TRUE(
             isa<TopBoolValue>(GetFooValue(Env3)->getProperty("has_value")));
runDataflow(
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
         const Environment &Env3 = getEnvironmentAtAnnotation(Results, "p3");
         const Environment &Env4 = getEnvironmentAtAnnotation(Results, "p4");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         EXPECT_EQ(GetFooValue(Env1)->getProperty("has_value"),
                   &Env1.getBoolLiteralValue(false));
         EXPECT_EQ(GetFooValue(Env2)->getProperty("has_value"),
                   &Env2.getBoolLiteralValue(true));
         EXPECT_EQ(GetFooValue(Env3)->getProperty("has_value"),
                   &Env3.getBoolLiteralValue(true));
runDataflow(
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         const auto *FooLoc =
             cast<ScalarStorageLocation>(Env.getStorageLocation(*FooDecl));
-        const auto *BarVal =
-            cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
+        const auto *BarVal = cast<PointerValue>(Env.getValue(*BarDecl));
         EXPECT_EQ(&BarVal->getPointeeLoc(), FooLoc);
       });
 }
 
 TEST_F(WideningTest, DistinctValuesWithSamePropertiesAreEquivalent) {
   std::string Code = R"(
     #include "widening_test_defs.h"
 
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-        const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
+        const auto *FooVal = Env.getValue(*FooDecl);
         EXPECT_EQ(FooVal->getProperty("has_value"),
                   &Env.getBoolLiteralValue(true));
       });
 }
 
 class FlowConditionTest : public Test {
 protected:
   template <typename Matcher>
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-        auto *FooVal1 =
-            cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl));
         EXPECT_TRUE(Env1.flowConditionImplies(*FooVal1));
 
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-        auto *FooVal2 =
-            cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl));
         EXPECT_FALSE(Env2.flowConditionImplies(*FooVal2));
       });
 }
 
 TEST_F(FlowConditionTest, IfStmtSingleNegatedVar) {
   std::string Code = R"(
     void target(bool Foo) {
       if (!Foo) {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-        auto *FooVal1 =
-            cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl));
         EXPECT_FALSE(Env1.flowConditionImplies(*FooVal1));
 
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-        auto *FooVal2 =
-            cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl));
         EXPECT_TRUE(Env2.flowConditionImplies(*FooVal2));
       });
 }
 
 TEST_F(FlowConditionTest, WhileStmt) {
   std::string Code = R"(
     void target(bool Foo) {
       while (Foo) {
         (void)0;
         /*[[p]]*/
       }
     }
   )";
   runDataflow(
       Code,
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
-        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(*FooVal));
       });
 }
 
 TEST_F(FlowConditionTest, Conjunction) {
   std::string Code = R"(
     void target(bool Foo, bool Bar) {
       if (Foo && Bar) {
runDataflow(Code, [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
     ASSERT_THAT(FooDecl, NotNull());
 
     const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
     ASSERT_THAT(BarDecl, NotNull());
 
     ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
     const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl));
+    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl));
     EXPECT_TRUE(Env1.flowConditionImplies(*FooVal1));
     EXPECT_TRUE(Env1.flowConditionImplies(*BarVal1));
 
     const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl));
+    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl));
     EXPECT_FALSE(Env2.flowConditionImplies(*FooVal2));
     EXPECT_FALSE(Env2.flowConditionImplies(*BarVal2));
   });
 }
 
 TEST_F(FlowConditionTest, Disjunction) {
   std::string Code = R"(
     void target(bool Foo, bool Bar) {
runDataflow(Code, [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
     ASSERT_THAT(FooDecl, NotNull());
 
     const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
     ASSERT_THAT(BarDecl, NotNull());
 
     ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
     const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl));
+    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl));
     EXPECT_FALSE(Env1.flowConditionImplies(*FooVal1));
     EXPECT_FALSE(Env1.flowConditionImplies(*BarVal1));
 
     const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl));
+    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl));
     EXPECT_FALSE(Env2.flowConditionImplies(*FooVal2));
     EXPECT_FALSE(Env2.flowConditionImplies(*BarVal2));
   });
 }
 
 TEST_F(FlowConditionTest, NegatedConjunction) {
   std::string Code = R"(
     void target(bool Foo, bool Bar) {
runDataflow(Code, [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
     ASSERT_THAT(FooDecl, NotNull());
 
     const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
     ASSERT_THAT(BarDecl, NotNull());
 
     ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
     const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl));
+    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl));
     EXPECT_FALSE(Env1.flowConditionImplies(*FooVal1));
     EXPECT_FALSE(Env1.flowConditionImplies(*BarVal1));
 
     const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl));
+    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl));
     EXPECT_TRUE(Env2.flowConditionImplies(*FooVal2));
     EXPECT_TRUE(Env2.flowConditionImplies(*BarVal2));
   });
 }
 
 TEST_F(FlowConditionTest, DeMorgan) {
   std::string Code = R"(
     void target(bool Foo, bool Bar) {
runDataflow(Code, [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
     ASSERT_THAT(FooDecl, NotNull());
 
     const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
     ASSERT_THAT(BarDecl, NotNull());
 
     ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
     const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal1 = cast<BoolValue>(Env1.getValue(*FooDecl));
+    auto *BarVal1 = cast<BoolValue>(Env1.getValue(*BarDecl));
     EXPECT_TRUE(Env1.flowConditionImplies(*FooVal1));
     EXPECT_TRUE(Env1.flowConditionImplies(*BarVal1));
 
     const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::None));
-    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl, SkipPast::None));
+    auto *FooVal2 = cast<BoolValue>(Env2.getValue(*FooDecl));
+    auto *BarVal2 = cast<BoolValue>(Env2.getValue(*BarDecl));
     EXPECT_FALSE(Env2.flowConditionImplies(*FooVal2));
     EXPECT_FALSE(Env2.flowConditionImplies(*BarVal2));
   });
 }
 
 TEST_F(FlowConditionTest, Join) {
   std::string Code = R"(
     void target(bool Foo, bool Bar) {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
-        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl));
         EXPECT_TRUE(Env.flowConditionImplies(*FooVal));
       });
 }
 
 // Verifies that flow conditions are properly constructed even when the
 // condition is not meaningfully interpreted.
 //
 // Note: currently, arbitrary function calls are uninterpreted, so the test
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarVal =
-            *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
 
         EXPECT_FALSE(Env.flowConditionImplies(BarVal));
       });
 }
 
 // Verifies that flow conditions are properly constructed even when the
 // condition is not meaningfully interpreted.
 //
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarVal =
-            *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
 
         EXPECT_FALSE(Env.flowConditionImplies(BarVal));
       });
 }
 
 // Verifies that flow conditions are properly constructed even when the
 // condition is not meaningfully interpreted. Adds to above by nesting the
 // interestnig case inside a normal branch. This protects against degenerate
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto &BarVal =
-            *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference));
+        auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl));
 
         EXPECT_FALSE(Env.flowConditionImplies(BarVal));
       });
 }
 
 TEST_F(FlowConditionTest, PointerToBoolImplicitCast) {
   std::string Code = R"(
     void target(int *Ptr) {
runDataflow(
       [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
-        auto &FooVal1 =
-            *cast<BoolValue>(Env1.getValue(*FooDecl, SkipPast::Reference));
+        auto &FooVal1 = *cast<BoolValue>(Env1.getValue(*FooDecl));
         EXPECT_TRUE(Env1.flowConditionImplies(FooVal1));
 
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
-        auto &FooVal2 =
-            *cast<BoolValue>(Env2.getValue(*FooDecl, SkipPast::Reference));
+        auto &FooVal2 = *cast<BoolValue>(Env2.getValue(*FooDecl));
         EXPECT_FALSE(Env2.flowConditionImplies(FooVal2));
       });
 }
 
 class TopAnalysis final : public DataflowAnalysis<TopAnalysis, NoopLattice> {
 public:
   explicit TopAnalysis(ASTContext &Context)
       : DataflowAnalysis<TopAnalysis, NoopLattice>(Context) {}
runDataflow(
         ASSERT_THAT(Results.keys(),
                     UnorderedElementsAre("p1", "p2"));
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         Value *FooVal1 = GetFooValue(Env1);
         ASSERT_THAT(FooVal1, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal1))
             << debugString(FooVal1->getKind());
 
         Value *FooVal2 = GetFooValue(Env2);
runDataflow(
         ASSERT_THAT(Results.keys(),
                     UnorderedElementsAre("p1", "p2"));
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
-
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         Value *FooVal1 = GetFooValue(Env1);
         ASSERT_THAT(FooVal1, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal1))
             << debugString(FooVal1->getKind());
 
         Value *FooVal2 = GetFooValue(Env2);
runDataflow(
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         Value *FooVal1 = GetFooValue(Env1);
         ASSERT_THAT(FooVal1, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal1))
             << debugString(FooVal1->getKind());
 
         Value *FooVal2 = GetFooValue(Env2);
runDataflow(
         const Environment &Env0 = getEnvironmentAtAnnotation(Results, "p0");
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         Value *FooVal0 = GetFooValue(Env0);
         ASSERT_THAT(FooVal0, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal0))
             << debugString(FooVal0->getKind());
 
         Value *FooVal1 = GetFooValue(Env1);
runDataflow(
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         Value *FooVal1 = GetFooValue(Env1);
         ASSERT_THAT(FooVal1, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal1))
             << debugString(FooVal1->getKind());
 
         Value *FooVal2 = GetFooValue(Env2);
runDataflow(
         const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         const ValueDecl *BarDecl = findValueDecl(AO.ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
-        auto *FooVal =
-            dyn_cast_or_null<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
+        auto *FooVal = dyn_cast_or_null<BoolValue>(Env.getValue(*FooDecl));
         ASSERT_THAT(FooVal, NotNull());
 
-        auto *BarVal =
-            dyn_cast_or_null<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
+        auto *BarVal = dyn_cast_or_null<BoolValue>(Env.getValue(*BarDecl));
         ASSERT_THAT(BarVal, NotNull());
 
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeIff(*FooVal, *BarVal)));
       });
 }
 
 TEST_F(TopTest, TopUnusedBeforeLoopHeadJoinsToTop) {
   std::string Code = R"(
runDataflow(
         ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
         const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
         const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
 
         const ValueDecl *FooDecl = findValueDecl(AO.ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         auto GetFooValue = [FooDecl](const Environment &Env) {
-          return Env.getValue(*FooDecl, SkipPast::None);
+          return Env.getValue(*FooDecl);
         };
 
         Value *FooVal1 = GetFooValue(Env1);
         ASSERT_THAT(FooVal1, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal1))
             << debugString(FooVal1->getKind());
 
         Value *FooVal2 = GetFooValue(Env2);
         ASSERT_THAT(FooVal2, NotNull());
         EXPECT_TRUE(isa<TopBoolValue>(FooVal2))
             << debugString(FooVal2->getKind());
 
       });
 }
 } // namespace