[clang][dataflow] Remove `Strict` suffix from accessors.

[mboehme]

Summary

For the time being, we're keeping the Strict versions around as deprecated synonyms so that clients can be migrated, but these synonyms will be removed soon.

Depends On D156673

[mboehme]

Rebased to head

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

public:
 
   /// Assigns `Loc` as the storage location of the glvalue `E` in the
   /// environment.
   ///
   /// Requirements:
   ///
   ///  `E` must not be assigned a storage location in the environment.
   ///  `E` must be a glvalue or a `BuiltinType::BuiltinFn`
-  void setStorageLocationStrict(const Expr &E, StorageLocation &Loc);
+  void setStorageLocation(const Expr &E, StorageLocation &Loc);
+
+  /// Deprecated synonym for `setStorageLocation()`.
+  void setStorageLocationStrict(const Expr &E, StorageLocation &Loc) {
+    setStorageLocation(E, Loc);
+  }
 
   /// Returns the storage location assigned to the glvalue `E` in the
   /// environment, or null if `E` isn't assigned a storage location in the
   /// environment.
   ///
   /// If the storage location for `E` is associated with a
   /// `ReferenceValue RefVal`, returns `RefVal.getReferentLoc()` instead.
   ///
   /// Requirements:
   ///  `E` must be a glvalue or a `BuiltinType::BuiltinFn`
-  StorageLocation *getStorageLocationStrict(const Expr &E) const;
+  StorageLocation *getStorageLocation(const Expr &E) const;
+
+  /// Deprecated synonym for `getStorageLocation()`.
+  StorageLocation *getStorageLocationStrict(const Expr &E) const {
+    return getStorageLocation(E);
+  }
 
   /// Returns the storage location assigned to the `this` pointee in the
   /// environment or null if the `this` pointee has no assigned storage location
   /// in the environment.
   AggregateStorageLocation *getThisPointeeStorageLocation() const;
 
   /// Returns the location of the result object for a record-type prvalue.
   ///
public:
   /// Requirements:
   ///
   ///  `E` must be a prvalue
   ///  `Val` must not be a `ReferenceValue`
   ///  If `Val` is a `StructValue`, its `AggregateStorageLocation` must be the
   ///  same as that of any `StructValue` that has already been associated with
   ///  `E`. This is to guarantee that the result object initialized by a prvalue
   ///  `StructValue` has a durable storage location.
