[clang][dataflow] Introduce `getFieldValue()` test helpers.

[mboehme]

Summary

These insulate tests against changes to the getChild() functions of AggregateStorageLocation and StructValue that will happen as part of the migration to strict handling of value categories (see https://discourse.llvm.org/t/70086 for details):

• AggregateStorageLocation::getChild() will soon return a StorageLocation * instead of a StorageLocation &. When this happens, getFieldValue() will be changed to return null if AggregateStorageLocation::getChild() returns null; test code will not need to change as it should already be checking whether the return value of getFieldValue() is null.

• StructValue::getChild() will soon return a StorageLocation * instead of a Value *. When this happens, getFieldValue() will be changed to look up the Value * in the Environment. Again, test code will not need to change.

The test helpers will continue to serve a useful purpose once the API changes are complete, so the intent is to leave them in place.

This patch changes DataflowEnvironmentTest.cpp and RecordOpsTest.cpp to use the test helpers. TransferTest.cpp will be changed in an upcoming patch to help keep patch sizes manageable for review.

Depends On D154934

[mboehme]

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

95

Using the opportunity to simplify the code here a bit: If we cast<>, we don't need to assert for non-nullness because cast<> already does that.

[gribozavr2]

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

27

[xazax.hun]

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

94–96

[mboehme]

Changes in response to review comments

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

 //===- unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
+#include "TestingSupport.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysisContext.h"
 #include "clang/Analysis/FlowSensitive/StorageLocation.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 #include "clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h"
 #include "clang/Tooling/Tooling.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 namespace {
 
 using namespace clang;
 using namespace dataflow;
+using ::clang::dataflow::test::getFieldValue;
 using ::testing::ElementsAre;
 using ::testing::NotNull;
 using ::testing::Pair;
 
 class EnvironmentTest : public ::testing::Test {
 protected:
   EnvironmentTest() : DAContext(std::make_unique<WatchedLiteralsSolver>()) {}
 
TEST_F(EnvironmentTest, CreateValueRecursiveType) {
 
   Results = match(functionDecl(hasName("Usage")).bind("fun"), Context);
   const auto *Fun = selectFirst<FunctionDecl>("fun", Results);
   ASSERT_THAT(Fun, NotNull());
 
   // Verify that the struct and the field (`R`) with first appearance of the
   // type is created successfully.
   Environment Env(DAContext, *Fun);
-  Value *Val = Env.createValue(Ty);
-  ASSERT_NE(Val, nullptr);
-  StructValue *SVal = clang::dyn_cast<StructValue>(Val);
-  ASSERT_NE(SVal, nullptr);
-  Val = SVal->getChild(*R);
-  ASSERT_NE(Val, nullptr);
-  PointerValue *PV = clang::dyn_cast<PointerValue>(Val);
-  EXPECT_NE(PV, nullptr);
+  StructValue *SVal = cast<StructValue>(Env.createValue(Ty));
+  PointerValue *PV = cast_or_null<PointerValue>(getFieldValue(SVal, *R, Env));
+  EXPECT_THAT(PV, NotNull());
 }
 
 TEST_F(EnvironmentTest, InitGlobalVarsFun) {
   using namespace ast_matchers;
 
   std::string Code = R"cc(
      int Global = 0;
      int Target () { return Global; }
for (FieldDecl *Field : Fields) {
     }
   }
   ASSERT_THAT(XDecl, NotNull());
 
   // Verify that the `X` field of `S` is populated when analyzing the
   // constructor, even though it is not referenced directly in the constructor.
   Environment Env(DAContext, *Constructor);
   auto *Val = cast<StructValue>(Env.createValue(QTy));
-  ASSERT_THAT(Val, NotNull());
-  EXPECT_THAT(Val->getChild(*XDecl), NotNull());
+  EXPECT_THAT(getFieldValue(Val, *XDecl, Env), NotNull());
 }
 
 TEST_F(EnvironmentTest, InitGlobalVarsFieldFun) {
   using namespace ast_matchers;
 
   std::string Code = R"cc(
      struct S { int Bar; };
      S Global = {0};
TEST_F(EnvironmentTest, InitGlobalVarsFieldFun) {
   }
   ASSERT_THAT(BarDecl, NotNull());
 
   // Verify the global variable is populated when we analyze `Target`.
   Environment Env(DAContext, *Fun);
   const auto *GlobalLoc =
       cast<AggregateStorageLocation>(Env.getStorageLocation(*GlobalDecl));
   const auto *GlobalVal = cast<StructValue>(Env.getValue(*GlobalLoc));
-  const auto *BarVal = GlobalVal->getChild(*BarDecl);
-  ASSERT_THAT(BarVal, NotNull());
+  auto *BarVal = getFieldValue(GlobalVal, *BarDecl, Env);
   EXPECT_TRUE(isa<IntegerValue>(BarVal));
 }
 
 TEST_F(EnvironmentTest, InitGlobalVarsConstructor) {
   using namespace ast_matchers;
 
   std::string Code = R"cc(
      int Global = 0;

clang/unittests/Analysis/FlowSensitive/RecordOpsTest.cpp

runDataflow(
         const ValueDecl *InnerDecl = findValueDecl(ASTCtx, "inner");
         const ValueDecl *InnerIntDecl = findValueDecl(ASTCtx, "inner_int");
 
         auto &S1 = getLocForDecl<AggregateStorageLocation>(ASTCtx, Env, "s1");
         auto &S2 = getLocForDecl<AggregateStorageLocation>(ASTCtx, Env, "s2");
         auto &Inner1 = cast<AggregateStorageLocation>(S1.getChild(*InnerDecl));
         auto &Inner2 = cast<AggregateStorageLocation>(S2.getChild(*InnerDecl));
 
-        EXPECT_NE(Env.getValue(S1.getChild(*OuterIntDecl)),
-                  Env.getValue(S2.getChild(*OuterIntDecl)));
+        EXPECT_NE(getFieldValue(&S1, *OuterIntDecl, Env),
+                  getFieldValue(&S2, *OuterIntDecl, Env));
         EXPECT_NE(Env.getValue(S1.getChild(*RefDecl)),
                   Env.getValue(S2.getChild(*RefDecl)));
-        EXPECT_NE(Env.getValue(Inner1.getChild(*InnerIntDecl)),
-                  Env.getValue(Inner2.getChild(*InnerIntDecl)));
+        EXPECT_NE(getFieldValue(&Inner1, *InnerIntDecl, Env),
+                  getFieldValue(&Inner2, *InnerIntDecl, Env));
 
         auto *S1Val = cast<StructValue>(Env.getValue(S1));
         auto *S2Val = cast<StructValue>(Env.getValue(S2));
         EXPECT_NE(S1Val, S2Val);
 
         S1Val->setProperty("prop", Env.getBoolLiteralValue(true));
 
         copyRecord(S1, S2, Env);
 
-        EXPECT_EQ(Env.getValue(S1.getChild(*OuterIntDecl)),
-                  Env.getValue(S2.getChild(*OuterIntDecl)));
+        EXPECT_EQ(getFieldValue(&S1, *OuterIntDecl, Env),
+                  getFieldValue(&S2, *OuterIntDecl, Env));
         EXPECT_EQ(Env.getValue(S1.getChild(*RefDecl)),
                   Env.getValue(S2.getChild(*RefDecl)));
-        EXPECT_EQ(Env.getValue(Inner1.getChild(*InnerIntDecl)),
-                  Env.getValue(Inner2.getChild(*InnerIntDecl)));
+        EXPECT_EQ(getFieldValue(&Inner1, *InnerIntDecl, Env),
+                  getFieldValue(&Inner2, *InnerIntDecl, Env));
 
         S1Val = cast<StructValue>(Env.getValue(S1));
         S2Val = cast<StructValue>(Env.getValue(S2));
         EXPECT_NE(S1Val, S2Val);
 
         EXPECT_EQ(S2Val->getProperty("prop"), &Env.getBoolLiteralValue(true));
       });
 }

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

 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));
 }
 
+/// Returns the value of a `Field` on the record referenced by `Loc.`
+/// Returns null if `Loc` is null.
+inline Value *getFieldValue(const AggregateStorageLocation *Loc,
+                            const ValueDecl &Field, const Environment &Env) {
+  if (Loc == nullptr)
+    return nullptr;
+  return Env.getValue(Loc->getChild(Field));
+}
+
+/// Returns the value of a `Field` on a `Struct.
+/// Returns null if `Struct` is null.
+///
+/// Note: This function currently does not use the `Env` parameter, but it will
+/// soon be needed to look up the `Value` when `setChild()` changes to return a
+/// `StorageLocation *`.
+inline Value *getFieldValue(const StructValue *Struct, const ValueDecl &Field,
+                            const Environment &Env) {
+  if (Struct == nullptr)
+    return nullptr;
+  return Struct->getChild(Field);
+}
+
 /// Creates and owns constraints which are boolean values.
 class ConstraintContext {
   unsigned NextAtom = 0;
   llvm::BumpPtrAllocator A;
 
   const Formula *make(Formula::Kind K,
                       llvm::ArrayRef<const Formula *> Operands) {
     return &Formula::create(A, K, Operands);