Allow friend functions to be wrapped (#21)

* Exclude friend functions in the matcher not the AST consumer
* Use unqualified function call for inline friends
* Exclude h5_write, h5_read and hdf5_format
* Fix issue with friend functions defined inside class templates
* Add fmt formatter for StringRef

---------

Co-authored-by: Olivier Parcollet <[email protected]>

Author: Thoemi09

src/tools/clair-c2py/ast_consumer.cpp

@@ -103,16 +103,17 @@ void ast_consumer::HandleTranslationUnit(clang::ASTContext &ctx) {
       return add_match_files(l);
   };
   // Final call of the chain, for classes, enums and functions
-  // Function are special, as we have to exclude methods and friend declarations
+  // Functions are special: exclude methods. Friend declarations (both inline
+  // definitions and out-of-class declarations) are matched; deduplication
+  // against out-of-class definitions is handled in the Fnt matcher callback.
   auto call_cls = [&](auto... x) {
     return cxxRecordDecl(std::move(x)...); //excludes);
   };
   auto call_enum = [&](auto... x) {
     return enumDecl(std::move(x)...); //excludes);
   };
   auto call_fun = [&](auto... x) {
-    auto excludes = unless(anyOf(cxxMethodDecl(), hasAncestor(friendDecl())));
-    return functionDecl(std::move(x)..., excludes);
+    return functionDecl(std::move(x)..., unless(cxxMethodDecl()));
   };
 
   // ------- Match the AST in two passes

src/tools/clair-c2py/codegen/fnt.cpp

@@ -69,10 +69,14 @@ void codegen::write_dispatch(std::ostream &code, std::ostream &table, std::ostre
   auto parent_cls_name = (not cls_alias.empty()) ? cls_alias : (parent_class ? clu::get_fully_qualified_name(parent_class) : str_t{});
 
   auto l = [&enforce_method, parent_class, &parent_cls_name](fnt_info_t const &f_info) {
-    auto *f        = f_info.ptr;
-    auto *m        = llvm::dyn_cast_or_null<clang::CXXMethodDecl>(f);
-    auto args      = fnt_params_with_default(f);
-    auto fname     = (m and parent_class ? parent_cls_name + "::" + f->getNameAsString() : f->getQualifiedNameAsString());
+    auto *f   = f_info.ptr;
+    auto *m   = llvm::dyn_cast_or_null<clang::CXXMethodDecl>(f);
+    auto args = fnt_params_with_default(f);
+    // Inline friend functions (defined inside a class body) are only found via ADL,
+    // so they must be called unqualified. They are not CXXMethodDecls.
+    bool is_inline_friend = (not m) and f->getFriendObjectKind() != clang::Decl::FOK_None;
+    auto fname            = (m and parent_class ? parent_cls_name + "::" + f->getNameAsString() :
+                                                  (is_inline_friend ? f->getNameAsString() : f->getQualifiedNameAsString()));
     auto fname_log = (m and parent_class ? clu::get_fully_qualified_name(parent_class) + "::" + f->getNameAsString() : f->getQualifiedNameAsString());
 
     auto cfun_or_cmethod = std::string{enforce_method and (not m) ? "cmethod" : "cfun"};

src/tools/clair-c2py/matchers.cpp

@@ -186,18 +186,39 @@ template <> void matcher<mtch::Fnt>::run(const MatchResult &Result) {
   // Reject function template declaration
   if (f->getDescribedFunctionTemplate()) return;
 
+  // Reject functions with dependent (unresolved) types.
+  // This filters out the pattern FunctionDecl of friend functions defined inside 
+  // class templates whose types still contain template parameters like `type-parameter-0-0`.
+  if (f->getType()->isDependentType()) return;
+
   // method should not be here
   EXPECTS(not llvm::isa<clang::CXXMethodDecl>(f));
 
+  // Deduplicate friend declarations vs out-of-class definitions.
+  // If this is a friend declaration (not a definition) and the definition
+  // exists in this TU, skip — the definition will be matched separately.
+  // If no definition is visible (defined in another .cpp), keep the declaration.
+  if (f->getFriendObjectKind() != clang::Decl::FOK_None and not f->isThisDeclarationADefinition())
+    if (f->getDefinition()) return;
+
+  // Wrapping c2py functions makes no sense, and is probably a mistake in the configuration or includes. Panic...
   if (f->getQualifiedNameAsString().starts_with("c2py::")) {
-    logs.error("FATAL ERROR: incorrect configuration or includes. It requests wrapping c2py functions which makes no sense.");
+    logs.error("FATAL ERROR: incorrect configuration or includes. It requests wrapping c2py functions, which makes no sense.");
     std::abort();
   }
 
   // apply c2py_ignore and the reject_name regex
   auto &M = wdata->module_info;
   if (should_reject(f, wdata->reject_names, &logs.rejected)) return;
 
+  // h5_write/h5_read/h5_read_construct  are HDF5 serialization helpers, never meant to be wrapped
+  // if we use the h5 method.
+  if (wdata->concepts.HasHdf5)
+    if (auto name = f->getName(); name == "h5_write" || name == "h5_read" || name == "h5_read_construct") {
+      logs.rejected(fmt::format(R"RAW({0} [treated directly in h5 support])RAW", name));
+      return;
+    }
+
   // Special treatment for operator
   if (f->getNameAsString().starts_with("operator")) {
     analyze_operator(f, *wdata);

src/tools/clair-c2py/scan_classes.cpp

@@ -55,6 +55,9 @@ static void analyze_one_method(clang::FunctionDecl const *f, cls_info_t &cls_inf
 
   auto name = m->getNameAsString();
 
+  // hdf5_format is an HDF5 serialization helper, never meant to be wrapped
+  if (wd.concepts.HasHdf5 and name == "hdf5_format") return;
+
   // ---- constructors
   if (llvm::isa<clang::CXXConstructorDecl>(m)) {
     const bool is_base_class = (cls != cls_info.ptr);

src/utility/logger.hpp

@@ -5,9 +5,16 @@
 #include <utility>
 #include <fmt/core.h>
 #include <fmt/format.h>
+#include <llvm/ADT/StringRef.h>
 
 #include "string_tools.hpp"
 
+template <> struct fmt::formatter<llvm::StringRef> : fmt::formatter<std::string_view> {
+  auto format(llvm::StringRef s, fmt::format_context &ctx) const {
+    return fmt::formatter<std::string_view>::format({s.data(), s.size()}, ctx);
+  }
+};
+
 namespace util {
   class logger {