Refactoring, move common code to static function

Author: aaronj0

include/clang/Interpreter/CppInterOp.h

@@ -286,6 +286,8 @@ namespace Cpp {
 
   /// Gets a list of all the Methods that are in the Class that is
   /// supplied as a parameter.
+  ///\param[in] klass - Pointer to the scope/class under which the methods have
+  /// to be retrieved
   CPPINTEROP_API void GetClassMethods(TCppScope_t klass, std::vector<TCppFunction_t> &methods);
 
   ///\returns Template function pointer list to add proxies for
@@ -335,8 +337,11 @@ namespace Cpp {
   CPPINTEROP_API bool ExistsFunctionTemplate(const std::string& name,
                                              TCppScope_t parent = nullptr);
 
-  CPPINTEROP_API std::vector<TCppFunction_t>
-  GetTemplatedMethods(const std::string& name, TCppScope_t parent = nullptr);
+  /// Sets a list of all the Templated Methods that are in the Class that is
+  /// supplied as a parameter.
+  CPPINTEROP_API void
+  GetClassTemplatedMethods(const std::string& name, TCppScope_t parent,
+                           std::vector<TCppFunction_t>& funcs);
 
   /// Checks if the provided parameter is a method.
   CPPINTEROP_API bool IsMethod(TCppConstFunction_t method);
@@ -542,6 +547,14 @@ namespace Cpp {
       : m_Type(type), m_IntegralValue(integral_value) {}
   };
   /// Builds a template instantiation for a given templated declaration.
+  /// Offers a single interface for instantiation of class, function and
+  /// variable templates
+  ///\param[in] tmpl - Uninstantiated template class/function
+  ///\param[in] template_args - Pointer to vector of template arguments stored
+  /// in the \c TemplateArgInfo struct \param[in] template_args_size - Size of
+  /// the vector of template arguments passed as \c template_args
+  ///
+  ///\returns Instantiated templated class/function/variable pointer
   CPPINTEROP_API TCppScope_t InstantiateTemplate(TCppScope_t tmpl,
                                                  const TemplateArgInfo* template_args,
                                                  size_t template_args_size);
@@ -557,8 +570,15 @@ namespace Cpp {
   CPPINTEROP_API TCppFunction_t
   InstantiateTemplateFunctionFromString(const char* function_template);
 
-  // Find best template match based on explicit template parameters and arg
-  // types
+  /// Finds best template match based on explicit template parameters and
+  /// argument types
+  ///
+  ///\param[in] candidates - Vector of suitable candidates that come under the
+  /// parent scope and have the same name (obtained using
+  /// GetClassTemplatedMethods) \param[in] explicit_types - set of expicitly
+  /// instantiated template types, if any \param[in] arg_types - set of argument
+  /// types
+  ///\returns Instantiated function pointer
   CPPINTEROP_API TCppFunction_t
   BestTemplateFunctionMatch(const std::vector<TCppFunction_t>& candidates,
                             const std::vector<TemplateArgInfo>& explicit_types,

lib/Interpreter/CppInterOp.cpp

@@ -719,48 +719,41 @@ namespace Cpp {
     return ComputeBaseOffset(getSema().getASTContext(), DCXXRD, Paths.front());
   }
 
-  void GetClassMethods(TCppScope_t klass, std::vector<TCppFunction_t> &methods) {
-    if (!klass) return;
-    
-    auto *D = (clang::Decl *) klass;
-
-    if (auto *TD = dyn_cast<TypedefNameDecl>(D))
-      D = GetScopeFromType(TD->getUnderlyingType());
-
-    if (D && isa<CXXRecordDecl>(D)) {
-      auto* CXXRD = dyn_cast<CXXRecordDecl>(D);
-      getSema().ForceDeclarationOfImplicitMembers(CXXRD);
-        for (Decl* DI : CXXRD->decls()) {
-          if (auto* MD = dyn_cast<CXXMethodDecl>(DI))
-            methods.push_back(MD);
-          else if (auto* USD = dyn_cast<UsingShadowDecl>(DI))
-            if (auto* MD = dyn_cast<CXXMethodDecl>(USD->getTargetDecl()))
-              methods.push_back(MD);
-      }
-    }
-  }
-
-  void GetFunctionTemplatedDecls(TCppScope_t klass, std::vector<TCppFunction_t> &methods) {
-    if (!klass) return;
+  template <typename DeclType>
+  static void GetClassDecls(TCppScope_t klass,
+                            std::vector<TCppFunction_t>& methods) {
+    if (!klass)
+      return;
 
     auto* D = (clang::Decl*)klass;
 
     if (auto* TD = dyn_cast<TypedefNameDecl>(D))
       D = GetScopeFromType(TD->getUnderlyingType());
 
-    if (D && isa<CXXRecordDecl>(D)) {
-      auto* CXXRD = dyn_cast<CXXRecordDecl>(D);
-      getSema().ForceDeclarationOfImplicitMembers(CXXRD);
-      for (Decl* DI : CXXRD->decls()) {
-        if (auto* MD = dyn_cast<FunctionTemplateDecl>(DI))
+    if (!D || !isa<CXXRecordDecl>(D))
+      return;
+
+    auto* CXXRD = dyn_cast<CXXRecordDecl>(D);
+    getSema().ForceDeclarationOfImplicitMembers(CXXRD);
+    for (Decl* DI : CXXRD->decls()) {
+      if (auto* MD = dyn_cast<DeclType>(DI))
+        methods.push_back(MD);
+      else if (auto* USD = dyn_cast<UsingShadowDecl>(DI))
+        if (auto* MD = dyn_cast<DeclType>(USD->getTargetDecl()))
           methods.push_back(MD);
-        else if (auto* USD = dyn_cast<UsingShadowDecl>(DI))
-          if (auto* MD = dyn_cast<FunctionTemplateDecl>(USD->getTargetDecl()))
-            methods.push_back(MD);
-      }
     }
   }
 
+  void GetClassMethods(TCppScope_t klass,
+                       std::vector<TCppFunction_t>& methods) {
+    GetClassDecls<CXXMethodDecl>(klass, methods);
+  }
+
+  void GetFunctionTemplatedDecls(TCppScope_t klass,
+                                 std::vector<TCppFunction_t>& methods) {
+    GetClassDecls<FunctionTemplateDecl>(klass, methods);
+  }
+
   bool HasDefaultConstructor(TCppScope_t scope) {
     auto *D = (clang::Decl *) scope;
 
@@ -883,9 +876,7 @@ namespace Cpp {
     return 0;
   }
 
-  std::string GetFunctionSignature(
-      TCppFunction_t func) { // FIXME : Doesn't work for template functions as
-                             // it does in cling
+  std::string GetFunctionSignature(TCppFunction_t func) {
     if (!func)
       return "<unknown>";
 
@@ -903,18 +894,6 @@ namespace Cpp {
       return Signature;
     }
 
-    // FIXME: else if (auto *FD = llvm::dyn_cast<FunctionTemplateDecl>(D)) {
-    //   std::string Signature;
-    //   raw_string_ostream SS(Signature);
-    //   PrintingPolicy Policy = getASTContext().getPrintingPolicy();
-    //   // Skip printing the body
-    //   Policy.TerseOutput = true;
-    //   Policy.FullyQualifiedName = true;
-    //   Policy.SuppressDefaultTemplateArgs = false;
-    //   FD->print(SS, Policy);
-    //   SS.flush();
-    //   return Signature;
-    // }
     return "<unknown>";
   }
 
@@ -954,7 +933,7 @@ namespace Cpp {
   {
     DeclContext *Within = 0;
     if (parent) {
-      auto *D = (Decl *)parent;
+      auto* D = (Decl*)parent;
       Within = llvm::dyn_cast<DeclContext>(D);
     }
 
@@ -970,17 +949,16 @@ namespace Cpp {
     return true;
   }
 
-  std::vector<TCppFunction_t> GetTemplatedMethods(const std::string& name,
-                                                  TCppScope_t parent) {
+  void GetClassTemplatedMethods(const std::string& name, TCppScope_t parent,
+                                std::vector<TCppFunction_t>& funcs) {
 
     auto* D = (Decl*)parent;
 
     if (!parent || name.empty())
-      return {};
+      return;
 
     D = GetUnderlyingScope(D);
 
-    std::vector<TCppFunction_t> funcs;
     llvm::StringRef Name(name);
     auto& S = getSema();
     DeclarationName DName = &getASTContext().Idents.get(name);
@@ -990,34 +968,26 @@ namespace Cpp {
     Cpp_utils::Lookup::Named(&S, R, Decl::castToDeclContext(D));
 
     if (R.empty())
-      return {};
+      return;
 
     R.resolveKind();
 
-    for (auto* Found : R) {
+    for (auto* Found : R)
       if (llvm::isa<FunctionTemplateDecl>(Found))
         funcs.push_back(Found);
-    }
-
-    if (!funcs.empty())
-      return funcs;
-
-    return {};
   }
 
   TCppFunction_t
   BestTemplateFunctionMatch(const std::vector<TCppFunction_t>& candidates,
                             const std::vector<TemplateArgInfo>& explicit_types,
                             const std::vector<TemplateArgInfo>& arg_types) {
 
-    int k = 1;
     for (const auto& candidate : candidates) {
       auto* TFD = (FunctionTemplateDecl*)candidate;
       clang::TemplateParameterList* tpl = TFD->getTemplateParameters();
 
       if (tpl->size() < explicit_types.size()) {
         // template parameter size does not match
-        ++k;
         continue;
       }
 
@@ -1029,7 +999,6 @@ namespace Cpp {
 
         // Check if number of function parameters match
         if (func->getNumParams() != arg_types.size()) {
-          ++k;
           continue;
         }
 
@@ -1051,7 +1020,6 @@ namespace Cpp {
               return instantiated;
 
             else {
-              k++;
               continue;
             }
           }