[clang][dataflow] Reverse course on `getValue()` deprecation.

[mboehme]

Summary

In the value categories RFC, I proposed that the end state of the migration should be that getValue() should only be legal to call on prvalues.

As a stepping stone, to allow migrating off existing calls to getValue(), I proposed introducing getValueStrict(), which would already have the new semantics.

However, I've now reconsidered this. Any expression, whether prvalue or glvalue, has a value, so really there isn't any reason to forbid calling getValue() on glvalues. I'm therefore removing the deprecation from getValue() and transitioning existing getValueStrict() calls back to getValue().

The other "strict" accessors are a different case. setValueStrict() should only be called on prvalues because glvalues need to have a storage location associated with them; it doesn't make sense to only set a value for them. And, of course, getStorageLocationStrict() and setStorageLocationStrict() should obviously only be called on glvalues because prvalues don't have storage locations.

[ymandel]

This sounds reasonable to me.

[xazax.hun]

Sounds good to me. I believe this will make check author's lives easier.

[mboehme]

Rebase to head

[mboehme]

Rebase to head

[mboehme]

Pre-merge failure looks unrelated. It's in AST/Interp/literals.cpp, and this patch shouldn't affect that in any way.

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

public:
 
   /// Equivalent to `getValue(getStorageLocation(D))` if `D` is assigned a
   /// storage location in the environment, otherwise returns null.
   Value *getValue(const ValueDecl &D) const;
 
   /// Equivalent to `getValue(getStorageLocation(E, SP))` if `E` is assigned a
   /// storage location in the environment, otherwise returns null.
   ///
-  /// The `SP` parameter has no effect.
-  ///
-  /// This function is deprecated; prefer `getValueStrict()`. For details, see
-  /// https://discourse.llvm.org/t/70086.
-  Value *getValue(const Expr &E, SkipPast SP) const;
+  /// The `SP` parameter is deprecated and has no effect. New callers should
+  /// avoid passing this parameter.
+  Value *getValue(const Expr &E, SkipPast SP = SkipPast::None) const;
 
   /// Returns the `Value` assigned to the prvalue `E` in the environment, or
   /// null if `E` isn't assigned a value in the environment.
   ///
-  /// This function is the preferred alternative to
-  /// `getValue(const Expr &, SkipPast)`. Once the migration to strict handling
-  /// of value categories is complete (see https://discourse.llvm.org/t/70086),
-  /// `getValue()` will be removed and this function will be renamed to
-  /// `getValue()`.
+  /// This function is deprecated. Call `getValue(E)` instead.
   ///
   /// Requirements:
   ///
   ///  `E` must be a prvalue
   Value *getValueStrict(const Expr &E) const;
 
   // FIXME: should we deprecate the following & call arena().create() directly?
 

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