-  void setValueStrict(const Expr &E, Value &Val);
+  void setValue(const Expr &E, Value &Val);
+
+  /// Deprecated synonym for `setValue()`.
+  void setValueStrict(const Expr &E, Value &Val) { setValue(E, 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))` if `D` is assigned a
   /// storage location in the environment, otherwise returns null.
   Value *getValue(const ValueDecl &D) const;
public:
 
   LLVM_DUMP_METHOD void dump() const;
   LLVM_DUMP_METHOD void dump(raw_ostream &OS) const;
 
 private:
   // The copy-constructor is for use in fork() only.
   Environment(const Environment &) = default;
 
-  /// Internal version of `setStorageLocationStrict()` that doesn't check if the
+  /// Internal version of `setStorageLocation()` that doesn't check if the
   /// expression is a prvalue.
   void setStorageLocationInternal(const Expr &E, StorageLocation &Loc);
 
-  /// Internal version of `getStorageLocationStrict()` that doesn't check if the
+  /// Internal version of `getStorageLocation()` that doesn't check if the
   /// expression is a prvalue.
   StorageLocation *getStorageLocationInternal(const Expr &E) const;
 
   /// Creates a value appropriate for `Type`, if `Type` is supported, otherwise
   /// return null.
   ///
   /// Recursively initializes storage locations and values until it sees a
   /// self-referential pointer or reference type. `Visited` is used to track

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

 
 Environment Environment::pushCall(const CallExpr *Call) const {
   Environment Env(*this);
 
   if (const auto *MethodCall = dyn_cast<CXXMemberCallExpr>(Call)) {
     if (const Expr *Arg = MethodCall->getImplicitObjectArgument()) {
       if (!isa<CXXThisExpr>(Arg))
           Env.ThisPointeeLoc =
-              cast<AggregateStorageLocation>(getStorageLocationStrict(*Arg));
+              cast<AggregateStorageLocation>(getStorageLocation(*Arg));
       // Otherwise (when the argument is `this`), retain the current
       // environment's `ThisPointeeLoc`.
     }
   }
 
   Env.pushCallInternal(Call->getDirectCallee(),
                        llvm::ArrayRef(Call->getArgs(), Call->getNumArgs()));
 
void Environment::popCall(const CallExpr *Call, const Environment &CalleeEnv) {
   // requires there to not already be a storage location assigned. Conceptually,
   // these maps capture information from the local scope, so when popping that
   // scope, we do not propagate the maps.
   this->LocToVal = std::move(CalleeEnv.LocToVal);
   this->FlowConditionToken = std::move(CalleeEnv.FlowConditionToken);
 
   if (Call->isGLValue()) {
     if (CalleeEnv.ReturnLoc != nullptr)
-      setStorageLocationStrict(*Call, *CalleeEnv.ReturnLoc);
+      setStorageLocation(*Call, *CalleeEnv.ReturnLoc);
   } else if (!Call->getType()->isVoidType()) {
     if (CalleeEnv.ReturnVal != nullptr)
-      setValueStrict(*Call, *CalleeEnv.ReturnVal);
+      setValue(*Call, *CalleeEnv.ReturnVal);
   }
 }
 
 void Environment::popCall(const CXXConstructExpr *Call,
                           const Environment &CalleeEnv) {
   // See also comment in `popCall(const CallExpr *, const Environment &)` above.
   this->LocToVal = std::move(CalleeEnv.LocToVal);
   this->FlowConditionToken = std::move(CalleeEnv.FlowConditionToken);
 
   if (Value *Val = CalleeEnv.getValue(*CalleeEnv.ThisPointeeLoc)) {
-    setValueStrict(*Call, *Val);
+    setValue(*Call, *Val);
   }
 }
 
 bool Environment::equivalentTo(const Environment &Other,
                                Environment::ValueModel &Model) const {
   assert(DACtx == Other.DACtx);
 
   if (ReturnVal != Other.ReturnVal)
StorageLocation *Environment::getStorageLocation(const ValueDecl &D) const {
   if (It == DeclToLoc.end())
     return nullptr;
 
   StorageLocation *Loc = It->second;
 
   return Loc;
 }
 
-void Environment::setStorageLocationStrict(const Expr &E,
-                                           StorageLocation &Loc) {
+void Environment::setStorageLocation(const Expr &E, StorageLocation &Loc) {
   // `DeclRefExpr`s to builtin function types aren't glvalues, for some reason,
   // but we still want to be able to associate a `StorageLocation` with them,
   // so allow these as an exception.
   assert(E.isGLValue() ||
          E.getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn));
   setStorageLocationInternal(E, Loc);
 }
 
-StorageLocation *Environment::getStorageLocationStrict(const Expr &E) const {
-  // See comment in `setStorageLocationStrict()`.
+StorageLocation *Environment::getStorageLocation(const Expr &E) const {
+  // See comment in `setStorageLocation()`.
   assert(E.isGLValue() ||
          E.getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn));
   return getStorageLocationInternal(E);
 }
 
 AggregateStorageLocation *Environment::getThisPointeeStorageLocation() const {
   return ThisPointeeLoc;
 }

 
 void Environment::setValue(const StorageLocation &Loc, Value &Val) {
   assert(!isa<StructValue>(&Val) ||
          &cast<StructValue>(&Val)->getAggregateLoc() == &Loc);
 
   LocToVal[&Loc] = &Val;
 }
 
-void Environment::setValueStrict(const Expr &E, Value &Val) {
+void Environment::setValue(const Expr &E, Value &Val) {
   assert(E.isPRValue());
 
   if (auto *StructVal = dyn_cast<StructValue>(&Val)) {
     if ([[maybe_unused]] auto *ExistingVal =
             cast_or_null<StructValue>(getValue(E)))
       assert(&ExistingVal->getAggregateLoc() == &StructVal->getAggregateLoc());
     if ([[maybe_unused]] StorageLocation *ExistingLoc =
             getStorageLocationInternal(E))

 StorageLocation &Environment::createObjectInternal(const VarDecl *D,
                                                    QualType Ty,
                                                    const Expr *InitExpr) {
   if (Ty->isReferenceType()) {
     // Although variables of reference type always need to be initialized, it
     // can happen that we can't see the initializer, so `InitExpr` may still
     // be null.
     if (InitExpr) {
-      if (auto *InitExprLoc = getStorageLocationStrict(*InitExpr))
+      if (auto *InitExprLoc = getStorageLocation(*InitExpr))
           return *InitExprLoc;
     }
 
     // Even though we have an initializer, we might not get an
     // InitExprLoc, for example if the InitExpr is a CallExpr for which we
     // don't have a function body. In this case, we just invent a storage
     // location and value -- it's the best we can do.
     return createObjectInternal(D, Ty.getNonReferenceType(), nullptr);
getImplicitObjectLocation(const CXXMemberCallExpr &MCE,
   if (ImplicitObject == nullptr)
     return nullptr;
   if (ImplicitObject->getType()->isPointerType()) {
     if (auto *Val = cast_or_null<PointerValue>(Env.getValue(*ImplicitObject)))
       return &cast<AggregateStorageLocation>(Val->getPointeeLoc());
     return nullptr;
   }
   return cast_or_null<AggregateStorageLocation>(
-      Env.getStorageLocationStrict(*ImplicitObject));
+      Env.getStorageLocation(*ImplicitObject));
 }
 
 AggregateStorageLocation *getBaseObjectLocation(const MemberExpr &ME,
                                                 const Environment &Env) {
   Expr *Base = ME.getBase();
   if (Base == nullptr)
     return nullptr;
   if (ME.isArrow()) {
     if (auto *Val = cast_or_null<PointerValue>(Env.getValue(*Base)))
       return &cast<AggregateStorageLocation>(Val->getPointeeLoc());
     return nullptr;
   }
-  return cast_or_null<AggregateStorageLocation>(
-      Env.getStorageLocationStrict(*Base));
+  return cast_or_null<AggregateStorageLocation>(Env.getStorageLocation(*Base));
 }
 
 std::vector<FieldDecl *> getFieldsForInitListExpr(const RecordDecl *RD) {
   // Unnamed bitfields are only used for padding and do not appear in
   // `InitListExpr`'s inits. However, those fields do appear in `RecordDecl`'s
   // field list, and we thus need to remove them before mapping inits to
   // fields to avoid mapping inits to the wrongs fields.
   std::vector<FieldDecl *> Fields;

 }
 
 StructValue &refreshStructValue(const Expr &Expr, Environment &Env) {
   assert(Expr.getType()->isRecordType());
 
   if (Expr.isPRValue()) {
     if (auto *ExistingVal = cast_or_null<StructValue>(Env.getValue(Expr))) {
       auto &NewVal = Env.create<StructValue>(ExistingVal->getAggregateLoc());
-      Env.setValueStrict(Expr, NewVal);
+      Env.setValue(Expr, NewVal);
       return NewVal;
     }
 
     auto &NewVal = *cast<StructValue>(Env.createValue(Expr.getType()));
-    Env.setValueStrict(Expr, NewVal);
+    Env.setValue(Expr, NewVal);
     return NewVal;
   }
 
   if (auto *Loc = cast_or_null<AggregateStorageLocation>(
-          Env.getStorageLocationStrict(Expr))) {
+          Env.getStorageLocation(Expr))) {
     auto &NewVal = Env.create<StructValue>(*Loc);
     Env.setValue(*Loc, NewVal);
     return NewVal;
   }
 
   auto &NewVal = *cast<StructValue>(Env.createValue(Expr.getType()));
-  Env.setStorageLocationStrict(Expr, NewVal.getAggregateLoc());
+  Env.setStorageLocation(Expr, NewVal.getAggregateLoc());
   return NewVal;
 }
 
 } // namespace dataflow
 } // namespace clang

clang/lib/Analysis/FlowSensitive/HTMLLogger.cpp

JOS->attributeObject(elementIterID(Block, Iter, ElementIndex), [&] {
         auto S =
             Iters.back().first->Elements[ElementIndex - 1].getAs<CFGStmt>();
         if (const Expr *E = S ? llvm::dyn_cast<Expr>(S->getStmt()) : nullptr) {
           if (E->isPRValue()) {
             if (auto *V = State.Env.getValue(*E))
               JOS->attributeObject(
                   "value", [&] { ModelDumper(*JOS, State.Env).dump(*V); });
           } else {
-            if (auto *Loc = State.Env.getStorageLocationStrict(*E))
+            if (auto *Loc = State.Env.getStorageLocation(*E))
               JOS->attributeObject(
                   "value", [&] { ModelDumper(*JOS, State.Env).dump(*Loc); });
           }
         }
       }
       if (!ContextLogs.empty()) {
         JOS->attribute("logs", ContextLogs);
         ContextLogs.clear();

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

 
 /// 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));
   if (Value != nullptr)
     return Value->formula();
 
   Value = &Env.makeAtomicBoolValue();
-  Env.setValueStrict(Expr, *Value);
+  Env.setValue(Expr, *Value);
   return Value->formula();
 }
 
 /// Sets `HasValueVal` as the symbolic value that represents the "has_value"
 /// property of the optional value `OptionalVal`.
 void setHasValue(Value &OptionalVal, BoolValue &HasValueVal) {
   OptionalVal.setProperty("has_value", HasValueVal);
 }
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 =
           getValueBehindPossiblePointer(*ObjectExpr, State.Env)) {
-    if (State.Env.getStorageLocationStrict(*UnwrapExpr) == nullptr)
+    if (State.Env.getStorageLocation(*UnwrapExpr) == nullptr)
       if (auto *Loc = maybeInitializeOptionalValueMember(
               UnwrapExpr->getType(), *OptionalVal, State.Env))
-        State.Env.setStorageLocationStrict(*UnwrapExpr, *Loc);
+        State.Env.setStorageLocation(*UnwrapExpr, *Loc);
   }
 }
 
 void transferArrowOpCall(const Expr *UnwrapExpr, const Expr *ObjectExpr,
                          LatticeTransferState &State) {
   if (auto *OptionalVal =
           getValueBehindPossiblePointer(*ObjectExpr, State.Env)) {
     if (auto *Loc = maybeInitializeOptionalValueMember(
             UnwrapExpr->getType()->getPointeeType(), *OptionalVal, State.Env)) {
-      State.Env.setValueStrict(*UnwrapExpr,
-                               State.Env.create<PointerValue>(*Loc));
+      State.Env.setValue(*UnwrapExpr, State.Env.create<PointerValue>(*Loc));
     }
   }
 }
 
 void transferMakeOptionalCall(const CallExpr *E,
                               const MatchFinder::MatchResult &,
                               LatticeTransferState &State) {
   createOptionalValue(State.Env.getResultObjectLocation(*E),
                       State.Env.getBoolLiteralValue(true), State.Env);
 }
 
 void transferOptionalHasValueCall(const CXXMemberCallExpr *CallExpr,
                                   const MatchFinder::MatchResult &,
                                   LatticeTransferState &State) {
   if (auto *HasValueVal = getHasValue(
           State.Env, getValueBehindPossiblePointer(
                          *CallExpr->getImplicitObjectArgument(), State.Env))) {
-    State.Env.setValueStrict(*CallExpr, *HasValueVal);
+    State.Env.setValue(*CallExpr, *HasValueVal);
   }
 }
 
 /// `ModelPred` builds a logical formula relating the predicate in
 /// `ValueOrPredExpr` to the optional's `has_value` property.
 void transferValueOrImpl(
     const clang::Expr *ValueOrPredExpr, const MatchFinder::MatchResult &Result,
     LatticeTransferState &State,
void transferCallReturningOptional(const CallExpr *E,
   if (State.Env.getValue(*E) != nullptr)
     return;
 
   AggregateStorageLocation *Loc = nullptr;
   if (E->isPRValue()) {
     Loc = &State.Env.getResultObjectLocation(*E);
   } else {
     Loc = cast_or_null<AggregateStorageLocation>(
-        State.Env.getStorageLocationStrict(*E));
+        State.Env.getStorageLocation(*E));
     if (!Loc) {
       Loc =
           &cast<AggregateStorageLocation>(State.Env.createStorageLocation(*E));
-      State.Env.setStorageLocationStrict(*E, *Loc);
+      State.Env.setStorageLocation(*E, *Loc);
     }
   }
 
   createOptionalValue(*Loc, State.Env.makeAtomicBoolValue(), State.Env);
 }
 
 void constructOptionalValue(const Expr &E, Environment &Env,
                             BoolValue &HasValueVal) {
   AggregateStorageLocation &Loc = Env.getResultObjectLocation(E);
-  Env.setValueStrict(E, createOptionalValue(Loc, HasValueVal, Env));
+  Env.setValue(E, createOptionalValue(Loc, HasValueVal, Env));
 }
 
 /// Returns a symbolic value for the "has_value" property of an `optional<T>`
 /// value that is constructed/assigned from a value of type `U` or `optional<U>`
 /// where `T` is constructible from `U`.
 BoolValue &valueOrConversionHasValue(const FunctionDecl &F, const Expr &E,
                                      const MatchFinder::MatchResult &MatchRes,
                                      LatticeTransferState &State) {
constructOptionalValue(*E, State.Env,
                                                    State));
 }
 
 void transferAssignment(const CXXOperatorCallExpr *E, BoolValue &HasValueVal,
                         LatticeTransferState &State) {
   assert(E->getNumArgs() > 0);
 
   if (auto *Loc = cast<AggregateStorageLocation>(
-          State.Env.getStorageLocationStrict(*E->getArg(0)))) {
+          State.Env.getStorageLocation(*E->getArg(0)))) {
     createOptionalValue(*Loc, HasValueVal, State.Env);
 
     // Assign a storage location for the whole expression.
-    State.Env.setStorageLocationStrict(*E, *Loc);
+    State.Env.setStorageLocation(*E, *Loc);
   }
 }
 
 void transferValueOrConversionAssignment(
     const CXXOperatorCallExpr *E, const MatchFinder::MatchResult &MatchRes,
     LatticeTransferState &State) {
   assert(E->getNumArgs() > 1);
   transferAssignment(E,
void transferSwap(AggregateStorageLocation *Loc1,
   createOptionalValue(*Loc2, *BoolVal1, Env);
 }
 
 void transferSwapCall(const CXXMemberCallExpr *E,
                       const MatchFinder::MatchResult &,
                       LatticeTransferState &State) {
   assert(E->getNumArgs() == 1);
   auto *OtherLoc = cast_or_null<AggregateStorageLocation>(
-      State.Env.getStorageLocationStrict(*E->getArg(0)));
+      State.Env.getStorageLocation(*E->getArg(0)));
   transferSwap(getImplicitObjectLocation(*E, State.Env), OtherLoc, State.Env);
 }
 
 void transferStdSwapCall(const CallExpr *E, const MatchFinder::MatchResult &,
                          LatticeTransferState &State) {
   assert(E->getNumArgs() == 2);
   auto *Arg0Loc = cast_or_null<AggregateStorageLocation>(
-      State.Env.getStorageLocationStrict(*E->getArg(0)));
+      State.Env.getStorageLocation(*E->getArg(0)));
   auto *Arg1Loc = cast_or_null<AggregateStorageLocation>(
-      State.Env.getStorageLocationStrict(*E->getArg(1)));
+      State.Env.getStorageLocation(*E->getArg(1)));
   transferSwap(Arg0Loc, Arg1Loc, State.Env);
 }
 
 void transferStdForwardCall(const CallExpr *E, const MatchFinder::MatchResult &,
                             LatticeTransferState &State) {
   assert(E->getNumArgs() == 1);
 
-  if (auto *Loc = State.Env.getStorageLocationStrict(*E->getArg(0)))
-    State.Env.setStorageLocationStrict(*E, *Loc);
+  if (auto *Loc = State.Env.getStorageLocation(*E->getArg(0)))
+    State.Env.setStorageLocation(*E, *Loc);
 }
 
 const Formula &evaluateEquality(Arena &A, const Formula &EqVal,
                                 const Formula &LHS, const Formula &RHS) {
   // Logically, an optional<T> object is composed of two values - a `has_value`
   // bit and a value of type T. Equality of optional objects compares both
   // values. Therefore, merely comparing the `has_value` bits isn't sufficient:
   // when two optional objects are engaged, the equality of their respective

clang/lib/Analysis/FlowSensitive/Transfer.cpp

static BoolValue &unpackValue(BoolValue &V, Environment &Env) {
   }
   return V;
 }
 
 // Unpacks the value (if any) associated with `E` and updates `E` to the new
 // value, if any unpacking occured. Also, does the lvalue-to-rvalue conversion,
 // by skipping past the reference.
 static Value *maybeUnpackLValueExpr(const Expr &E, Environment &Env) {
-  auto *Loc = Env.getStorageLocationStrict(E);
+  auto *Loc = Env.getStorageLocation(E);
   if (Loc == nullptr)
     return nullptr;
   auto *Val = Env.getValue(*Loc);
 
   auto *B = dyn_cast_or_null<BoolValue>(Val);
   if (B == nullptr)
     return Val;
 
   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.getValue(From))
-    Env.setValueStrict(To, *Val);
+    Env.setValue(To, *Val);
 }
 
 static void propagateStorageLocation(const Expr &From, const Expr &To,
                                      Environment &Env) {
-  if (auto *Loc = Env.getStorageLocationStrict(From))
-    Env.setStorageLocationStrict(To, *Loc);
+  if (auto *Loc = Env.getStorageLocation(From))
+    Env.setStorageLocation(To, *Loc);
 }
 
 // Propagates the value or storage location of `From` to `To` in cases where
 // `From` may be either a glvalue or a prvalue. `To` must be a glvalue iff
 // `From` is a glvalue.
 static void propagateValueOrStorageLocation(const Expr &From, const Expr &To,
                                             Environment &Env) {
   assert(From.isGLValue() == To.isGLValue());
void VisitBinaryOperator(const BinaryOperator *S) {
     const Expr *LHS = S->getLHS();
     assert(LHS != nullptr);
 
     const Expr *RHS = S->getRHS();
     assert(RHS != nullptr);
 
     switch (S->getOpcode()) {
     case BO_Assign: {
-      auto *LHSLoc = Env.getStorageLocationStrict(*LHS);
+      auto *LHSLoc = Env.getStorageLocation(*LHS);
       if (LHSLoc == nullptr)
         break;
 
       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.setStorageLocationStrict(*S, *LHSLoc);
+      Env.setStorageLocation(*S, *LHSLoc);
       break;
     }
     case BO_LAnd:
     case BO_LOr: {
       BoolValue &LHSVal = getLogicOperatorSubExprValue(*LHS);
       BoolValue &RHSVal = getLogicOperatorSubExprValue(*RHS);
 
       if (S->getOpcode() == BO_LAnd)
-        Env.setValueStrict(*S, Env.makeAnd(LHSVal, RHSVal));
+        Env.setValue(*S, Env.makeAnd(LHSVal, RHSVal));
       else
-        Env.setValueStrict(*S, Env.makeOr(LHSVal, RHSVal));
+        Env.setValue(*S, Env.makeOr(LHSVal, RHSVal));
       break;
     }
     case BO_NE:
     case BO_EQ: {
       auto &LHSEqRHSValue = evaluateBooleanEquality(*LHS, *RHS, Env);
-      Env.setValueStrict(*S, S->getOpcode() == BO_EQ
-                                 ? LHSEqRHSValue
+      Env.setValue(*S, S->getOpcode() == BO_EQ ? LHSEqRHSValue
                                                : Env.makeNot(LHSEqRHSValue));
       break;
     }
     case BO_Comma: {
       propagateValueOrStorageLocation(*RHS, *S, Env);
       break;
     }
     default:
       break;
void VisitDeclRefExpr(const DeclRefExpr *S) {
     if (auto *Method = dyn_cast<CXXMethodDecl>(VD);
         Method && !Method->isStatic())
       return;
 
     auto *DeclLoc = Env.getStorageLocation(*VD);
     if (DeclLoc == nullptr)
       return;
 
-    Env.setStorageLocationStrict(*S, *DeclLoc);
+    Env.setStorageLocation(*S, *DeclLoc);
   }
 
   void VisitDeclStmt(const DeclStmt *S) {
     // Group decls are converted into single decls in the CFG so the cast below
     // is safe.
     const auto &D = *cast<VarDecl>(S->getSingleDecl());
 
     ProcessVarDecl(D);
if (const auto *Decomp = dyn_cast<DecompositionDecl>(&D)) {
           if (DE == nullptr)
             continue;
 
           // ME and its base haven't been visited because they aren't included
           // in the statements of the CFG basic block.
           VisitDeclRefExpr(DE);
           VisitMemberExpr(ME);
 
-          if (auto *Loc = Env.getStorageLocationStrict(*ME))
+          if (auto *Loc = Env.getStorageLocation(*ME))
             Env.setStorageLocation(*B, *Loc);
         } else if (auto *VD = B->getHoldingVar()) {
           // Holding vars are used to back the `BindingDecl`s of tuple-like
           // types. The holding var declarations appear after the
           // `DecompositionDecl`, so we have to explicitly process them here
           // to know their storage location. They will be processed a second
           // time when we visit their `VarDecl`s, so we have code that protects
           // against this above.
void VisitImplicitCastExpr(const ImplicitCastExpr *S) {
 
     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.getValue(*SubExpr)))
-        Env.setValueStrict(*S, *SubExprVal);
+        Env.setValue(*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());
+        Env.setValue(*S, Env.makeAtomicBoolValue());
       break;
     }
 
     case CK_LValueToRValue: {
       // When an L-value is used as an R-value, it may result in sharing, so we
       // need to unpack any nested `Top`s. We also need to strip off the
       // `ReferenceValue` associated with the lvalue.
       auto *SubExprVal = maybeUnpackLValueExpr(*SubExpr, Env);
       if (SubExprVal == nullptr)
         break;
 
-      Env.setValueStrict(*S, *SubExprVal);
+      Env.setValue(*S, *SubExprVal);
       break;
     }
 
     case CK_IntegralCast:
       // FIXME: This cast creates a new integral value from the
       // subexpression. But, because we don't model integers, we don't
       // distinguish between this new value and the underlying one. If integer
       // modeling is added, then update this code to create a fresh location and
       // value.
     case CK_UncheckedDerivedToBase:
     case CK_ConstructorConversion:
     case CK_UserDefinedConversion:
       // FIXME: Add tests that excercise CK_UncheckedDerivedToBase,
       // CK_ConstructorConversion, and CK_UserDefinedConversion.
     case CK_NoOp: {
       // FIXME: Consider making `Environment::getStorageLocation` skip noop
       // expressions (this and other similar expressions in the file) instead
       // of assigning them storage locations.
       propagateValueOrStorageLocation(*SubExpr, *S, Env);
       break;
     }
     case CK_NullToPointer: {
       auto &NullPointerVal =
           Env.getOrCreateNullPointerValue(S->getType()->getPointeeType());
-      Env.setValueStrict(*S, NullPointerVal);
+      Env.setValue(*S, NullPointerVal);
       break;
     }
     case CK_NullToMemberPointer:
       // FIXME: Implement pointers to members. For now, don't associate a value
       // with this expression.
       break;
     case CK_FunctionToPointerDecay: {
-      StorageLocation *PointeeLoc = Env.getStorageLocationStrict(*SubExpr);
+      StorageLocation *PointeeLoc = Env.getStorageLocation(*SubExpr);
       if (PointeeLoc == nullptr)
         break;
 
-      Env.setValueStrict(*S, Env.create<PointerValue>(*PointeeLoc));
+      Env.setValue(*S, Env.create<PointerValue>(*PointeeLoc));
       break;
     }
     case CK_BuiltinFnToFnPtr:
       // Despite its name, the result type of `BuiltinFnToFnPtr` is a function,
       // not a function pointer. In addition, builtin functions can only be
       // called directly; it is not legal to take their address. We therefore
       // don't need to create a value or storage location for them.
       break;
     default:
       break;
     }
   }
 
   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.getValue(*SubExpr));
       if (SubExprVal == nullptr)
         break;
 
-      Env.setStorageLocationStrict(*S, SubExprVal->getPointeeLoc());
+      Env.setStorageLocation(*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));
+      if (StorageLocation *PointeeLoc = Env.getStorageLocation(*SubExpr))
+        Env.setValue(*S, Env.create<PointerValue>(*PointeeLoc));
       break;
     }
     case UO_LNot: {
       auto *SubExprVal = dyn_cast_or_null<BoolValue>(Env.getValue(*SubExpr));
       if (SubExprVal == nullptr)
         break;
 
-      Env.setValueStrict(*S, Env.makeNot(*SubExprVal));
+      Env.setValue(*S, Env.makeNot(*SubExprVal));
       break;
     }
     default:
       break;
     }
   }
 
   void VisitCXXThisExpr(const CXXThisExpr *S) {
     auto *ThisPointeeLoc = Env.getThisPointeeStorageLocation();
     if (ThisPointeeLoc == nullptr)
       // Unions are not supported yet, and will not have a location for the
       // `this` expression's pointee.
       return;
 
-    Env.setValueStrict(*S, Env.create<PointerValue>(*ThisPointeeLoc));
+    Env.setValue(*S, Env.create<PointerValue>(*ThisPointeeLoc));
   }
 
   void VisitCXXNewExpr(const CXXNewExpr *S) {
     if (Value *Val = Env.createValue(S->getType()))
-      Env.setValueStrict(*S, *Val);
+      Env.setValue(*S, *Val);
   }
 
   void VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
     // Empty method.
     // We consciously don't do anything on deletes.  Diagnosing double deletes
     // (for example) should be done by a specific analysis, not by the
     // framework.
   }
void VisitReturnStmt(const ReturnStmt *S) {
     if (Ret->isPRValue()) {
       auto *Val = Env.getValue(*Ret);
       if (Val == nullptr)
         return;
 
       // FIXME: Model NRVO.
       Env.setReturnValue(Val);
     } else {
-      auto *Loc = Env.getStorageLocationStrict(*Ret);
+      auto *Loc = Env.getStorageLocation(*Ret);
       if (Loc == nullptr)
         return;
 
       // FIXME: Model NRVO.
       Env.setReturnStorageLocation(Loc);
     }
   }
 
if (isa<EnumConstantDecl>(Member))
       return;
 
     if (auto *D = dyn_cast<VarDecl>(Member)) {
       if (D->hasGlobalStorage()) {
         auto *VarDeclLoc = Env.getStorageLocation(*D);
         if (VarDeclLoc == nullptr)
           return;
 
-        Env.setStorageLocationStrict(*S, *VarDeclLoc);
+        Env.setStorageLocation(*S, *VarDeclLoc);
         return;
       }
     }
 
     AggregateStorageLocation *BaseLoc = getBaseObjectLocation(*S, Env);
     if (BaseLoc == nullptr)
       return;
 
     auto *MemberLoc = BaseLoc->getChild(*Member);
     if (MemberLoc == nullptr)
       return;
-    Env.setStorageLocationStrict(*S, *MemberLoc);
+    Env.setStorageLocation(*S, *MemberLoc);
   }
 
   void VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) {
     const Expr *InitExpr = S->getExpr();
     assert(InitExpr != nullptr);
     propagateValueOrStorageLocation(*InitExpr, *S, Env);
   }
 
   void VisitCXXConstructExpr(const CXXConstructExpr *S) {
     const CXXConstructorDecl *ConstructorDecl = S->getConstructor();
     assert(ConstructorDecl != nullptr);
 
     if (ConstructorDecl->isCopyOrMoveConstructor()) {
       // It is permissible for a copy/move constructor to have additional
       // parameters as long as they have default arguments defined for them.
       assert(S->getNumArgs() != 0);
 
       const Expr *Arg = S->getArg(0);
       assert(Arg != nullptr);
 
-      auto *ArgLoc = cast_or_null<AggregateStorageLocation>(
-          Env.getStorageLocationStrict(*Arg));
+      auto *ArgLoc =
+          cast_or_null<AggregateStorageLocation>(Env.getStorageLocation(*Arg));
       if (ArgLoc == nullptr)
         return;
 
       if (S->isElidable()) {
         if (Value *Val = Env.getValue(*ArgLoc))
-          Env.setValueStrict(*S, *Val);
+          Env.setValue(*S, *Val);
       } else {
         auto &Val = *cast<StructValue>(Env.createValue(S->getType()));
-        Env.setValueStrict(*S, Val);
+        Env.setValue(*S, Val);
         copyRecord(*ArgLoc, Val.getAggregateLoc(), Env);
       }
       return;
     }
 
     // `CXXConstructExpr` can have array type if default-initializing an array
     // of records, and we currently can't create values for arrays. So check if
     // we've got a record type.
if (S->getOperator() == OO_Equal) {
       const auto *Method =
           dyn_cast_or_null<CXXMethodDecl>(S->getDirectCallee());
       if (!Method)
         return;
       if (!Method->isCopyAssignmentOperator() &&
           !Method->isMoveAssignmentOperator())
         return;
 
-      auto *LocSrc = cast_or_null<AggregateStorageLocation>(
-          Env.getStorageLocationStrict(*Arg1));
-      auto *LocDst = cast_or_null<AggregateStorageLocation>(
-          Env.getStorageLocationStrict(*Arg0));
+      auto *LocSrc =
+          cast_or_null<AggregateStorageLocation>(Env.getStorageLocation(*Arg1));
+      auto *LocDst =
+          cast_or_null<AggregateStorageLocation>(Env.getStorageLocation(*Arg0));
 
       if (LocSrc != nullptr && LocDst != nullptr) {
         copyRecord(*LocSrc, *LocDst, Env);
-        Env.setStorageLocationStrict(*S, *LocDst);
+        Env.setStorageLocation(*S, *LocDst);
       }
     }
   }
 
   void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) {
     if (S->getCastKind() == CK_ConstructorConversion) {
       const Expr *SubExpr = S->getSubExpr();
       assert(SubExpr != nullptr);
 
       propagateValue(*SubExpr, *S, Env);
     }
   }
 
   void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) {
     if (Value *Val = Env.createValue(S->getType()))
-      Env.setValueStrict(*S, *Val);
+      Env.setValue(*S, *Val);
   }
 
   void VisitCallExpr(const CallExpr *S) {
     // Of clang's builtins, only `__builtin_expect` is handled explicitly, since
     // others (like trap, debugtrap, and unreachable) are handled by CFG
     // construction.
     if (S->isCallToStdMove()) {
       assert(S->getNumArgs() == 1);
 
       const Expr *Arg = S->getArg(0);
       assert(Arg != nullptr);
 
-      auto *ArgLoc = Env.getStorageLocationStrict(*Arg);
+      auto *ArgLoc = Env.getStorageLocation(*Arg);
       if (ArgLoc == nullptr)
         return;
 
-      Env.setStorageLocationStrict(*S, *ArgLoc);
+      Env.setStorageLocation(*S, *ArgLoc);
     } else if (S->getDirectCallee() != nullptr &&
                S->getDirectCallee()->getBuiltinID() ==
                    Builtin::BI__builtin_expect) {
       assert(S->getNumArgs() > 0);
       assert(S->getArg(0) != nullptr);
       auto *ArgVal = Env.getValue(*S->getArg(0));
       if (ArgVal == nullptr)
         return;
-      Env.setValueStrict(*S, *ArgVal);
+      Env.setValue(*S, *ArgVal);
     } else if (const FunctionDecl *F = S->getDirectCallee()) {
       transferInlineCall(S, F);
     }
   }
 
   void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *S) {
     const Expr *SubExpr = S->getSubExpr();
     assert(SubExpr != nullptr);
 
     Value *SubExprVal = Env.getValue(*SubExpr);
     if (SubExprVal == nullptr)
       return;
 
     if (StructValue *StructVal = dyn_cast<StructValue>(SubExprVal)) {
-      Env.setStorageLocationStrict(*S, StructVal->getAggregateLoc());
+      Env.setStorageLocation(*S, StructVal->getAggregateLoc());
       return;
     }
 
     StorageLocation &Loc = Env.createStorageLocation(*S);
     Env.setValue(Loc, *SubExprVal);
-    Env.setStorageLocationStrict(*S, Loc);
+    Env.setStorageLocation(*S, Loc);
   }
 
   void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) {
     const Expr *SubExpr = S->getSubExpr();
     assert(SubExpr != nullptr);
 
     propagateValue(*SubExpr, *S, Env);
   }
 
   void VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) {
     if (S->getCastKind() == CK_NoOp) {
       const Expr *SubExpr = S->getSubExpr();
       assert(SubExpr != nullptr);
 
       propagateValueOrStorageLocation(*SubExpr, *S, Env);
     }
   }
 
   void VisitConditionalOperator(const ConditionalOperator *S) {
     // FIXME: Revisit this once flow conditions are added to the framework. For
     // `a = b ? c : d` we can add `b => a == c && !b => a == d` to the flow
     // condition.
     if (S->isGLValue())
-      Env.setStorageLocationStrict(*S, Env.createObject(S->getType()));
+      Env.setStorageLocation(*S, Env.createObject(S->getType()));
     else if (Value *Val = Env.createValue(S->getType()))
-      Env.setValueStrict(*S, *Val);
+      Env.setValue(*S, *Val);
   }
 
   void VisitInitListExpr(const InitListExpr *S) {
     QualType Type = S->getType();
 
     if (!Type->isStructureOrClassType()) {
       if (auto *Val = Env.createValue(Type))
-        Env.setValueStrict(*S, *Val);
+        Env.setValue(*S, *Val);
 
       return;
     }
 
     // In case the initializer list is transparent, we just need to propagate
     // the value that it contains.
     if (S->isSemanticForm() && S->isTransparent()) {
       propagateValue(*S->getInit(0), *S, Env);
void VisitInitListExpr(const InitListExpr *S) {
     auto &Loc =
         Env.getDataflowAnalysisContext()
             .arena()
             .create<AggregateStorageLocation>(Type, std::move(FieldLocs));
     StructValue &StructVal = Env.create<StructValue>(Loc);
 
     Env.setValue(Loc, StructVal);
 
-    Env.setValueStrict(*S, StructVal);
+    Env.setValue(*S, StructVal);
 
     // FIXME: Implement array initialization.
   }
 
   void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
-    Env.setValueStrict(*S, Env.getBoolLiteralValue(S->getValue()));
+    Env.setValue(*S, Env.getBoolLiteralValue(S->getValue()));
   }
 
   void VisitIntegerLiteral(const IntegerLiteral *S) {
-    Env.setValueStrict(*S, Env.getIntLiteralValue(S->getValue()));
+    Env.setValue(*S, Env.getIntLiteralValue(S->getValue()));
   }
 
   void VisitParenExpr(const ParenExpr *S) {
     // The CFG does not contain `ParenExpr` as top-level statements in basic
     // blocks, however manual traversal to sub-expressions may encounter them.
     // Redirect to the sub-expression.
     auto *SubExpr = S->getSubExpr();
     assert(SubExpr != nullptr);

clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

TerminatorVisitorRetTy extendFlowCondition(const Expr &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);
+      Env.setValue(Cond, *Val);
     }
 
     bool ConditionValue = true;
     // The condition must be inverted for the successor that encompasses the
     // "else" branch, if such exists.
     if (BlockSuccIdx == 1) {
       Val = &Env.makeNot(*Val);
       ConditionValue = false;
builtinTransferInitializer(const CFGInitializer &Elt,
   // FIXME: Instead of these case distinctions, we would ideally want to be able
   // to simply use `Environment::createObject()` here, the same way that we do
   // this in `TransferVisitor::VisitInitListExpr()`. However, this would require
   // us to be able to build a list of fields that we then use to initialize an
   // `AggregateStorageLocation` -- and the problem is that, when we get here,
   // 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);
+    auto *InitExprLoc = Env.getStorageLocation(*InitExpr);
     if (InitExprLoc == nullptr)
       return;
 
     ParentLoc->setChild(*Member, InitExprLoc);
   } 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

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

TEST_F(EnvironmentTest, RefreshStructValue) {
   const auto *Target = selectFirst<FunctionDecl>("target", Results);
   ASSERT_THAT(Target, NotNull());
 
   Results = match(declRefExpr(to(varDecl(hasName("s")))).bind("s"), Context);
   const auto *DRE = selectFirst<DeclRefExpr>("s", Results);
   ASSERT_THAT(DRE, NotNull());
 
   Environment Env(DAContext, *Target);
-  EXPECT_THAT(Env.getStorageLocationStrict(*DRE), IsNull());
+  EXPECT_THAT(Env.getStorageLocation(*DRE), IsNull());
   refreshStructValue(*DRE, Env);
-  EXPECT_THAT(Env.getStorageLocationStrict(*DRE), NotNull());
+  EXPECT_THAT(Env.getStorageLocation(*DRE), NotNull());
 }
 
 } // namespace

clang/unittests/Analysis/FlowSensitive/SignAnalysisTest.cpp

getValueAndSignProperties(const UnaryOperator *UO,
   const auto *OperandValue = State.Env.getValue(*OperandVar);
   if (!OperandValue)
     return {nullptr, {}, {}};
 
   // Value of the unary op.
   auto *UnaryOpValue = State.Env.getValue(*UO);
   if (!UnaryOpValue) {
     UnaryOpValue = &State.Env.makeAtomicBoolValue();
-    State.Env.setValueStrict(*UO, *UnaryOpValue);
+    State.Env.setValue(*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.getValue(*BO))) {
     Comp = &V->formula();
   } else {
     Comp = &A.makeAtomRef(A.makeAtom());
-    State.Env.setValueStrict(*BO, A.makeBoolValue(*Comp));
+    State.Env.setValue(*BO, A.makeBoolValue(*Comp));
   }
 
   // FIXME Use this as well:
   // auto *NegatedComp = &State.Env.makeNot(*Comp);
 
   auto *LHS = State.Env.getValue(*BO->getLHS());
   auto *RHS = State.Env.getValue(*BO->getRHS());
 

 // glvalue). Creates a `Value` or `StorageLocation` as needed if `E` does not
 // have either of these associated with it yet.
 //
 // If this functionality turns out to be needed in more cases, this function
 // should be moved to a more central location.
 Value *getOrCreateValue(const Expr *E, Environment &Env) {
   Value *Val = nullptr;
   if (E->isGLValue()) {
-    StorageLocation *Loc = Env.getStorageLocationStrict(*E);
+    StorageLocation *Loc = Env.getStorageLocation(*E);
     if (!Loc) {
       Loc = &Env.createStorageLocation(*E);
-      Env.setStorageLocationStrict(*E, *Loc);
+      Env.setStorageLocation(*E, *Loc);
     }
     Val = Env.getValue(*Loc);
     if (!Val) {
       Val = Env.createValue(E->getType());
       Env.setValue(*Loc, *Val);
     }
   } else {
     Val = Env.getValue(*E);
     if (!Val) {
       Val = Env.createValue(E->getType());
-      Env.setValueStrict(*E, *Val);
+      Env.setValue(*E, *Val);
     }
   }
   assert(Val != nullptr);
 
   return Val;
 }
 
 void transferExpr(const Expr *E, const MatchFinder::MatchResult &M,

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

void transfer(const CFGElement &Elt, NoopLattice &, Environment &Env) {
     auto CS = Elt.getAs<CFGStmt>();
     if (!CS)
       return;
     const Stmt *S = CS->getStmt();
     SmallVector<BoundNodes, 1> Matches =
         match(callExpr(callee(functionDecl(hasName("makeTop")))).bind("top"),
               *S, getASTContext());
     if (const auto *E = selectFirst<CallExpr>("top", Matches)) {
-      Env.setValueStrict(*E, Env.makeTopBoolValue());
+      Env.setValue(*E, Env.makeTopBoolValue());
     }
   }
 
   ComparisonResult compare(QualType Type, const Value &Val1,
                            const Environment &Env1, const Value &Val2,
                            const Environment &Env2) override {
     // Changes to a sound approximation, which allows us to test whether we can
     // (soundly) converge for some loops.