[clang][AST] Add support for BindingDecl to ASTImporter.

[shafik]

clang/unittests/AST/ASTImporterTest.cpp

887

Can we add a larger variety of tests? Given how simple the BindingDecl case seems to be I don't expect any surprises but it would be good to verify that cases like mixed types, references and bit-fields work as expected.

[balazske]

Improved the test.

[balazske]

This change in itself is not enough to support BindingDecl. The tests pass but the resulting AST is not correct because DecompositionDecl is not imported yet. Still no visible problem happens, the DecompositionDecl is just visited and imported as a VarDecl. The import of DecompositionDecl can be added later (but I am not sure if without it the new import of BindingDecl will not cause hidden problems).

clang/unittests/AST/ASTImporterTest.cpp

887

Improved the test variety a bit. (std::tuple is more difficult to handle because need for namespace std.)

[martong]

I like it, though I've found a nit.

clang/lib/AST/ASTImporter.cpp

2318

Should we use rather addDeclToContexts ?

[balazske]

Using addDeclToContexts.

[balazske]

Ping.

[martong]

LGTM! Thanks!

[balazske]

Not using auto declarations.

[martong]

In D102492#2854811, @balazske wrote:

Not using auto declarations.

Still looks good, thanks!

clang/lib/AST/ASTImporter.cpp

public:
     bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
     bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
     ExpectedDecl VisitDecl(Decl *D);
     ExpectedDecl VisitImportDecl(ImportDecl *D);
     ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
     ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
     ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
     ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
+    ExpectedDecl VisitBindingDecl(BindingDecl *D);
     ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
     ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
     ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
     ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
     ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
     ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
     ExpectedDecl VisitLabelDecl(LabelDecl *D);
     ExpectedDecl VisitEnumDecl(EnumDecl *D);
ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
   TranslationUnitDecl *ToD =
     Importer.getToContext().getTranslationUnitDecl();
 
   Importer.MapImported(D, ToD);
 
   return ToD;
 }
 
+ExpectedDecl ASTNodeImporter::VisitBindingDecl(BindingDecl *D) {
+  DeclContext *DC, *LexicalDC;
+  DeclarationName Name;
+  SourceLocation Loc;
+  NamedDecl *ToND;
+  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToND, Loc))
+    return std::move(Err);
+  if (ToND)
+    return ToND;
+
+  Error Err = Error::success();
+  QualType ToType = importChecked(Err, D->getType());
+  Expr *ToBinding = importChecked(Err, D->getBinding());
+  ValueDecl *ToDecomposedDecl = importChecked(Err, D->getDecomposedDecl());
+  if (Err)
+    return std::move(Err);
+
+  BindingDecl *ToD;
+  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc,
+                              Name.getAsIdentifierInfo()))
+    return ToD;
+
+  ToD->setBinding(ToType, ToBinding);
+  ToD->setDecomposedDecl(ToDecomposedDecl);
+  addDeclToContexts(D, ToD);
+
+  return ToD;
+}
+
 ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
   ExpectedSLoc LocOrErr = import(D->getLocation());
   if (!LocOrErr)
     return LocOrErr.takeError();
   auto ColonLocOrErr = import(D->getColonLoc());
   if (!ColonLocOrErr)
     return ColonLocOrErr.takeError();
 

clang/unittests/AST/ASTImporterTest.cpp

TEST_P(ImportDecl, ImportUsingShadowDecl) {
   testImport("namespace foo { enum bar {baz, toto, quux }; }"
              "namespace declToImport { using enum foo::bar; }",
              Lang_CXX20, "", Lang_CXX20, Verifier,
              namespaceDecl(has(usingShadowDecl(hasName("baz")))));
 }
 
 TEST_P(ImportExpr, ImportUnresolvedLookupExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template<typename T> int foo();"
              "template <typename T> void declToImport() {"
              "  (void)::foo<T>;"
              "  (void)::template foo<T>;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasDescendant(unresolvedLookupExpr())));
 }
TEST_P(ImportVariables, InitAndDefinitionAreInTheFromContext) {
   ASSERT_FALSE(ToD->getInit());
   ASSERT_FALSE(ToD->getDefinition());
 
   auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
   EXPECT_TRUE(ImportedD->getAnyInitializer());
   EXPECT_TRUE(ImportedD->getDefinition());
 }
 
+TEST_P(ImportVariables, ImportBindingDecl) {
+  Decl *From, *To;
+  std::tie(From, To) = getImportedDecl(
+      R"(
+      void declToImport() {
+        int a[2] = {1,2};
+        auto [x1,y1] = a;
+        auto& [x2,y2] = a;
+        
+        struct S {
+          mutable int x1 : 2;
+          volatile double y1;
+        };
+        S b;
+        const auto [x3, y3] = b;
+      };
+      )",
+      Lang_CXX17, "", Lang_CXX17);
+
+  TranslationUnitDecl *FromTU = From->getTranslationUnitDecl();
+  auto *FromF = FirstDeclMatcher<FunctionDecl>().match(
+      FromTU, functionDecl(hasName("declToImport")));
+  auto *ToF = Import(FromF, Lang_CXX17);
+  EXPECT_TRUE(ToF);
+
+  auto VerifyImport = [&](llvm::StringRef BindName) {
+    auto *FromB = FirstDeclMatcher<BindingDecl>().match(
+        FromF, bindingDecl(hasName(BindName)));
+    ASSERT_TRUE(FromB);
+    auto *ToB = Import(FromB, Lang_CXX17);
+    EXPECT_TRUE(ToB);
+    EXPECT_EQ(FromB->getBinding() != nullptr, ToB->getBinding() != nullptr);
+    EXPECT_EQ(FromB->getDecomposedDecl() != nullptr,
+              ToB->getDecomposedDecl() != nullptr);
+    EXPECT_EQ(FromB->getHoldingVar() != nullptr,
+              ToB->getHoldingVar() != nullptr);
+  };
+
+  VerifyImport("x1");
+  VerifyImport("y1");
+  VerifyImport("x2");
+  VerifyImport("y2");
+  VerifyImport("x3");
+  VerifyImport("y3");
+}
+
 struct ImportClasses : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContext) {
   Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C99);
   Decl *FromTU1 = getTuDecl("struct X {};", Lang_C99, "input1.cc");
   auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
   auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);