void Environment::setValue(const StorageLocation &Loc, Value &Val) {
 
   LocToVal[&Loc] = &Val;
 }
 
 void Environment::setValueStrict(const Expr &E, Value &Val) {
   assert(E.isPRValue());
 
   if (auto *StructVal = dyn_cast<StructValue>(&Val)) {
-    if (auto *ExistingVal = cast_or_null<StructValue>(getValueStrict(E)))
+    if (auto *ExistingVal = cast_or_null<StructValue>(getValue(E)))
       assert(&ExistingVal->getAggregateLoc() == &StructVal->getAggregateLoc());
     if (StorageLocation *ExistingLoc = getStorageLocation(E, SkipPast::None))
       assert(ExistingLoc == &StructVal->getAggregateLoc());
     else
       setStorageLocation(E, StructVal->getAggregateLoc());
     setValue(StructVal->getAggregateLoc(), Val);
     return;
   }
Value *Environment::getValue(const Expr &E, SkipPast SP) const {
   auto *Loc = getStorageLocation(E, SP);
   if (Loc == nullptr)
     return nullptr;
   return getValue(*Loc);
 }
 
 Value *Environment::getValueStrict(const Expr &E) const {
   assert(E.isPRValue());
-  Value *Val = getValue(E, SkipPast::None);
-
-  return Val;
+  return getValue(E);
 }
 
 Value *Environment::createValue(QualType Type) {
   llvm::DenseSet<QualType> Visited;
   int CreatedValuesCount = 0;
   Value *Val = createValueUnlessSelfReferential(Type, Visited, /*Depth=*/0,
                                                 CreatedValuesCount);
   if (CreatedValuesCount > MaxCompositeValueSize) {
if (InitExpr)
     // of the variable can be used for reasoning about the surrounding code.
     // For this reason, we let this case be handled by the `createValue()`
     // call below.
     //
     // FIXME. If and when we interpret all language cases, change this to
     // assert that `InitExpr` is interpreted, rather than supplying a
     // default value (assuming we don't update the environment API to return
     // references).
-    Val = getValueStrict(*InitExpr);
+    Val = getValue(*InitExpr);
   if (!Val)
     Val = createValue(Ty);
 
   if (Ty->isRecordType())
     return cast<StructValue>(Val)->getAggregateLoc();
 
   StorageLocation &Loc =
       D ? createStorageLocation(*D) : createStorageLocation(Ty);
StructValue &refreshStructValue(AggregateStorageLocation &Loc,
   Env.setValue(Loc, NewVal);
   return NewVal;
 }
 
 StructValue &refreshStructValue(const Expr &Expr, Environment &Env) {
   assert(Expr.getType()->isRecordType());
 
   if (Expr.isPRValue()) {
-    if (auto *ExistingVal =
-            cast_or_null<StructValue>(Env.getValueStrict(Expr))) {
+    if (auto *ExistingVal = cast_or_null<StructValue>(Env.getValue(Expr))) {
       auto &NewVal = Env.create<StructValue>(ExistingVal->getAggregateLoc());
       Env.setValueStrict(Expr, NewVal);
       return NewVal;
     }
 
     auto &NewVal = *cast<StructValue>(Env.createValue(Expr.getType()));
     Env.setValueStrict(Expr, NewVal);
     return NewVal;

clang/lib/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.cpp

auto isComparisonOperatorCall(L lhs_arg_matcher, R rhs_arg_matcher) {
   return cxxOperatorCallExpr(
       anyOf(hasOverloadedOperatorName("=="), hasOverloadedOperatorName("!=")),
       argumentCountIs(2), hasArgument(0, lhs_arg_matcher),
       hasArgument(1, rhs_arg_matcher));
 }
 
 /// Ensures that `Expr` is mapped to a `BoolValue` and returns its formula.
 const Formula &forceBoolValue(Environment &Env, const Expr &Expr) {
-  auto *Value = cast_or_null<BoolValue>(Env.getValue(Expr, SkipPast::None));
+  auto *Value = cast_or_null<BoolValue>(Env.getValue(Expr));
   if (Value != nullptr)
     return Value->formula();
 
   auto &Loc = Env.createStorageLocation(Expr);
   Value = &Env.makeAtomicBoolValue();
   Env.setValue(Loc, *Value);
   Env.setStorageLocation(Expr, Loc);
   return Value->formula();
StorageLocation *maybeInitializeOptionalValueMember(QualType Q,
   // created `Value` instead.
   OptionalVal.setProperty("value", ValuePtr);
   return &ValueLoc;
 }
 
 void initializeOptionalReference(const Expr *OptionalExpr,
                                  const MatchFinder::MatchResult &,
                                  LatticeTransferState &State) {
-  if (auto *OptionalVal =
-          State.Env.getValue(*OptionalExpr, SkipPast::Reference)) {
+  if (auto *OptionalVal = State.Env.getValue(*OptionalExpr)) {
     if (OptionalVal->getProperty("has_value") == nullptr) {
       setHasValue(*OptionalVal, State.Env.makeAtomicBoolValue());
     }
   }
 }
 
 /// Returns true if and only if `OptionalVal` is initialized and known to be
 /// empty in `Env`.

 bool isNonEmptyOptional(const Value &OptionalVal, const Environment &Env) {
   auto *HasValueVal =
       cast_or_null<BoolValue>(OptionalVal.getProperty("has_value"));
   return HasValueVal != nullptr &&
          Env.flowConditionImplies(HasValueVal->formula());
 }
 
 Value *getValueBehindPossiblePointer(const Expr &E, const Environment &Env) {
-  Value *Val = Env.getValue(E, SkipPast::Reference);
+  Value *Val = Env.getValue(E);
   if (auto *PointerVal = dyn_cast_or_null<PointerValue>(Val))
     return Env.getValue(PointerVal->getPointeeLoc());
   return Val;
 }
 
 void transferUnwrapCall(const Expr *UnwrapExpr, const Expr *ObjectExpr,
                         LatticeTransferState &State) {
   if (auto *OptionalVal =
BoolValue &valueOrConversionHasValue(const FunctionDecl &F, const Expr &E,
 
   // Check if this is a constructor/assignment call for `optional<T>` with
   // argument of type `U` such that `T` is constructible from `U`.
   if (TemplateParamOptionalWrappersCount == ArgTypeOptionalWrappersCount)
     return State.Env.getBoolLiteralValue(true);
 
   // This is a constructor/assignment call for `optional<T>` with argument of
   // type `optional<U>` such that `T` is constructible from `U`.
-  if (auto *HasValueVal =
-          getHasValue(State.Env, State.Env.getValue(E, SkipPast::Reference)))
+  if (auto *HasValueVal = getHasValue(State.Env, State.Env.getValue(E)))
     return *HasValueVal;
   return State.Env.makeAtomicBoolValue();
 }
 
 void transferValueOrConversionConstructor(
     const CXXConstructExpr *E, const MatchFinder::MatchResult &MatchRes,
     LatticeTransferState &State) {
   assert(E->getNumArgs() > 0);

 }
 
 void transferOptionalAndOptionalCmp(const clang::CXXOperatorCallExpr *CmpExpr,
                                     const MatchFinder::MatchResult &,
                                     LatticeTransferState &State) {
   Environment &Env = State.Env;
   auto &A = Env.arena();
   auto *CmpValue = &forceBoolValue(Env, *CmpExpr);
-  if (auto *LHasVal = getHasValue(
-          Env, Env.getValue(*CmpExpr->getArg(0), SkipPast::Reference)))
-    if (auto *RHasVal = getHasValue(
-            Env, Env.getValue(*CmpExpr->getArg(1), SkipPast::Reference))) {
+  if (auto *LHasVal = getHasValue(Env, Env.getValue(*CmpExpr->getArg(0))))
+    if (auto *RHasVal = getHasValue(Env, Env.getValue(*CmpExpr->getArg(1)))) {
       if (CmpExpr->getOperator() == clang::OO_ExclaimEqual)
         CmpValue = &A.makeNot(*CmpValue);
       Env.addToFlowCondition(evaluateEquality(A, *CmpValue, LHasVal->formula(),
                                               RHasVal->formula()));
     }
 }
 
 void transferOptionalAndValueCmp(const clang::CXXOperatorCallExpr *CmpExpr,
                                  const clang::Expr *E, Environment &Env) {
   auto &A = Env.arena();
   auto *CmpValue = &forceBoolValue(Env, *CmpExpr);
-  if (auto *HasVal = getHasValue(Env, Env.getValue(*E, SkipPast::Reference))) {
+  if (auto *HasVal = getHasValue(Env, Env.getValue(*E))) {
     if (CmpExpr->getOperator() == clang::OO_ExclaimEqual)
       CmpValue = &A.makeNot(*CmpValue);
     Env.addToFlowCondition(
         evaluateEquality(A, *CmpValue, HasVal->formula(), A.makeLiteral(true)));
   }
 }
 
 std::optional<StatementMatcher>

clang/lib/Analysis/FlowSensitive/Transfer.cpp

if (!CFCtx.isBlockReachable(*BlockIt->getSecond()))
     return nullptr;
   const auto &State = BlockToState[BlockIt->getSecond()->getBlockID()];
   assert(State);
   return &State->Env;
 }
 
 static BoolValue &evaluateBooleanEquality(const Expr &LHS, const Expr &RHS,
                                           Environment &Env) {
-  Value *LHSValue = Env.getValueStrict(LHS);
-  Value *RHSValue = Env.getValueStrict(RHS);
+  Value *LHSValue = Env.getValue(LHS);
+  Value *RHSValue = Env.getValue(RHS);
 
   if (LHSValue == RHSValue)
     return Env.getBoolLiteralValue(true);
 
   if (auto *LHSBool = dyn_cast_or_null<BoolValue>(LHSValue))
     if (auto *RHSBool = dyn_cast_or_null<BoolValue>(RHSValue))
       return Env.makeIff(*LHSBool, *RHSBool);
 
static Value *maybeUnpackLValueExpr(const Expr &E, Environment &Env) {
   auto &UnpackedVal = unpackValue(*B, Env);
   if (&UnpackedVal == Val)
     return Val;
   Env.setValue(*Loc, UnpackedVal);
   return &UnpackedVal;
 }
 
 static void propagateValue(const Expr &From, const Expr &To, Environment &Env) {
-  if (auto *Val = Env.getValueStrict(From))
+  if (auto *Val = Env.getValue(From))
     Env.setValueStrict(To, *Val);
 }
 
 static void propagateStorageLocation(const Expr &From, const Expr &To,
                                      Environment &Env) {
   if (auto *Loc = Env.getStorageLocationStrict(From))
     Env.setStorageLocationStrict(To, *Loc);
 }
void VisitBinaryOperator(const BinaryOperator *S) {
     assert(RHS != nullptr);
 
     switch (S->getOpcode()) {
     case BO_Assign: {
       auto *LHSLoc = Env.getStorageLocationStrict(*LHS);
       if (LHSLoc == nullptr)
         break;
 
-      auto *RHSVal = Env.getValueStrict(*RHS);
+      auto *RHSVal = Env.getValue(*RHS);
       if (RHSVal == nullptr)
         break;
 
       // Assign a value to the storage location of the left-hand side.
       Env.setValue(*LHSLoc, *RHSVal);
 
       // Assign a storage location for the whole expression.
       Env.setStorageLocation(*S, *LHSLoc);
void VisitImplicitCastExpr(const ImplicitCastExpr *S) {
     assert(SubExpr != nullptr);
 
     switch (S->getCastKind()) {
     case CK_IntegralToBoolean: {
       // This cast creates a new, boolean value from the integral value. We
       // model that with a fresh value in the environment, unless it's already a
       // boolean.
       if (auto *SubExprVal =
-              dyn_cast_or_null<BoolValue>(Env.getValueStrict(*SubExpr)))
+              dyn_cast_or_null<BoolValue>(Env.getValue(*SubExpr)))
         Env.setValueStrict(*S, *SubExprVal);
       else
         // FIXME: If integer modeling is added, then update this code to create
         // the boolean based on the integer model.
         Env.setValueStrict(*S, Env.makeAtomicBoolValue());
       break;
     }
 
public:
 
   void VisitUnaryOperator(const UnaryOperator *S) {
     const Expr *SubExpr = S->getSubExpr();
     assert(SubExpr != nullptr);
 
     switch (S->getOpcode()) {
     case UO_Deref: {
       const auto *SubExprVal =
-          cast_or_null<PointerValue>(Env.getValueStrict(*SubExpr));
+          cast_or_null<PointerValue>(Env.getValue(*SubExpr));
       if (SubExprVal == nullptr)
         break;
 
       Env.setStorageLocationStrict(*S, SubExprVal->getPointeeLoc());
       break;
     }
     case UO_AddrOf: {
       // FIXME: Model pointers to members.
       if (S->getType()->isMemberPointerType())
         break;
 
       if (StorageLocation *PointeeLoc = Env.getStorageLocationStrict(*SubExpr))
         Env.setValueStrict(*S, Env.create<PointerValue>(*PointeeLoc));
       break;
     }
     case UO_LNot: {
-      auto *SubExprVal =
-          dyn_cast_or_null<BoolValue>(Env.getValueStrict(*SubExpr));
+      auto *SubExprVal = dyn_cast_or_null<BoolValue>(Env.getValue(*SubExpr));
       if (SubExprVal == nullptr)
         break;
 
       auto &ExprLoc = Env.createStorageLocation(*S);
       Env.setStorageLocation(*S, ExprLoc);
       Env.setValue(ExprLoc, Env.makeNot(*SubExprVal));
       break;
     }
void VisitReturnStmt(const ReturnStmt *S) {
     if (!Env.getDataflowAnalysisContext().getOptions().ContextSensitiveOpts)
       return;
 
     auto *Ret = S->getRetValue();
     if (Ret == nullptr)
       return;
 
     if (Ret->isPRValue()) {
-      auto *Val = Env.getValueStrict(*Ret);
+      auto *Val = Env.getValue(*Ret);
       if (Val == nullptr)
         return;
 
       // FIXME: Model NRVO.
       Env.setReturnValue(Val);
     } else {
       auto *Loc = Env.getStorageLocationStrict(*Ret);
       if (Loc == nullptr)
if (ConstructorDecl->isCopyOrMoveConstructor()) {
 
       auto *ArgLoc = cast_or_null<AggregateStorageLocation>(
           Env.getStorageLocation(*Arg, SkipPast::Reference));
       if (ArgLoc == nullptr)
         return;
 
       if (S->isElidable()) {
         Env.setStorageLocation(*S, *ArgLoc);
-      } else if (auto *ArgVal = cast_or_null<StructValue>(
-                     Env.getValue(*Arg, SkipPast::Reference))) {
+      } else if (auto *ArgVal = cast_or_null<StructValue>(Env.getValue(*Arg))) {
         auto &Val = *cast<StructValue>(Env.createValue(S->getType()));
         Env.setValueStrict(*S, Val);
         copyRecord(ArgVal->getAggregateLoc(), Val.getAggregateLoc(), Env);
       }
       return;
     }
 
     // `CXXConstructExpr` can have array type if default-initializing an array
if (S->isCallToStdMove()) {
       transferInlineCall(S, F);
     }
   }
 
   void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *S) {
     const Expr *SubExpr = S->getSubExpr();
     assert(SubExpr != nullptr);
 
-    Value *SubExprVal = Env.getValueStrict(*SubExpr);
+    Value *SubExprVal = Env.getValue(*SubExpr);
     if (SubExprVal == nullptr)
       return;
 
     if (StructValue *StructVal = dyn_cast<StructValue>(SubExprVal)) {
       Env.setStorageLocation(*S, StructVal->getAggregateLoc());
       return;
     }
 

 private:
   /// Returns the value for the sub-expression `SubExpr` of a logic operator.
   BoolValue &getLogicOperatorSubExprValue(const Expr &SubExpr) {
     // `SubExpr` and its parent logic operator might be part of different basic
     // blocks. We try to access the value that is assigned to `SubExpr` in the
     // corresponding environment.
     if (const Environment *SubExprEnv = StmtToEnv.getEnvironment(SubExpr))
       if (auto *Val =
-              dyn_cast_or_null<BoolValue>(SubExprEnv->getValueStrict(SubExpr)))
+              dyn_cast_or_null<BoolValue>(SubExprEnv->getValue(SubExpr)))
         return *Val;
 
     // The sub-expression may lie within a basic block that isn't reachable,
     // even if we need it to evaluate the current (reachable) expression
     // (see https://discourse.llvm.org/t/70775). In this case, visit `SubExpr`
     // within the current environment and then try to get the value that gets
     // assigned to it.
-    if (Env.getValueStrict(SubExpr) == nullptr)
+    if (Env.getValue(SubExpr) == nullptr)
       Visit(&SubExpr);
-    if (auto *Val = dyn_cast_or_null<BoolValue>(Env.getValueStrict(SubExpr)))
+    if (auto *Val = dyn_cast_or_null<BoolValue>(Env.getValue(SubExpr)))
       return *Val;
 
     // If the value of `SubExpr` is still unknown, we create a fresh symbolic
     // boolean value for it.
     return Env.makeAtomicBoolValue();
   }
 
   // If context sensitivity is enabled, try to analyze the body of the callee

clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

VisitConditionalOperator(const ConditionalOperator *S) {
     auto *Cond = S->getCond();
     assert(Cond != nullptr);
     return extendFlowCondition(*Cond);
   }
 
 private:
   TerminatorVisitorRetTy extendFlowCondition(const Expr &Cond) {
     // The terminator sub-expression might not be evaluated.
-    if (Env.getValueStrict(Cond) == nullptr)
+    if (Env.getValue(Cond) == nullptr)
       transfer(StmtToEnv, Cond, Env);
 
-    auto *Val = cast_or_null<BoolValue>(Env.getValueStrict(Cond));
+    auto *Val = cast_or_null<BoolValue>(Env.getValue(Cond));
     // Value merging depends on flow conditions from different environments
     // being mutually exclusive -- that is, they cannot both be true in their
     // entirety (even if they may share some clauses). So, we need *some* value
     // for the condition expression, even if just an atom.
     if (Val == nullptr) {
       Val = &Env.makeAtomicBoolValue();
       Env.setValueStrict(Cond, *Val);
     }
builtinTransferInitializer(const CFGInitializer &Elt,
   // the `AggregateStorageLocation` already exists. We should explore if there's
   // anything that we can do to change this.
   if (Member->getType()->isReferenceType()) {
     auto *InitExprLoc = Env.getStorageLocationStrict(*InitExpr);
     if (InitExprLoc == nullptr)
       return;
 
     ParentLoc->setChild(*Member, InitExprLoc);
-  } else if (auto *InitExprVal = Env.getValueStrict(*InitExpr)) {
+  } else if (auto *InitExprVal = Env.getValue(*InitExpr)) {
     if (Member->getType()->isRecordType()) {
       auto *InitValStruct = cast<StructValue>(InitExprVal);
       // FIXME: Rather than performing a copy here, we should really be
       // initializing the field in place. This would require us to propagate the
       // storage location of the field to the AST node that creates the
       // `StructValue`.
       copyRecord(InitValStruct->getAggregateLoc(),
                  *cast<AggregateStorageLocation>(MemberLoc), Env);

clang/unittests/Analysis/FlowSensitive/SignAnalysisTest.cpp

getValueAndSignProperties(const UnaryOperator *UO,
   // 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);
   if (!OperandValue)
     return {nullptr, {}, {}};
 
   // Value of the unary op.
-  auto *UnaryOpValue = State.Env.getValueStrict(*UO);
+  auto *UnaryOpValue = State.Env.getValue(*UO);
   if (!UnaryOpValue) {
     UnaryOpValue = &State.Env.makeAtomicBoolValue();
     State.Env.setValueStrict(*UO, *UnaryOpValue);
   }
 
   // Properties for the operand (sub expression).
   SignProperties OperandProps = getSignProperties(*OperandValue, State.Env);
   if (OperandProps.Neg == nullptr)
     return {nullptr, {}, {}};
   // Properties for the operator expr itself.
   SignProperties UnaryOpProps = initUnknown(*UnaryOpValue, State.Env);
   return {UnaryOpValue, UnaryOpProps, OperandProps};
 }
 
 void transferBinary(const BinaryOperator *BO, const MatchFinder::MatchResult &M,
                     LatticeTransferState &State) {
   auto &A = State.Env.arena();
   const Formula *Comp;
-  if (BoolValue *V = cast_or_null<BoolValue>(State.Env.getValueStrict(*BO))) {
+  if (BoolValue *V = cast_or_null<BoolValue>(State.Env.getValue(*BO))) {
     Comp = &V->formula();
   } else {
     Comp = &A.makeAtomRef(A.makeAtom());
     State.Env.setValueStrict(*BO, A.makeBoolValue(*Comp));
   }
 
   // FIXME Use this as well:
   // auto *NegatedComp = &State.Env.makeNot(*Comp);
 
-  auto *LHS = State.Env.getValueStrict(*BO->getLHS());
-  auto *RHS = State.Env.getValueStrict(*BO->getRHS());
+  auto *LHS = State.Env.getValue(*BO->getLHS());
+  auto *RHS = State.Env.getValue(*BO->getRHS());
 
   if (!LHS || !RHS)
     return;
 
   SignProperties LHSProps = getSignProperties(*LHS, State.Env);
   SignProperties RHSProps = getSignProperties(*RHS, State.Env);
   if (LHSProps.Neg == nullptr || RHSProps.Neg == nullptr)
     return;
if (!Loc) {
       Env.setStorageLocationStrict(*E, *Loc);
     }
     Val = Env.getValue(*Loc);
     if (!Val) {
       Val = Env.createValue(E->getType());
       Env.setValue(*Loc, *Val);
     }
   } else {
-    Val = Env.getValueStrict(*E);
+    Val = Env.getValue(*E);
     if (!Val) {
       Val = Env.createValue(E->getType());
       Env.setValueStrict(*E, *Val);
     }
   }
   assert(Val != nullptr);
 
   return Val;

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

runDataflow(
         auto *ImplicitCast = selectFirst<ImplicitCastExpr>(
             "implicit_cast",
             match(traverse(TK_AsIs,
                            implicitCastExpr(hasCastKind(CK_BuiltinFnToFnPtr))
                                .bind("implicit_cast")),
                   ASTCtx));
 
         ASSERT_THAT(ImplicitCast, NotNull());
-        EXPECT_THAT(Env.getValueStrict(*ImplicitCast), IsNull());
+        EXPECT_THAT(Env.getValue(*ImplicitCast), IsNull());
       });
 }
 
 // Check that fields of anonymous records are modeled.
 TEST(TransferTest, AnonymousStruct) {
   std::string Code = R"(
     struct S {
       struct {

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

if (!CS)
       return;
     const auto *S = CS->getStmt();
     auto SpecialBoolRecordDecl = recordDecl(hasName("SpecialBool"));
     auto HasSpecialBoolType = hasType(SpecialBoolRecordDecl);
 
     if (const auto *E = selectFirst<CXXConstructExpr>(
             "call", match(cxxConstructExpr(HasSpecialBoolType).bind("call"), *S,
                           getASTContext()))) {
-      cast<StructValue>(Env.getValueStrict(*E))
+      cast<StructValue>(Env.getValue(*E))
           ->setProperty("is_set", Env.getBoolLiteralValue(false));
     } else if (const auto *E = selectFirst<CXXMemberCallExpr>(
                    "call", match(cxxMemberCallExpr(callee(cxxMethodDecl(ofClass(
                                                        SpecialBoolRecordDecl))))
                                      .bind("call"),
                                  *S, getASTContext()))) {
       auto &ObjectLoc =
           *cast<AggregateStorageLocation>(getImplicitObjectLocation(*E, Env));
void transfer(const CFGElement &Elt, NoopLattice &, Environment &Env) {
     SmallVector<BoundNodes, 1> Matches = match(
         stmt(anyOf(cxxConstructExpr(HasOptionalIntType).bind("construct"),
                    cxxOperatorCallExpr(
                        callee(cxxMethodDecl(ofClass(OptionalIntRecordDecl))))
                        .bind("operator"))),
         *S, getASTContext());
     if (const auto *E = selectFirst<CXXConstructExpr>(
             "construct", Matches)) {
-      cast<StructValue>(Env.getValueStrict(*E))
+      cast<StructValue>(Env.getValue(*E))
           ->setProperty("has_value", Env.getBoolLiteralValue(false));
     } else if (const auto *E =
                    selectFirst<CXXOperatorCallExpr>("operator", Matches)) {
       assert(E->getNumArgs() > 0);
       auto *Object = E->getArg(0);
       assert(Object != nullptr);
 
       refreshStructValue(*Object, Env)