@@ -1102,6 +1102,10 @@ std::string Converter::GetMethodName(const clang::CXXMethodDecl *decl) {
   if (IsOverloadedMethod(decl)) {
     return GetOverloadedFunctionName(decl);
   }
+  if (auto *conversion = clang::dyn_cast<clang::CXXConversionDecl>(decl)) {
+    return GetConversionName(
+        conversion, GetUnsafeTypeAsString(conversion->getConversionType()));
+  }
   return GetNamedDeclAsString(decl);
 }
 
@@ -1146,10 +1150,9 @@ std::string Converter::GetCtorName(clang::CXXConstructorDecl *decl) {
   if (decl->isCopyOrMoveConstructor()) {
     return GetOverloadedFunctionName(decl);
   }
-  return GetRecordName(decl->getParent()) +
-         (GetNumberOfConvertingCtors(decl->getParent()) != 1
-              ? std::to_string(GetCtorIndex(decl))
-              : "");
+  return GetNumberOfConvertingCtors(decl->getParent()) != 1
+             ? std::format("new_{}", GetCtorIndex(decl))
+             : "new";
 }
 
 bool Converter::VisitCXXConstructorDecl(clang::CXXConstructorDecl *decl) {
@@ -1369,7 +1372,12 @@ bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
     return false;
   }
   StrCat(keyword::kIf);
-  ConvertCondition(stmt->getCond());
+  if (auto *cond = clang::dyn_cast<clang::ConstantExpr>(stmt->getCond());
+      cond && stmt->isConstexpr()) {
+    StrCat(cond->getResultAsAPSInt() != 0 ? keyword::kTrue : keyword::kFalse);
+  } else {
+    ConvertCondition(stmt->getCond());
+  }
   ConvertBody(stmt->getThen());
   if (stmt->hasElseStorage()) {
     StrCat(keyword::kElse);
@@ -4074,6 +4082,10 @@ std::string Converter::ConvertVarDefaultInit(clang::QualType qual_type) {
 std::string
 Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
   auto name = GetFunctionBaseName(decl);
+  if (auto *conversion = clang::dyn_cast<clang::CXXConversionDecl>(decl)) {
+    name = GetConversionName(
+        conversion, GetUnsafeTypeAsString(conversion->getConversionType()));
+  }
   if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(decl);
       ctor && !ctor->getParent()->getIdentifier()) {
     name = GetRecordName(ctor->getParent());
@@ -4143,19 +4155,7 @@ Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
     }
   }
 
-  ReplaceAll(name, "[", "arr");
-  ReplaceAll(name, "]", "arr");
-  ReplaceAll(name, ";", "_");
-  ReplaceAll(name, ",", "_");
-  name.erase(std::remove_if(name.begin(), name.end(),
-                            [](char c) {
-                              return c == '<' || c == '>' || c == ' ' ||
-                                     c == ':' || c == '(' || c == ')' ||
-                                     c == '-';
-                            }),
-             name.end());
-  std::replace(name.begin(), name.end(), '*', 'p');
-
+  ToIdentifier(name);
   return name;
 }
 
 
@@ -132,21 +132,35 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual const char *CharRustType() const { return "libc::c_char"; }
 
   virtual bool VisitCXXMethodDecl(clang::CXXMethodDecl *decl);
+
   virtual bool ShouldConvertMethod(const clang::CXXMethodDecl *decl);
+
   virtual bool ConvertOutOfLineMethod(clang::CXXMethodDecl *decl);
+
   bool ConvertCXXMethodDecl(clang::CXXMethodDecl *decl);
+
   std::string GetMethodName(const clang::CXXMethodDecl *decl);
+
   virtual std::string GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl);
+
   std::string GetCtorName(clang::CXXConstructorDecl *decl);
+
   virtual void ConvertCXXRecordMethods(clang::CXXRecordDecl *decl);
+
   virtual void ConvertLateInstantiatedMethods(clang::CXXRecordDecl *decl);
+
   virtual std::string DestroyMembers(const clang::CXXRecordDecl *decl);
+
   virtual void EmitScopedDestructor(const clang::VarDecl *decl);
+
   void EmitDeallocation(clang::CXXDeleteExpr *expr,
                         const std::string &argument_as_string);
+
   virtual void SetUFCSReceiver(clang::Expr *base, bool is_arrow,
                                const clang::CXXMethodDecl *method);
+
   void ConvertUserOperatorCall(clang::CXXOperatorCallExpr *expr);
+
   virtual std::string GetUFCSName(const clang::CXXMethodDecl *method) const;
 
   virtual bool ThisIsRustPtr() const { return false; }
@@ -424,6 +438,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   VisitUnaryExprOrTypeTraitExpr(clang::UnaryExprOrTypeTraitExpr *expr);
 
   virtual bool VisitTypeTraitExpr(clang::TypeTraitExpr *expr);
+
   virtual bool VisitSizeOfPackExpr(clang::SizeOfPackExpr *expr);
 
   virtual bool VisitOffsetOfExpr(clang::OffsetOfExpr *expr);
 
