[clang][dataflow] Fix missed fields in field set construction.

[ymandel]

Summary

When building the set of referenced fields for the DataflowAnalysisContext,
include fields referenced only in default member initializers. These
initializers are visited in the CFGs of constructors and so the fields must be
included when analysing constructor bodies.

[gribozavr2]

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

141

Is foo() used for anything in this test?

[ymandel]

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

141

not that I can see. looks left over from some previous version. want to remove it?

[gribozavr2]

clang/unittests/Analysis/FlowSensitive/DataflowEnvironmentTest.cpp

141

Actually it is load-bearing: the qualType() matcher below matches the return type of the function.

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

Environment::Environment(DataflowAnalysisContext &DACtx,
   CallStack.push_back(&DeclCtx);
 
   if (const auto *FuncDecl = dyn_cast<FunctionDecl>(&DeclCtx)) {
     assert(FuncDecl->getBody() != nullptr);
 
     llvm::DenseSet<const FieldDecl *> Fields;
     llvm::DenseSet<const VarDecl *> Vars;
 
-    // Look for global variable references in the constructor-initializers.
+    // Look for global variable and field references in the
+    // constructor-initializers.
     if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(&DeclCtx)) {
       for (const auto *Init : CtorDecl->inits()) {
         if (const auto *M = Init->getAnyMember())
           Fields.insert(M);
         const Expr *E = Init->getInit();
         assert(E != nullptr);
         getFieldsAndGlobalVars(*E, Fields, Vars);
       }
+      // Add all fields mentioned in default member initializers.
+      for (const FieldDecl *F  : CtorDecl->getParent()->fields())
+        if (const auto *I = F->getInClassInitializer())
+          getFieldsAndGlobalVars(*I, Fields, Vars);
     }
     getFieldsAndGlobalVars(*FuncDecl->getBody(), Fields, Vars);
 
     // These have to be added before the lines that follow to ensure that
     // `create*` work correctly for structs.
     DACtx.addModeledFields(Fields);
 
     initVars(Vars);

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/NoopAnalysis.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;
TEST_F(EnvironmentTest, InitGlobalVarsFun) {
   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());
 }
 
+// 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(
+     struct S {
+     S() {}
+     int X = 3;
+     int Y = X;
+     };
+     S foo();
+  )cc";
+
+  auto Unit =
+      tooling::buildASTFromCodeWithArgs(Code, {"-fsyntax-only", "-std=c++11"});
+  auto &Context = Unit->getASTContext();
+
+  ASSERT_EQ(Context.getDiagnostics().getClient()->getNumErrors(), 0U);
+
+  auto Results = match(
+      qualType(hasDeclaration(
+                   cxxRecordDecl(hasName("S"),
+                                 hasMethod(cxxConstructorDecl().bind("target")))
+                       .bind("struct")))
+          .bind("ty"),
+      Context);
+  const auto *Constructor = selectFirst<FunctionDecl>("target", Results);
+  const auto *Rec = selectFirst<RecordDecl>("struct", Results);
+  const auto QTy = *selectFirst<QualType>("ty", Results);
+  ASSERT_THAT(Constructor, NotNull());
+  ASSERT_THAT(Rec, NotNull());
+  ASSERT_FALSE(QTy.isNull());
+
+  auto Fields = Rec->fields();
+  FieldDecl *XDecl = nullptr;
+  for (FieldDecl *Field : Fields) {
+    if (Field->getNameAsString() == "X") {
+      XDecl = Field;
+      break;
+    }
+  }
+  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());
+}
+
 TEST_F(EnvironmentTest, InitGlobalVarsFieldFun) {
   using namespace ast_matchers;
 
   std::string Code = R"cc(
      struct S { int Bar; };
      S Global = {0};
      int Target () { return Global.Bar; }
   )cc";