Add LookupConstructors and fix logic in IsConstructor for templates

Also splits IsTemplatedFunction into `IsTemplatedFunction` for FunctionTemplateDecl, and `IsTemplateInstantiationOrSpecialization` when we have an instantiation or a specialization.
Accumulate constructors with the new lookup in `GetClassTemplatedMethods` enabling 8 tests.

Author: aaronj0

include/clang/Interpreter/CppInterOp.h

@@ -416,13 +416,27 @@ namespace Cpp {
   CPPINTEROP_API bool ExistsFunctionTemplate(const std::string& name,
                                              TCppScope_t parent = nullptr);
 
+  /// Sets a list of all the constructor for a scope/class that is
+  /// supplied as a parameter.
+  ///\param[in] name - This string is used as a constraint, that clients can use
+  ///           to ensure the constructors match the name that they provide
+  ///\param[in] parent - Pointer to the scope/class for which the constructors
+  ///           are being looked up
+  ///           to be retrieved
+  ///\param[out] funcs - vector of handles to all constructors found under the
+  ///            given scope
+  CPPINTEROP_API void LookupConstructors(const std::string& name,
+                                         TCppScope_t parent,
+                                         std::vector<TCppFunction_t>& funcs);
+
   /// Sets a list of all the Templated Methods that are in the Class that is
   /// supplied as a parameter.
+  ///\returns true if the lookup succeeded, and false if there are no candidates
   ///\param[in] name - method name
   ///\param[in] parent - Pointer to the scope/class under which the methods have
   ///           to be retrieved
   ///\param[out] funcs - vector of function pointers matching the name
-  CPPINTEROP_API void
+  CPPINTEROP_API bool
   GetClassTemplatedMethods(const std::string& name, TCppScope_t parent,
                            std::vector<TCppFunction_t>& funcs);
 

lib/Interpreter/CppInterOp.cpp

@@ -988,9 +988,10 @@ namespace Cpp {
   // encompassed in an anonymous namespace as follows.
   namespace {
     bool IsTemplatedFunction(Decl *D) {
-      if (llvm::isa_and_nonnull<FunctionTemplateDecl>(D))
-        return true;
+      return llvm::isa_and_nonnull<FunctionTemplateDecl>(D);
+    }
 
+    bool IsTemplateInstantiationOrSpecialization(Decl* D) {
       if (auto *FD = llvm::dyn_cast_or_null<FunctionDecl>(D)) {
         auto TK = FD->getTemplatedKind();
         return TK == FunctionDecl::TemplatedKind::
@@ -1013,9 +1014,12 @@ namespace Cpp {
   bool IsTemplatedFunction(TCppFunction_t func)
   {
     auto *D = (Decl *) func;
-    return IsTemplatedFunction(D);
+    return IsTemplatedFunction(D) || IsTemplateInstantiationOrSpecialization(D);
   }
 
+  // FIXME: This lookup is broken, and should no longer be used in favour of
+  // `GetClassTemplatedMethods` If the candidate set returned is =1, that means
+  // the template function exists and >1 means overloads
   bool ExistsFunctionTemplate(const std::string& name,
           TCppScope_t parent)
   {
@@ -1031,38 +1035,68 @@ namespace Cpp {
       return false;
 
     if ((intptr_t) ND != (intptr_t) -1)
-      return IsTemplatedFunction(ND);
+      return IsTemplatedFunction(ND) ||
+             IsTemplateInstantiationOrSpecialization(ND);
 
     // FIXME: Cycle through the Decls and check if there is a templated function
     return true;
   }
 
-  void GetClassTemplatedMethods(const std::string& name, TCppScope_t parent,
-                                std::vector<TCppFunction_t>& funcs) {
-
+  // Looks up all constructors in the current DeclContext
+  void LookupConstructors(const std::string& name, TCppScope_t parent,
+                          std::vector<TCppFunction_t>& funcs) {
     auto* D = (Decl*)parent;
 
-    if (!parent || name.empty())
-      return;
+    if (auto* CXXRD = llvm::dyn_cast_or_null<CXXRecordDecl>(D)) {
+      getSema().ForceDeclarationOfImplicitMembers(CXXRD);
+      DeclContextLookupResult Result = getSema().LookupConstructors(CXXRD);
+      // Obtaining all constructors when we intend to lookup a method under a
+      // scope can lead to crashes. We avoid that by accumulating constructors
+      // only if the Decl matches the lookup name.
+      for (auto* i : Result)
+        if (GetName(i) == name)
+          funcs.push_back(i);
+    }
+  }
 
-    D = GetUnderlyingScope(D);
+  bool GetClassTemplatedMethods(const std::string& name, TCppScope_t parent,
+                                std::vector<TCppFunction_t>& funcs) {
+    auto* D = (Decl*)parent;
+    if (!D && name.empty())
+      return false;
 
-    llvm::StringRef Name(name);
+    // Accumulate constructors
+    LookupConstructors(name, parent, funcs);
     auto& S = getSema();
+    D = GetUnderlyingScope(D);
+    llvm::StringRef Name(name);
     DeclarationName DName = &getASTContext().Idents.get(name);
     clang::LookupResult R(S, DName, SourceLocation(), Sema::LookupOrdinaryName,
                           For_Visible_Redeclaration);
+    auto* DC = clang::Decl::castToDeclContext(D);
+    Cpp_utils::Lookup::Named(&S, R, DC);
 
-    Cpp_utils::Lookup::Named(&S, R, Decl::castToDeclContext(D));
-
-    if (R.empty())
-      return;
+    // Distinct match, single Decl
+    if (R.getResultKind() == clang::LookupResult::Found) {
+      funcs.push_back(R.getFoundDecl());
+    }
+    // Loop over overload set
+    else if (R.getResultKind() == clang::LookupResult::FoundOverloaded) {
+      for (auto* Found : R)
+        if (IsTemplatedFunction(Found))
+          funcs.push_back(Found);
+    }
 
-    R.resolveKind();
+    // Ambiguously found
+    // FIXME : if result not empty, add them anyway?
+    else {
+      if (!R.empty()) {
+        for (auto* Found : R)
+          funcs.push_back(Found);
+      }
+    }
 
-    for (auto* Found : R)
-      if (llvm::isa<FunctionTemplateDecl>(Found))
-        funcs.push_back(Found);
+    return !funcs.empty();
   }
 
   // Adapted from inner workings of Sema::BuildCallExpr
@@ -1185,6 +1219,8 @@ namespace Cpp {
   bool IsConstructor(TCppConstFunction_t method)
   {
     const auto* D = static_cast<const Decl*>(method);
+    if (const auto* FTD = dyn_cast<FunctionTemplateDecl>(D))
+      return IsConstructor(FTD->getTemplatedDecl());
     return llvm::isa_and_nonnull<CXXConstructorDecl>(D);
   }