Index through specializations that have the same arguments

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1978,7 +1978,8 @@ void Converter::ConvertLambdaCall(clang::CallExpr *expr,
   if (lambda->isGenericLambda()) {
     auto call_operator = expr->getDirectCallee();
     auto proto = call_operator->getType()->castAs<clang::FunctionProtoType>();
-    StrCat(std::format(".spec::<{}>()", ConvertFunctionPointerType(proto)));
+    StrCat(std::format(".spec::<{}>({})", ConvertFunctionPointerType(proto),
+                       GetLambdaSpecializationIndex(call_operator)));
   }
   StrCat(".call");
 }
@@ -3963,13 +3964,7 @@ bool Converter::VisitLambdaExpr(clang::LambdaExpr *expr) {
     }
   }
   StrCat(token::kComma);
-  std::unordered_set<std::string> signatures;
   ForEachLambdaCallOperator(decl, [&](clang::CXXMethodDecl *call_operator) {
-    auto proto = call_operator->getType()->castAs<clang::FunctionProtoType>();
-    if (!signatures.insert(ConvertFunctionPointerType(proto)).second) {
-      llvm::report_fatal_error("generic lambda with two specializations of "
-                               "the same signature is not supported");
-    }
     ConvertLambdaClosure(decl, call_operator);
     StrCat(token::kComma);
   });

cpp2rust/converter/converter_lib.cpp

@@ -1210,6 +1210,22 @@ AsLambdaCallOperator(const clang::CXXConversionDecl *conversion) {
   return found;
 }
 
+unsigned
+GetLambdaSpecializationIndex(const clang::FunctionDecl *call_operator) {
+  std::optional<unsigned> index;
+  unsigned i = 0;
+  ForEachLambdaCallOperator(
+      clang::cast<clang::CXXMethodDecl>(call_operator)->getParent(),
+      [&](const clang::CXXMethodDecl *op) {
+        if (op->getCanonicalDecl() == call_operator->getCanonicalDecl()) {
+          index = i;
+        }
+        ++i;
+      });
+  assert(index);
+  return *index;
+}
+
 const clang::LambdaCapture *AsLambdaCapture(const clang::FieldDecl *field) {
   auto decl = clang::dyn_cast<clang::CXXRecordDecl>(field->getParent());
   if (!decl || !decl->isLambda()) {

cpp2rust/converter/converter_lib.h

@@ -221,6 +221,8 @@ void ForEachLambdaCallOperator(
 clang::CXXMethodDecl *
 AsLambdaCallOperator(const clang::CXXConversionDecl *conversion);
 
+unsigned GetLambdaSpecializationIndex(const clang::FunctionDecl *call_operator);
+
 const clang::LambdaCapture *AsLambdaCapture(const clang::FieldDecl *field);
 
 bool IsLambdaCopyOrMoveConstructor(const clang::CXXConstructorDecl *ctor);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1579,10 +1579,10 @@ void ConverterRefCount::ConvertLambdaToFunctionPointer(
   StrCat(ConvertFreshRValue(lambda));
   auto decl = AsLambdaClass(lambda->getType());
   if (decl->isGenericLambda()) {
-    auto proto = conversion->getConversionType()
-                     ->getPointeeType()
-                     ->castAs<clang::FunctionProtoType>();
-    StrCat(std::format(".spec::<{}>()", ConvertFunctionPointerType(proto)));
+    auto call_operator = AsLambdaCallOperator(conversion);
+    auto proto = call_operator->getType()->castAs<clang::FunctionProtoType>();
+    StrCat(std::format(".spec::<{}>({})", ConvertFunctionPointerType(proto),
+                       GetLambdaSpecializationIndex(call_operator)));
   }
 }
 

libcc2rs/src/fn_ptr.rs

@@ -458,14 +458,10 @@ impl FnPtr<Generic> {
         }
     }
 
-    pub fn spec<U: FnSig>(&self) -> FnPtr<U> {
+    pub fn spec<U: FnSig>(&self, index: usize) -> FnPtr<U> {
         assert!(!self.is_null(), "ub: null fn pointer call");
-        self.original
-            .as_ref()
-            .unwrap()
-            .specializations()
-            .iter()
-            .find_map(|spec| spec.downcast_ref::<FnPtr<U>>())
+        self.original.as_ref().unwrap().specializations()[index]
+            .downcast_ref::<FnPtr<U>>()
             .expect("ub: calling through incompatible fn pointer type")
             .clone()
     }