[ASTImporter] Support importing CXXUnresolvedConstructExpr and UnresolvedLookupExpr

[a.sidorin]

Summary

This patch adds support for importing two different kind of C++ AST Node.
Note: This solution is based on https://github.com/haoNoQ/clang/blob/summary-ipa-draft/lib/AST/ASTImporter.cpp#L7605 .

[xazax.hun]

lib/AST/ASTImporter.cpp

5897

Use uppercase variable names.

5898

I would eliminate this local variable.

[a.sidorin]

Hi Peter,

Thank you for the patch. You can find some comments inline.

lib/AST/ASTImporter.cpp

5897

We have implemented ImportContainerChecked helper to avoid such routine code. You can use it.

5905

No need to allocate and copy - CXXUnresolvedConstructExpr::Create allocates the required amount of memory itself.

5931

ImportContainerChecked

5941

Needs to become a common function.

unittests/AST/ASTImporterTest.cpp

554

Code samples need alignment.

[szepet]

Updates based on review comments.

[szepet]

Hello Aleksei,

Thank you for the review! (and sorry for the late update)

lib/AST/ASTImporter.cpp

5931

Since the operator* is const on UnresolvedSetIterator so returns NameDecl* not NamedDecl*& the ImportContainerChecked can not be use here as I understand (since the left side of the = operator is not an LVal in this case). So we can add elements via the addDecl function call.

[szepet]

Updating the usage of ImportTemplateArgumentListInfo.

[xazax.hun]

lib/AST/ASTImporter.cpp

5912

Is this condition correct?

[a.sidorin]

lib/AST/ASTImporter.cpp

5912

Looks like it should be E->getName() && !Name.

[a.sidorin]

Fixed sanity check.

lib/AST/ASTImporter.cpp

public:
     Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
     Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
     Expr *VisitPackExpansionExpr(PackExpansionExpr *E);
     Expr *VisitCXXNewExpr(CXXNewExpr *CE);
     Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
     Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
     Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
+    Expr *VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE);
+    Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
     Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
     Expr *VisitCXXThisExpr(CXXThisExpr *E);
     Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
     Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
     Expr *VisitMemberExpr(MemberExpr *E);
     Expr *VisitCallExpr(CallExpr *E);
     Expr *VisitInitListExpr(InitListExpr *E);
     Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
   return CXXDependentScopeMemberExpr::Create(
       Importer.getToContext(), Base, BaseType, E->isArrow(),
       Importer.Import(E->getOperatorLoc()),
       Importer.Import(E->getQualifierLoc()),
       Importer.Import(E->getTemplateKeywordLoc()),
       cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
 }
 
+Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
+    CXXUnresolvedConstructExpr *CE) {
+
+  unsigned NumArgs = CE->arg_size();
+
+  llvm::SmallVector<Expr *, 8> ToArgs(NumArgs);
+  if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin()))
+    return nullptr;
+
+  return CXXUnresolvedConstructExpr::Create(
+      Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()),
+      Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs),
+      Importer.Import(CE->getRParenLoc()));
+}
+
+Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
+  CXXRecordDecl *NamingClass =
+      cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
+  if (E->getNamingClass() && !NamingClass)
+    return nullptr;
+
+  DeclarationName Name = Importer.Import(E->getName());
+  if (E->getName() && !Name)
+    return nullptr;
+
+  DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
+  // Import additional name location/type info.
+  ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
+
+  UnresolvedSet<8> ToDecls;
+  for (Decl *D : E->decls()) {
+    if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
+      ToDecls.addDecl(To);
+    else
+      return nullptr;
+  }
+
+  TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()),
+                                    Importer.Import(E->getRAngleLoc()));
+  TemplateArgumentListInfo *ResInfo = nullptr;
+  if (E->hasExplicitTemplateArgs()) {
+    if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
+      return nullptr;
+    ResInfo = &ToTAInfo;
+  }
+
+  if (ResInfo || E->getTemplateKeywordLoc().isValid())
+    return UnresolvedLookupExpr::Create(
+        Importer.getToContext(), NamingClass,
+        Importer.Import(E->getQualifierLoc()),
+        Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(),
+        ResInfo, ToDecls.begin(), ToDecls.end());
+
+  return UnresolvedLookupExpr::Create(
+      Importer.getToContext(), NamingClass,
+      Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(),
+      E->isOverloaded(), ToDecls.begin(), ToDecls.end());
+}
+
 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *ToCallee = Importer.Import(E->getCallee());
   if (!ToCallee && E->getCallee())
     return nullptr;

unittests/AST/ASTImporterTest.cpp

EXPECT_TRUE(testImport("template <typename... Args>"
                          functionDecl(
                            hasBody(
                              compoundStmt(
                                has(
                                  returnStmt(
                                    has(
                                      implicitCastExpr(
                                        has(
                                          declRefExpr()))))))))));
 }
 
 /// \brief Matches __builtin_types_compatible_p:
 /// GNU extension to check equivalent types
 /// Given
 /// \code
 ///   __builtin_types_compatible_p(int, int)
 /// \endcode
EXPECT_TRUE(
           "namespace foo { int bar; }"
           "namespace declToImport { using foo::bar; }",
           Lang_CXX, "", Lang_CXX, Verifier,
           namespaceDecl(
             has(
               usingShadowDecl()))));
 }
 
+TEST(ImportExpr, ImportUnresolvedLookupExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("template<typename T> int foo();"
+                         "template <typename T> void declToImport() {"
+                         "  ::foo<T>;"
+                         "  ::template foo<T>;"
+                         "}",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionTemplateDecl(has(functionDecl(has(
+                             compoundStmt(has(unresolvedLookupExpr()))))))));
+}
+
+TEST(ImportExpr, ImportCXXUnresolvedConstructExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+      testImport("template <typename T> class C { T t; };"
+                 "template <typename T> void declToImport() {"
+                 "  C<T> d;"
+                 "  d.t = T();"
+                 "}",
+                 Lang_CXX, "", Lang_CXX, Verifier,
+                 functionTemplateDecl(has(functionDecl(has(compoundStmt(has(
+                     binaryOperator(has(cxxUnresolvedConstructExpr()))))))))));
+  EXPECT_TRUE(
+      testImport("template <typename T> class C { T t; };"
+                 "template <typename T> void declToImport() {"
+                 "  C<T> d;"
+                 "  (&d)->t = T();"
+                 "}",
+                 Lang_CXX, "", Lang_CXX, Verifier,
+                 functionTemplateDecl(has(functionDecl(has(compoundStmt(has(
+                     binaryOperator(has(cxxUnresolvedConstructExpr()))))))))));
+}
+
 } // end namespace ast_matchers
 } // end namespace clang