[ASTImporter] Support importing UnresolvedLookupExpr nodes

[khazem]

Summary

This patch adds support for importing AST nodes of type UnresolvedLookupExpr, as well as a test for such an import. This resolves an issue where attempting to import UnresolvedLookupExprs would cause Clang to error out with "cannot import unsupported AST node UnresolvedLookupExpr".

This patch depends on D26904.

[a.sidorin]

Hi Kareem! I'll be happy to see this changes in upstream. Please see my comments inline.

lib/AST/ASTImporter.cpp

6492

auto will look nice here.

6501

UnresolvedLookupExpr::Create is overloaded for different use cases and it seems like some of them are not covered here. You may refer to https://github.com/haoNoQ/clang/blob/summary-ipa-draft/lib/AST/ASTImporter.cpp#L7499 for some implementation details.

6502

QualifierLoc needs to be imported: it may refer to decls in the "from" context.

[spyffe]

I only have a stylistic nit to add to Aleksei's comments.

lib/AST/ASTImporter.cpp

6492

Alternatively,

for (Decl *D : E->decls())

[spyffe]

Marked the place I was talking about in D27181

lib/AST/ASTImporter.cpp

6489

Commented in D27181 that usage of ImportDeclarationNameLoc look different in different places.

lib/AST/ASTImporter.cpp

     Expr *VisitCXXNewExpr(CXXNewExpr *CE);
     Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
     Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
     Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
     Expr *VisitCXXThisExpr(CXXThisExpr *E);
     Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
     Expr *VisitMemberExpr(MemberExpr *E);
+    Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
     Expr *VisitCallExpr(CallExpr *E);
     Expr *VisitInitListExpr(InitListExpr *E);
     Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
     Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
 
     template<typename IIter, typename OIter>
     void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
       typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;

                             Importer.Import(E->getOperatorLoc()),
                             Importer.Import(E->getQualifierLoc()),
                             Importer.Import(E->getTemplateKeywordLoc()),
                             ToMember, ToFoundDecl, ToMemberNameInfo,
                             nullptr, T, E->getValueKind(),
                             E->getObjectKind());
 }
 
+Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
+  CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
+      Importer.Import(E->getNamingClass()));
+  if (!NamingClass)
+    return nullptr;
+
+  DeclarationNameInfo NameInfo(E->getName(), E->getNameLoc());
+  ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
+
+  UnresolvedSet<8> ToDecls;
+  for (UnresolvedLookupExpr::decls_iterator S = E->decls_begin(),
+                                            F = E->decls_end();
+       S != F; ++S){
+    if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(*S)))
+      ToDecls.addDecl(To);
+    else
+      return nullptr;
+  }
+
+  return UnresolvedLookupExpr::Create(Importer.getToContext(), NamingClass,
+                                      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(
               compoundStmt(
                 has(
                   cStyleCastExpr(
                     hasSourceExpression(
                       vaArgExpr()))))))));
 }
 
 
+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()))))))));
+}
+
+
 } // end namespace ast_matchers
 } // end namespace clang