Implement a slow string-based function template instantiation.

This routine should be used only in cases where we cannot do anything else. It
takes the string and tries to force the compiler to instantiate by requesting
the address to the function.

Author: vgvassilev

include/clang/Interpreter/CppInterOp.h

@@ -471,6 +471,13 @@ namespace Cpp {
   /// Returns the class template instantiation arguments of \c templ_instance.
   void GetClassTemplateInstantiationArgs(TCppScope_t templ_instance,
                                          std::vector<TemplateArgInfo> &args);
+
+  /// Instantiates a function template from a given string representation. This
+  /// function also does overload resolution.
+  ///\returns the instantiated function template declaration.
+  TCppFunction_t
+  InstantiateTemplateFunctionFromString(const char* function_template);
+
   std::vector<std::string> GetAllCppNames(TCppScope_t scope);
 
   void DumpScope(TCppScope_t scope);

lib/Interpreter/CppInterOp.cpp

@@ -474,6 +474,8 @@ namespace Cpp {
       Type = Type->getUnqualifiedDesugaredType();
       if (auto *ET = llvm::dyn_cast<EnumType>(Type))
         return ET->getDecl();
+      if (auto* FnType = llvm::dyn_cast<FunctionProtoType>(Type))
+        Type = const_cast<clang::Type*>(FnType->getReturnType().getTypePtr());
       return Type->getAsCXXRecordDecl();
     }
     return 0;
@@ -2651,6 +2653,24 @@ namespace Cpp {
     }
   }
 
+  TCppFunction_t
+  InstantiateTemplateFunctionFromString(const char* function_template) {
+    // FIXME: Drop this interface and replace it with the proper overload
+    // resolution handling and template instantiation selection.
+
+    // Try to force template instantiation and overload resolution.
+    static unsigned long long var_count = 0;
+    std::string id = "__Cppyy_GetMethTmpl_" + std::to_string(var_count++);
+    std::string instance = "auto " + id + " = " + function_template + ";\n";
+
+    if (!Cpp::Declare(instance.c_str(), /*silent=*/false)) {
+      VarDecl* VD = (VarDecl*)Cpp::GetNamed(id, 0);
+      DeclRefExpr* DRE = (DeclRefExpr*)VD->getInit()->IgnoreImpCasts();
+      return DRE->getDecl();
+    }
+    return nullptr;
+  }
+
   std::vector<std::string> GetAllCppNames(TCppScope_t scope) {
     auto *D = (clang::Decl *)scope;
     clang::DeclContext *DC;

unittests/CppInterOp/ScopeReflectionTest.cpp

@@ -704,6 +704,15 @@ TEST(ScopeReflectionTest, InstantiateNNTPClassTemplate) {
                                                 /*type_size*/ args1.size()));
 }
 
+TEST(ScopeReflectionTest, InstantiateTemplateFunctionFromString) {
+  Cpp::CreateInterpreter();
+  std::string code = R"(#include <memory>)";
+  Interp->process(code);
+  const char* str = "std::make_unique<int,int>";
+  auto* Instance1 = (Decl*)Cpp::InstantiateTemplateFunctionFromString(str);
+  EXPECT_TRUE(Instance1);
+}
+
 TEST(ScopeReflectionTest, InstantiateClassTemplate) {
   std::vector<Decl *> Decls;
   std::string code = R"(