@@ -942,6 +942,35 @@ std::string GetFunctionBaseName(const clang::FunctionDecl *decl) {
   return decl->getNameAsString();
 }
 
+void ToIdentifier(std::string &name) {
+  ReplaceAll(name, "[", "arr");
+  ReplaceAll(name, "]", "arr");
+  ReplaceAll(name, ";", "_");
+  ReplaceAll(name, ",", "_");
+  name.erase(std::remove_if(name.begin(), name.end(),
+                            [](char c) {
+                              return c == '<' || c == '>' || c == ' ' ||
+                                     c == ':' || c == '(' || c == ')' ||
+                                     c == '-';
+                            }),
+             name.end());
+  std::replace(name.begin(), name.end(), '*', 'p');
+}
+
+std::string GetConversionName(const clang::CXXConversionDecl *decl,
+                              const std::string &rust_type) {
+  auto name = "to_" + rust_type;
+  ToIdentifier(name);
+  const auto *record = decl->getParent();
+  bool is_unique_name =
+      std::none_of(record->method_begin(), record->method_end(),
+                   [&name](const clang::CXXMethodDecl *method) {
+                     return method->getDeclName().isIdentifier() &&
+                            method->getName() == name;
+                   });
+  return is_unique_name ? name : GetFunctionBaseName(decl);
+}
+
 clang::CXXDestructorDecl *
 GetUserDefinedDestructor(const clang::CXXRecordDecl *decl) {
   if (!decl->hasDefinition() || !IsUserDefinedDecl(decl) ||
 
@@ -165,6 +165,11 @@ const char *GetOverloadedOperator(const clang::FunctionDecl *decl);
 
 std::string GetFunctionBaseName(const clang::FunctionDecl *decl);
 
+void ToIdentifier(std::string &name);
+
+std::string GetConversionName(const clang::CXXConversionDecl *decl,
+                              const std::string &rust_type);
+
 bool IsImplicitAssignmentCall(const clang::CallExpr *expr);
 bool IsUserOperatorCall(const clang::CXXOperatorCallExpr *expr);
 
 
@@ -215,62 +215,6 @@ bool ConverterRefCount::VisitReferenceType(clang::ReferenceType *type) {
   return false;
 }
 
-std::string ConverterRefCount::BuildFnAdapter(
-    const clang::FunctionDecl *src_fn,
-    const clang::FunctionProtoType *src_proto,
-    const clang::FunctionProtoType *target_proto) {
-
-  // UB: Incompatible arity
-  if (src_proto->getNumParams() != target_proto->getNumParams()) {
-    return "None";
-  }
-
-  PushConversionKind push(*this, ConversionKind::Unboxed);
-
-  // Build adapter signature: |a0: T0, a1: T1, ...| -> Tr
-  std::string closure = "(|";
-  for (unsigned i = 0; i < target_proto->getNumParams(); ++i) {
-    closure +=
-        std::format("a{}: {},", i, ToString(target_proto->getParamType(i)));
-  }
-  closure += '|';
-  if (!target_proto->getReturnType()->isVoidType()) {
-    closure += std::format(" -> {} ", ToString(target_proto->getReturnType()));
-  }
-  closure += "{ ";
-
-  // Build adapter body: src_fn(convert(a0), convert(a1), ...)
-  closure += Mapper::MapFunctionName(src_fn) + '(';
-  for (unsigned i = 0; i < src_proto->getNumParams(); ++i) {
-    auto src_pty = src_proto->getParamType(i);
-    auto tgt_pty = target_proto->getParamType(i);
-    if (ToString(src_pty) == ToString(tgt_pty)) {
-      closure += std::format("a{}", i);
-    } else if (src_pty->isPointerType() && tgt_pty->isPointerType()) {
-      if (tgt_pty->isVoidPointerType()) {
-        closure += std::format("a{}.reinterpret_cast::<{}>()", i,
-                               ConvertPointeeType(src_pty));
-      } else if (src_pty->isVoidPointerType()) {
-        closure += std::format("a{}.to_any()", i);
-      } else if (tgt_pty->getPointeeType()->isCharType()) {
-        closure += std::format("a{}.reinterpret_cast::<{}>()", i,
-                               ConvertPointeeType(src_pty));
-      } else if (src_pty->getPointeeType()->isCharType()) {
-        closure += std::format("a{}.reinterpret_cast::<{}>()", i,
-                               ConvertPointeeType(src_pty));
-      }
-    } else {
-      // UB: Incompatible types
-      return "None";
-    }
-    closure += ", ";
-  }
-  closure += ") })";
-
-  return std::format("Some({} as {})", closure,
-                     ConvertFunctionPointerType(target_proto));
-}
-
 std::string ConverterRefCount::ConvertFunctionPointerType(
     const clang::FunctionProtoType *proto, FnProtoType kind) {
   PushConversionKind push(*this, ConversionKind::Unboxed);
@@ -1390,9 +1334,8 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
 }
 
 void ConverterRefCount::EmitFnPtrCall(clang::Expr *callee) {
-  StrCat("(*");
   Convert(callee);
-  StrCat(')');
+  StrCat(".call");
 }
 
 void ConverterRefCount::ConvertFunctionToFunctionPointer(
@@ -1423,25 +1366,8 @@ bool ConverterRefCount::VisitFunctionPointerCast(
         expr->getType()->isFunctionPointerType()) {
       auto target_proto =
           expr->getType()->getPointeeType()->getAs<clang::FunctionProtoType>();
-      auto src_proto = expr->getSubExpr()
-                           ->getType()
-                           ->getPointeeType()
-                           ->getAs<clang::FunctionProtoType>();
-      auto fn_type = ConvertFunctionPointerType(target_proto);
-
-      std::string adapter = "None";
-      // Only accept direct references to the casted function. Otherwise the
-      // closure would be capturing and would not coerce into a fn pointer.
-      if (auto *decl_ref = clang::dyn_cast<clang::DeclRefExpr>(
-              expr->getSubExpr()->IgnoreImplicit())) {
-        if (auto *fn_decl =
-                clang::dyn_cast<clang::FunctionDecl>(decl_ref->getDecl())) {
-          adapter = BuildFnAdapter(fn_decl, src_proto, target_proto);
-        }
-      }
-
-      StrCat(std::format("{}.cast::<{}>({})", ToString(expr->getSubExpr()),
-                         fn_type, adapter));
+      StrCat(std::format("{}.cast::<{}>()", ToString(expr->getSubExpr()),
+                         ConvertFunctionPointerType(target_proto)));
     } else if (expr->getSubExpr()->getType()->isFunctionPointerType() ||
                expr->getType()->isVoidPointerType()) {
       Convert(expr->getSubExpr());
@@ -1456,6 +1382,7 @@ bool ConverterRefCount::VisitFunctionPointerCast(
     } else {
       assert(0 && "Unhandled function pointer cast");
     }
+    computed_expr_type_ = ComputedExprType::FreshPointer;
     return false;
   }
 
@@ -2263,11 +2190,40 @@ std::string ConverterRefCount::ConvertVarInitValue(clang::QualType qual_type,
       return std::format("({} as {})", ConvertFreshPointer(expr),
                          ToString(qual_type));
     }
+    if (qual_type->isFunctionPointerType()) {
+      return ConvertFnPtrValue(qual_type, expr);
+    }
     return ConvertFreshPointer(expr);
   }
   return ConvertFreshRValue(expr, qual_type);
 }
 
+std::string ConverterRefCount::ConvertFnPtrValue(clang::QualType qual_type,
+                                                 clang::Expr *expr) {
+  auto base = ConvertFreshPointer(expr);
+
+  // `qual_type` (the expected fn pointer type) and `expr`'s own fn pointer
+  // type may differ in spelling only because the translation maps two
+  // typedefs of the same C type to distinct Rust types (e.g. size_t vs
+  // unsigned long) -- FnPtr::cast handles this (and any other cast)
+  // automatically, so just insert it whenever the two differ.
+  auto target_proto =
+      qual_type->getPointeeType()->getAs<clang::FunctionProtoType>();
+  if (!target_proto || !expr->getType()->isFunctionPointerType()) {
+    return base;
+  }
+  auto src_proto =
+      expr->getType()->getPointeeType()->getAs<clang::FunctionProtoType>();
+  if (!src_proto) {
+    return base;
+  }
+  auto fn_type = ConvertFunctionPointerType(target_proto);
+  if (ConvertFunctionPointerType(src_proto) == fn_type) {
+    return base;
+  }
+  return std::format("{}.cast::<{}>()", base, fn_type);
+}
+
 void ConverterRefCount::ConvertVarInit(clang::QualType qual_type,
                                        clang::Expr *expr) {
   bool is_ref = qual_type->isReferenceType();
 
@@ -277,9 +277,12 @@ class ConverterRefCount final : public Converter {
   const char *GetPointerDerefSuffix(clang::QualType pointee_type);
   const char *GetPointerDerefPrefix(clang::QualType pointee_type) override;
 
-  std::string BuildFnAdapter(const clang::FunctionDecl *src_fn,
-                             const clang::FunctionProtoType *src_proto,
-                             const clang::FunctionProtoType *target_proto);
+  // Converts `expr` for use where a `qual_type` function pointer is
+  // expected, inserting a `.cast()` if `expr`'s own fn pointer type differs
+  // from `qual_type` -- e.g. because the two describe the same C function
+  // pointer type through different typedefs that the translation maps to
+  // distinct Rust types (`size_t` vs `unsigned long`).
+  std::string ConvertFnPtrValue(clang::QualType qual_type, clang::Expr *expr);
 
   void EmitSetOrAssign(clang::Expr *lhs, std::string_view rhs);