[ASTImporter] Merge ExprBits

[martong]

Summary

Some Expr classes set up default values for the ExprBits of Stmt. These
default values are then overwritten by the parser sometimes. One example is
InitListExpr which sets the value kind to be an rvalue in the ctor. However,
this bit may change after the InitListExpr is created. There may be other
expressions similar to InitListExpr in this sense, thus the safest solution
is to copy the expression bits.

The lack of copying ExprBits causes an assertion in the analyzer engine in a
specific case: Since the value kind is not imported, the analyzer engine
believes that the given InitListExpr is an rvalue, thus it creates a
nonloc::CompoundVal instead of creating memory region (as in case of an lvalue
reference).

[a_sidorin]

Looks good, thanks!

unittests/AST/ASTImporterTest.cpp

3241 ↗

(On Diff #163494)

EXPECT_TRUE (same below).

[martong]

unittests/AST/ASTImporterTest.cpp

3241 ↗

(On Diff #163494)

Thanks, changed it.

cfe/trunk/lib/AST/ASTImporter.cpp

Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
 
   if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
     auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
     if (!ToSyntForm)
       return nullptr;
     To->setSyntacticForm(ToSyntForm);
   }
 
+  // Copy InitListExprBitfields, which are not handled in the ctor of
+  // InitListExpr.
   To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
-  To->setValueDependent(ILE->isValueDependent());
-  To->setInstantiationDependent(ILE->isInstantiationDependent());
 
   return To;
 }
 
 Expr *ASTNodeImporter::VisitCXXStdInitializerListExpr(
     CXXStdInitializerListExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
if (Pos != ImportedStmts.end())
     return Pos->second;
 
   // Import the type
   ASTNodeImporter Importer(*this);
   Stmt *ToS = Importer.Visit(FromS);
   if (!ToS)
     return nullptr;
 
+  if (auto *ToE = dyn_cast<Expr>(ToS)) {
+    auto *FromE = cast<Expr>(FromS);
+    // Copy ExprBitfields, which may not be handled in Expr subclasses
+    // constructors.
+    ToE->setValueKind(FromE->getValueKind());
+    ToE->setObjectKind(FromE->getObjectKind());
+    ToE->setTypeDependent(FromE->isTypeDependent());
+    ToE->setValueDependent(FromE->isValueDependent());
+    ToE->setInstantiationDependent(FromE->isInstantiationDependent());
+    ToE->setContainsUnexpandedParameterPack(
+        FromE->containsUnexpandedParameterPack());
+  }
+
   // Record the imported declaration.
   ImportedStmts[FromS] = ToS;
   return ToS;
 }
 
 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
   if (!FromNNS)
     return nullptr;

cfe/trunk/unittests/AST/ASTImporterTest.cpp

TEST_P(ASTImporterTestBase, ClassTemplateFullAndPartialSpecsShouldNotBeMixed) {
   EXPECT_EQ(1u, DeclCounter<ClassTemplatePartialSpecializationDecl>().match(
                     ToTU, classTemplatePartialSpecializationDecl()));
   // Check the number of full specializations.
   EXPECT_EQ(1u, DeclCounter<ClassTemplateSpecializationDecl>().match(
                     ToTU, classTemplateSpecializationDecl(
                               unless(classTemplatePartialSpecializationDecl()))));
 }
 
+TEST_P(ASTImporterTestBase, InitListExprValueKindShouldBeImported) {
+  Decl *TU = getTuDecl(
+      R"(
+      const int &init();
+      void foo() { const int &a{init()}; }
+      )", Lang_CXX11, "input0.cc");
+  auto *FromD = FirstDeclMatcher<VarDecl>().match(TU, varDecl(hasName("a")));
+  ASSERT_TRUE(FromD->getAnyInitializer());
+  auto *InitExpr = FromD->getAnyInitializer();
+  ASSERT_TRUE(InitExpr);
+  ASSERT_TRUE(InitExpr->isGLValue());
+
+  auto *ToD = Import(FromD, Lang_CXX11);
+  EXPECT_TRUE(ToD);
+  auto *ToInitExpr = cast<VarDecl>(ToD)->getAnyInitializer();
+  EXPECT_TRUE(ToInitExpr);
+  EXPECT_TRUE(ToInitExpr->isGLValue());
+}
+
 struct DeclContextTest : ASTImporterTestBase {};
 
 TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
   Decl *TU = getTuDecl(
       R"(
       namespace NS {
 
       template <typename T>