[clang][dataflow] Various refactorings in TypeErasedDataflowAnalysisTest.cpp

[mboehme]

Summary

These simplify the code in their own right, but they are also useful in that they minimize the number of changes that will need to be made when then API of AggregateStorageLocation and StructValue changes as part of the migration to strict handling of value categories (see https://discourse.llvm.org/t/70086).

Depends On D154949

[mboehme]

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

400–401

This works because we know that constructor has already created a fresh value for E.

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

std::string Code = R"(
     }
   )";
   runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
                         "p", HoldsFunctionCallLattice(HasCalledFunctions(
                                  UnorderedElementsAre("baz", "foo"))))));
   // FIXME: Called functions at point `p` should contain only "foo".
 }
 
+StructValue &createNewStructValue(AggregateStorageLocation &Loc,
+                                  Environment &Env) {
+  auto &Val = *cast<StructValue>(Env.createValue(Loc.getType()));
+  Env.setValue(Loc, Val);
+  return Val;
+}
+
 // Models an analysis that uses flow conditions.
 class SpecialBoolAnalysis final
     : public DataflowAnalysis<SpecialBoolAnalysis, NoopLattice> {
 public:
   explicit SpecialBoolAnalysis(ASTContext &Context)
       : DataflowAnalysis<SpecialBoolAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return {}; }
 
   void transfer(const CFGElement &Elt, NoopLattice &, Environment &Env) {
     auto CS = Elt.getAs<CFGStmt>();
     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()))) {
-      auto &ConstructorVal = *Env.createValue(E->getType());
-      ConstructorVal.setProperty("is_set", Env.getBoolLiteralValue(false));
-      Env.setValue(*Env.getStorageLocation(*E, SkipPast::None), ConstructorVal);
+      cast<StructValue>(Env.getValueStrict(*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 *Object = E->getImplicitObjectArgument();
-      assert(Object != nullptr);
-
-      auto *ObjectLoc = getImplicitObjectLocation(*E, Env);
-      assert(ObjectLoc != nullptr);
+      auto &ObjectLoc =
+          *cast<AggregateStorageLocation>(getImplicitObjectLocation(*E, Env));
 
-      auto &ConstructorVal = *Env.createValue(Object->getType());
-      ConstructorVal.setProperty("is_set", Env.getBoolLiteralValue(true));
-      Env.setValue(*ObjectLoc, ConstructorVal);
+      createNewStructValue(ObjectLoc, Env)
+          .setProperty("is_set", Env.getBoolLiteralValue(true));
     }
   }
 
   ComparisonResult compare(QualType Type, const Value &Val1,
                            const Environment &Env1, const Value &Val2,
                            const Environment &Env2) override {
     const auto *Decl = Type->getAsCXXRecordDecl();
     if (Decl == nullptr || Decl->getIdentifier() == nullptr ||
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)) {
-      auto &ConstructorVal = *Env.createValue(E->getType());
-      ConstructorVal.setProperty("has_value", Env.getBoolLiteralValue(false));
-      Env.setValue(*Env.getStorageLocation(*E, SkipPast::None), ConstructorVal);
+      cast<StructValue>(Env.getValueStrict(*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);
 
-      auto *ObjectLoc = Env.getStorageLocation(*Object, SkipPast::Reference);
-      assert(ObjectLoc != nullptr);
+      auto &ObjectLoc = *cast<AggregateStorageLocation>(
+          Env.getStorageLocation(*Object, SkipPast::Reference));
 
-      auto &ConstructorVal = *Env.createValue(Object->getType());
-      ConstructorVal.setProperty("has_value", Env.getBoolLiteralValue(true));
-      Env.setValue(*ObjectLoc, ConstructorVal);
+      createNewStructValue(ObjectLoc, Env)
+          .setProperty("has_value", Env.getBoolLiteralValue(true));
     }
   }
 
   ComparisonResult compare(QualType Type, const Value &Val1,
                            const Environment &Env1, const Value &Val2,
                            const Environment &Env2) override {
     // Nothing to say about a value that does not model an `OptionalInt`.
     if (!Type->isRecordType() ||
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)) {
-      auto &Loc = Env.createStorageLocation(*E);
-      Env.setValue(Loc, Env.makeTopBoolValue());
-      Env.setStorageLocation(*E, Loc);
+      Env.setValueStrict(*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.