[ASTImporter] Support for importing UsingDecl and UsingShadowDecl

[khazem]

Summary

Some of this patch comes from Aleksei's branch [1], with minor revisions. I've added unit tests and AST Matcher support. Copying in Manuel in case there is no need for a dedicated usingShadowDecl() matcher, in which case I could define it only in the test suite.

This patch depends on D26753.

[1] https://github.com/haoNoQ/clang/blob/summary-ipa-draft/lib/AST/ASTImporter.cpp#L3594

[klimek]

Can you add a test to ASTMatchersNodeTests.cpp? Otherwise LG for the matcher parts.

[a.sidorin]

Thank you Kareem, It looks mostly good, but I'd like to have some functional tests in ASTMerge for this patch.

lib/AST/ASTImporter.cpp

4299

nullptr

4323

This will assert if import fails. We need to use cast_or_null and check for null returns. (If this is the result of my misleading code, sorry for this.)

4335

nullptr

4342

This will assert if import fails. We need to use cast_or_null and check for null returns.

[spyffe]

Looks good, but I have a concern about the underlying branch's apparently inconsistent initialization of DeclarationNameInfo. Aleksei, could you clarify how that code works? Should we have a helper function so we don't have to carefully repeat this pattern everywhere?

lib/AST/ASTImporter.cpp

4305

I've seen this pattern before, in D20733, at ASTImporter.cpp:6488:

DeclarationNameInfo NameInfo(E->getName(), E->getNameLoc());
ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);

That code didn't do the Import during the initialization of the DeclarationNameInfo. Is either of these incorrect?

[a.sidorin]

lib/AST/ASTImporter.cpp

4305

This may come from our published code but it looks like an issue that needs to be fixed. Thank you for spotting this.

[a.sidorin]

Hello Kareem,

While the functionality of this patch is already implemented in my already merged patch, I added your tests into the repo. Thank you!

include/clang/AST/ASTImporter.h

public:
 
     /// \brief Import the given type source information from the
     /// "from" context into the "to" context.
     ///
     /// \returns the equivalent type source information in the "to"
     /// context, or NULL if an error occurred.
     TypeSourceInfo *Import(TypeSourceInfo *FromTSI);
 
+    /// \brief Get an imported declaration in "to" context
+    /// if it is already been imported
+    ///
+    /// \ returns an imported declaration if it is already imported,
+    ///  or a NULL type if is not imported yet.
+    Decl *GetImported(Decl *FromD);
+
     /// \brief Import the given declaration from the "from" context into the 
     /// "to" context.
     ///
     /// \returns the equivalent declaration in the "to" context, or a NULL type 
     /// if an error occurred.
     Decl *Import(Decl *FromD);
 
     /// \brief Return the copy of the given declaration in the "to" context if

include/clang/ASTMatchers/ASTMatchers.h

 /// \code
 ///   namespace X { int x; }
 ///   using X::x;
 /// \endcode
 /// usingDecl()
 ///   matches \code using X::x \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
 
+/// \brief Matches shadow declarations introduced into a scope by a
+///        (resolved) using declaration.
+///
+/// Given
+/// \code
+///   namespace n { int f; }
+///   namespace declToImport { using n::f; }
+/// \endcode
+/// usingShadowDecl()
+///   matches \code f \endcode
+const internal::VariadicDynCastAllOfMatcher<Decl,
+                                            UsingShadowDecl> usingShadowDecl;
+
 /// \brief Matches using namespace declarations.
 ///
 /// Given
 /// \code
 ///   namespace X { int x; }
 ///   using namespace X;
 /// \endcode
 /// usingDirectiveDecl()

lib/AST/ASTImporter.cpp

     Decl *VisitVarDecl(VarDecl *D);
     Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
     Decl *VisitParmVarDecl(ParmVarDecl *D);
     Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
     Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
     Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
     Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
     Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
+    Decl *VisitUsingDecl(UsingDecl *D);
+    Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
 
     ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
     Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
     Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
     Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
     Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
     Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
     Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);

   ToLinkageSpec->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToLinkageSpec);
 
   Importer.Imported(D, ToLinkageSpec);
 
   return ToLinkageSpec;
 }
 
+Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
+  DeclContext *DC, *LexicalDC;
+  DeclarationName Name;
+  SourceLocation Loc;
+  NamedDecl *AlreadyImported;
+  if (ImportDeclParts(D, DC, LexicalDC, Name, AlreadyImported, Loc))
+    return NULL;
+  assert(DC && "Null DeclContext after importing decl parts");
+  if (AlreadyImported)
+    return AlreadyImported;
+
+  DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
+  ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
+
+  // If a UsingShadowDecl has a pointer to its UsingDecl, then we may
+  // already have imported this UsingDecl. That should have been caught
+  // above when checking if ToD is non-null.
+  assert(!Importer.GetImported(D) &&
+         "Decl imported but not assigned to AlreadyImported");
+
+  UsingDecl *ToD = UsingDecl::Create(Importer.getToContext(), DC,
+                                     Importer.Import(D->getUsingLoc()),
+                                     Importer.Import(D->getQualifierLoc()),
+                                     NameInfo, D->hasTypename());
+  ImportAttributes(D, ToD);
+  ToD->setLexicalDeclContext(LexicalDC);
+  LexicalDC->addDeclInternal(ToD);
+  Importer.Imported(D, ToD);
+
+  for (UsingShadowDecl *I : D->shadows()) {
+    UsingShadowDecl *SD = cast<UsingShadowDecl>(Importer.Import(I));
+    ToD->addShadowDecl(SD);
+  }
+  return ToD;
+}
+
+Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
+  DeclContext *DC, *LexicalDC;
+  DeclarationName Name;
+  SourceLocation Loc;
+  NamedDecl *AlreadyImported;
+  if (ImportDeclParts(D, DC, LexicalDC, Name, AlreadyImported, Loc))
+    return NULL;
+  assert(DC && "Null DeclContext after importing decl parts");
+  if (AlreadyImported)
+    return AlreadyImported;
+
+  UsingShadowDecl *ToD = UsingShadowDecl::Create(
+        Importer.getToContext(), DC, Loc,
+        cast<UsingDecl>(Importer.Import(D->getUsingDecl())),
+        cast_or_null<NamedDecl>(Importer.Import(D->getTargetDecl())));
+
+  ImportAttributes(D, ToD);
+  ToD->setAccess(D->getAccess());
+  ToD->setLexicalDeclContext(LexicalDC);
+  Importer.Imported(D, ToD);
+
+  LexicalDC->addDeclInternal(ToD);
+
+  return ToD;
+}
+
 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 
                                        ObjCInterfaceDecl *To,
                                        ImportDefinitionKind Kind) {
   if (To->getDefinition()) {
     // Check consistency of superclass.
     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
     if (FromSuper) {
       FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));

     Decl *ToD = Pos->second;
     ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
     return ToD;
   } else {
     return nullptr;
   }
 }
 
+Decl *ASTImporter::GetImported(Decl *FromD) {
+  llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
+  return Pos != ImportedDecls.end() ? Pos->second : NULL;
+}
+
 Decl *ASTImporter::Import(Decl *FromD) {
   if (!FromD)
     return nullptr;
 
   ASTNodeImporter Importer(*this);
 
   // Check whether we've already imported this declaration.  
   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(unaryOperator);
   REGISTER_MATCHER(unaryTransformType);
   REGISTER_MATCHER(unless);
   REGISTER_MATCHER(unresolvedLookupExpr);
   REGISTER_MATCHER(unresolvedUsingTypenameDecl);
   REGISTER_MATCHER(unresolvedUsingValueDecl);
   REGISTER_MATCHER(userDefinedLiteral);
   REGISTER_MATCHER(usingDecl);
+  REGISTER_MATCHER(usingShadowDecl);
   REGISTER_MATCHER(usingDirectiveDecl);
   REGISTER_MATCHER(valueDecl);
   REGISTER_MATCHER(varDecl);
   REGISTER_MATCHER(variableArrayType);
   REGISTER_MATCHER(voidType);
   REGISTER_MATCHER(whileStmt);
   REGISTER_MATCHER(withInitializer);
 }

unittests/AST/ASTImporterTest.cpp

EXPECT_TRUE(
                   compoundStmt(
                     has(
                       binaryOperator(
                         has(
                           cxxDependentScopeMemberExpr()))))))))));
 }
 
 
+TEST(ImportDecl, ImportUsingDecl) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "namespace foo { int bar; }"
+          "int declToImport(){ using foo::bar; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            has(
+              compoundStmt(
+                has(
+                  declStmt(
+                    has(
+                      usingDecl()))))))));
+}
+
+
+TEST(ImportDecl, ImportUsingShadowDecl) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "namespace foo { int bar; }"
+          "namespace declToImport { using foo::bar; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          namespaceDecl(
+            has(
+              usingShadowDecl()))));
+}
+
+
 } // end namespace ast_matchers
 } // end namespace clang