diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index cc4a32dff0..a5bae5c706 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -10,6 +10,7 @@
 #include <clang/Basic/Version.h>
 #include <clang/Sema/Template.h>
 #include <llvm/ADT/DenseMap.h>
+#include <llvm/ADT/StringExtras.h>
 #include <llvm/Support/ConvertUTF.h>
 #include <llvm/Support/ErrorHandling.h>
 
@@ -879,6 +880,9 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
     EmitReprC(decl);
   }
   EmitDerives(decl);
+  if (auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl)) {
+    EmitConversionAttrs(cxx);
+  }
   EmitByteSizeAttr(decl);
 
   // Fields
@@ -956,6 +960,41 @@ void Converter::EmitDerives(const clang::RecordDecl *decl) {
   StrCat(")]");
 }
 
+void Converter::EmitConversionAttrs(clang::CXXRecordDecl *decl) {
+  std::unordered_set<std::string> from_types;
+  ForEachConvertingConstructor(decl, [&](clang::CXXConstructorDecl *ctor) {
+    auto *param = ctor->getParamDecl(0);
+    auto type = param->getType();
+    auto source =
+        GetUnboxedTypeAsString(type.getNonReferenceType().getUnqualifiedType());
+    bool is_move = type->isRValueReferenceType();
+    if (!from_types.insert(source + (is_move ? "&&" : "")).second) {
+      return;
+    }
+    const char *kind =
+        !type->isReferenceType()                                   ? "value"
+        : is_move || type.getNonReferenceType().isConstQualified() ? "ptr"
+                                                                   : "mut_ptr";
+    StrCat(std::format(
+        "#[{}({}, {}, {}{})]", is_move ? "cpp_from_move" : "cpp_from", source,
+        GetCtorName(ctor), param->hasDefaultArg() ? "some_" : "", kind));
+  });
+  std::unordered_set<std::string> into_types;
+  ForEachMethod(decl, [&](clang::CXXMethodDecl *method) {
+    if (!IsImplicitConversionOperator(method)) {
+      return;
+    }
+    auto *conversion = clang::cast<clang::CXXConversionDecl>(method);
+    auto target = GetUnboxedTypeAsString(
+        conversion->getConversionType().getUnqualifiedType());
+    if (!into_types.insert(target).second) {
+      return;
+    }
+    StrCat(
+        std::format("#[cpp_into({}, {})]", target, GetMethodName(conversion)));
+  });
+}
+
 void Converter::EmitReprC(clang::RecordDecl *decl) {
   if (decl->hasAttr<clang::AlignedAttr>()) {
     StrCat(std::format("#[repr(C, align({}))]",
@@ -4208,6 +4247,10 @@ Converter::GetStructAttributes(const clang::RecordDecl *decl) {
     struct_attrs.emplace_back("MoveCtorUnsafe");
   }
 
+  if (HasImplicitConversions(decl)) {
+    struct_attrs.emplace_back("CppFromUnsafe");
+  }
+
   if (HasCopyAssignOperator(decl)) {
     struct_attrs.emplace_back("CopyAssignUnsafe");
   }
@@ -4946,6 +4989,14 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
                        ToStringBase(ctx_.getPointerType(elem)));
   }
 
+  if (auto *init =
+          RuleRegistry::BuildParamConversion(ctx_, expr, ph_ctx.arg_idx, arg)) {
+    Buffer buf(*this);
+    PushExprKind push(*this, ExprKind::RValue);
+    ConvertInit(init->getType(), init);
+    return std::move(buf).str();
+  }
+
   if (ph_ctx.needs_materialization()) {
     auto materialized = ph_ctx.materialize_ctx->GetOrMaterialize(
         static_cast<unsigned>(ph_ctx.materialize_idx),
@@ -5093,11 +5144,6 @@ std::string Converter::ConvertIRFragment(
       result += t->text;
     } else if (auto *g = std::get_if<GenericFragment>(&frag)) {
       result += GetTemplateArgumentAsString(bindings[g->n - 1]);
-    } else if (auto *d = std::get_if<DefaultFragment>(&frag)) {
-      auto &arg = bindings[d->n - 1];
-      assert(arg.getKind() == clang::TemplateArgument::Type &&
-             "default of a non-type generic");
-      result += GetUnboxedDefaultAsString(arg.getAsType());
     } else if (auto *ph = std::get_if<PlaceholderFragment>(&frag)) {
       assert(expr && "placeholder outside an expression rule");
       auto arg_idx = ph->n;
@@ -5138,12 +5184,78 @@ std::string Converter::ConvertIRFragment(
       result +=
           (*re)->prefix + ' ' +
           ConvertIRFragment((*re)->inner, bindings, expr, args, num_args, ctx);
+    } else if (auto *call =
+                   std::get_if<std::unique_ptr<GenericCallFragment>>(&frag)) {
+      result += ConvertGenericCall(**call, bindings, expr, args, num_args, ctx);
     }
   }
 
   return result;
 }
 
+std::string
+Converter::ConvertGenericCall(const TranslationRule::GenericCallFragment &call,
+                              llvm::ArrayRef<clang::TemplateArgument> bindings,
+                              clang::Expr *expr, clang::Expr **args,
+                              unsigned num_args, TempMaterializationCtx *ctx) {
+  std::vector<std::string> call_args;
+  for (const auto &arg : call.args) {
+    call_args.push_back(
+        ConvertIRFragment(arg, bindings, expr, args, num_args, ctx));
+  }
+  clang::QualType type;
+  if (call.generic <= bindings.size() &&
+      bindings[call.generic - 1].getKind() == clang::TemplateArgument::Type) {
+    type = bindings[call.generic - 1].getAsType();
+  } else {
+    assert(expr && "unbound generic outside an expression rule");
+    type = RuleRegistry::GetGenericType(ctx_, expr, call.generic);
+  }
+  if (call.method == "default") {
+    assert(call_args.empty() && "default takes no arguments");
+    return GetUnboxedDefaultAsString(type);
+  }
+  if (call.method == "cpp_from" || call.method == "cpp_from_move") {
+    assert(call_args.size() == 1 && "cpp_from takes one argument");
+    return ConvertConversion(
+        type, RuleRegistry::GetConversionSourceType(ctx_, expr, call.generic),
+        call.method == "cpp_from_move", call_args[0]);
+  }
+  return std::format("<{}>::{}({})", GetUnboxedTypeAsString(type), call.method,
+                     llvm::join(call_args, ", "));
+}
+
+std::string Converter::ConvertConversion(clang::QualType to,
+                                         clang::QualType from, bool is_move,
+                                         const std::string &ptr) {
+  if (to->isArithmeticType() && from->isArithmeticType()) {
+    auto value = DerefPtrExpr(ptr, from);
+    if (ctx_.hasSameUnqualifiedType(to, from)) {
+      return value;
+    }
+    if (to->isBooleanType()) {
+      return std::format("({} != {})", value,
+                         from->isFloatingType() ? "0.0" : "0");
+    }
+    if (from->isBooleanType() && to->isFloatingType()) {
+      return std::format("({} as u8 as {})", value, GetUnsafeTypeAsString(to));
+    }
+    return std::format("({} as {})", value, GetUnsafeTypeAsString(to));
+  }
+  return std::format("<{} as {}<{}>>::{}({})", GetUnboxedTypeAsString(to),
+                     GetConversionTraitName(), GetUnboxedTypeAsString(from),
+                     is_move ? "cpp_from_move" : "cpp_from", ptr);
+}
+
+const char *Converter::GetConversionTraitName() const {
+  return "CppFromUnsafe";
+}
+
+std::string Converter::DerefPtrExpr(std::string_view ptr_expr,
+                                    clang::QualType pointee_type) {
+  return std::format("({}{})", GetPointerDerefPrefix(pointee_type), ptr_expr);
+}
+
 std::string
 Converter::ConvertVariadicTail(clang::Expr *expr,
                                const std::vector<clang::Expr *> &all_args) {
@@ -5180,14 +5292,18 @@ void Converter::ConvertConstructFromArgs(clang::QualType type,
                                          clang::SourceLocation loc) {
   auto *init = BuildInitExpr(GetSema(), type, args, loc);
   assert(init && "type cannot be initialized from the arguments");
-  if (auto *ctor =
-          clang::dyn_cast<clang::CXXConstructExpr>(init->IgnoreImplicit())) {
-    ConvertConstructedValue(type, ctor);
+  if (args.empty() &&
+      !clang::isa<clang::CXXConstructExpr>(init->IgnoreImplicit())) {
+    StrCat(GetDefaultAsString(type));
     return;
   }
+  ConvertInit(type, init);
+}
 
-  if (args.empty()) {
-    StrCat(GetDefaultAsString(type));
+void Converter::ConvertInit(clang::QualType type, clang::Expr *init) {
+  if (auto *ctor =
+          clang::dyn_cast<clang::CXXConstructExpr>(init->IgnoreImplicit())) {
+    ConvertConstructedValue(type, ctor);
     return;
   }
   Convert(init);
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index f6ba0973cf..65eae3dac7 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -178,6 +178,9 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   void EmitReprC(clang::RecordDecl *decl);
   void EmitDerives(const clang::RecordDecl *decl);
+
+  void EmitConversionAttrs(clang::CXXRecordDecl *decl);
+
   virtual void EmitRustUnion(clang::RecordDecl *decl);
 
   virtual bool EmitsReprCForRecords() const { return true; }
@@ -304,6 +307,20 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                     clang::Expr *expr, clang::Expr **args, unsigned num_args,
                     TempMaterializationCtx *ctx);
 
+  std::string
+  ConvertGenericCall(const TranslationRule::GenericCallFragment &call,
+                     llvm::ArrayRef<clang::TemplateArgument> bindings,
+                     clang::Expr *expr, clang::Expr **args, unsigned num_args,
+                     TempMaterializationCtx *ctx);
+
+  std::string ConvertConversion(clang::QualType to, clang::QualType from,
+                                bool is_move, const std::string &ptr);
+
+  virtual const char *GetConversionTraitName() const;
+
+  virtual std::string DerefPtrExpr(std::string_view ptr_expr,
+                                   clang::QualType pointee_type);
+
   struct PlaceholderCtx {
     unsigned arg_idx;
     std::optional<clang::QualType> implicit_convert_to;
@@ -866,6 +883,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                 llvm::ArrayRef<clang::Expr *> args,
                                 clang::SourceLocation loc);
 
+  void ConvertInit(clang::QualType type, clang::Expr *init);
+
   virtual void ConvertConstructedValue(clang::QualType type,
                                        clang::CXXConstructExpr *ctor);
 
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 8daca90de6..409acc74ac 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -543,6 +543,50 @@ bool IsConvertibleMoveConstructor(const clang::CXXConstructorDecl *ctor) {
   return ctor->isUserProvided() || NeedsDefaultedMoveConstructor(parent);
 }
 
+static bool
+IsImplicitConvertingConstructor(const clang::CXXConstructorDecl *ctor) {
+  return !ctor->isCopyOrMoveConstructor() && !ctor->isImplicit() &&
+         !ctor->isDeleted() && ctor->hasBody() && ctor->getNumParams() == 1 &&
+         ctor->isConvertingConstructor(/*AllowExplicit=*/false);
+}
+
+void ForEachConvertingConstructor(
+    clang::CXXRecordDecl *decl,
+    llvm::function_ref<void(clang::CXXConstructorDecl *)> fn) {
+  for (auto *ctor : decl->ctors()) {
+    if (IsImplicitConvertingConstructor(ctor)) {
+      fn(ctor);
+    }
+  }
+  for (auto *ctor : GetTemplateInstantiatedCtors(decl)) {
+    if (IsImplicitConvertingConstructor(ctor)) {
+      fn(ctor);
+    }
+  }
+}
+
+bool IsImplicitConversionOperator(const clang::CXXMethodDecl *method) {
+  auto *conversion = clang::dyn_cast<clang::CXXConversionDecl>(method);
+  return conversion && !conversion->isExplicit() && !conversion->isDeleted() &&
+         conversion->hasBody() &&
+         !conversion->getConversionType()->isReferenceType();
+}
+
+bool HasImplicitConversions(const clang::RecordDecl *decl) {
+  auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
+  if (!cxx || !IsUserDefinedDecl(cxx)) {
+    return false;
+  }
+  bool found = false;
+  ForEachConvertingConstructor(
+      const_cast<clang::CXXRecordDecl *>(cxx),
+      [&](clang::CXXConstructorDecl *) { found = true; });
+  ForEachMethod(cxx, [&](clang::CXXMethodDecl *method) {
+    found = found || IsImplicitConversionOperator(method);
+  });
+  return found;
+}
+
 bool HasMoveFromConstructor(const clang::RecordDecl *decl) {
   auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
   return cxx && llvm::any_of(cxx->ctors(), [](auto *ctor) {
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index feba03343f..2ebaa52627 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -105,6 +105,14 @@ bool IsConvertibleMoveConstructor(const clang::CXXConstructorDecl *ctor);
 // Whether decl has a move constructor converted to a move_from method.
 bool HasMoveFromConstructor(const clang::RecordDecl *decl);
 
+void ForEachConvertingConstructor(
+    clang::CXXRecordDecl *decl,
+    llvm::function_ref<void(clang::CXXConstructorDecl *)> fn);
+
+bool IsImplicitConversionOperator(const clang::CXXMethodDecl *method);
+
+bool HasImplicitConversions(const clang::RecordDecl *decl);
+
 bool IsConvertibleMoveAssignment(const clang::CXXMethodDecl *method);
 
 bool IsConvertibleCopyAssignment(const clang::CXXMethodDecl *method);
diff --git a/cpp2rust/converter/models/boxed_vars.cpp b/cpp2rust/converter/models/boxed_vars.cpp
index f5f663405f..b5f7387a53 100644
--- a/cpp2rust/converter/models/boxed_vars.cpp
+++ b/cpp2rust/converter/models/boxed_vars.cpp
@@ -177,7 +177,9 @@ class AddressTakenVisitor
     if (auto *source = GetTrivialCopySource(expr)) {
       AddValueUse(source);
     }
-    AddRuleArgs(expr, expr->getArgs(), expr->getNumArgs());
+    if (!expr->isElidable()) {
+      AddRuleArgs(expr, expr->getArgs(), expr->getNumArgs());
+    }
     return true;
   }
 
@@ -237,6 +239,10 @@ class AddressTakenVisitor
     auto all_args = BuildUnifiedArgs(expr, args, num_args);
     for (unsigned i = 0; i < all_args.size() && i < rule->params.size(); ++i) {
       auto *arg = IgnoreNoOpCasts(all_args[i]);
+      if (auto *init = RuleRegistry::BuildParamConversion(ctx_, expr, i, arg)) {
+        TraverseStmt(init);
+        continue;
+      }
       if (!rule->params[i].is_pointer() || arg->getType()->isPointerType() ||
           RuleRegistry::MapsToPointer(ctx_, arg->getType())) {
         AddValueUse(arg);
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 3550437fdb..58bd0793a4 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -2257,6 +2257,10 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
     attrs.emplace_back("MoveCtor");
   }
 
+  if (HasImplicitConversions(decl)) {
+    attrs.emplace_back("CppFrom");
+  }
+
   if (HasCopyAssignOperator(decl)) {
     attrs.emplace_back("CopyAssign");
   }
@@ -2276,6 +2280,10 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
   return attrs;
 }
 
+const char *ConverterRefCount::GetConversionTraitName() const {
+  return "CppFrom";
+}
+
 bool ConverterRefCount::TypeDerivesDefault(clang::QualType qual_type) {
   // Arrays are translated to Value<Box<[T]>>, whose Default is empty
   return !qual_type->isArrayType() && Converter::TypeDerivesDefault(qual_type);
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index a99dd063ca..eef71cddf5 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -418,7 +418,9 @@ class ConverterRefCount final : public Converter {
   // Wraps a pointer expression with deref prefix/suffix: e.g.
   // "(*ptr.upgrade().deref())" or "(ptr.read())"
   std::string DerefPtrExpr(std::string_view ptr_expr,
-                           clang::QualType pointee_type);
+                           clang::QualType pointee_type) override;
+
+  const char *GetConversionTraitName() const override;
 
   std::string GetInnerType(clang::QualType type);
 
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index 70790d78d3..f0e21f7812 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -87,18 +87,19 @@ clang::QualType getInitPattern(const clang::FunctionDecl *rule) {
 
 void collectGenerics(const std::vector<TranslationRule::BodyFragment> &body,
                      std::unordered_set<unsigned> &used) {
-  TranslationRule::AnyFragment(
-      body, [&](const TranslationRule::BodyFragment &fragment) {
-        if (auto generic =
-                std::get_if<TranslationRule::GenericFragment>(&fragment)) {
-          used.insert(generic->n);
-        }
-        if (auto generic =
-                std::get_if<TranslationRule::DefaultFragment>(&fragment)) {
-          used.insert(generic->n);
-        }
-        return false;
-      });
+  TranslationRule::AnyFragment(body, [&](const TranslationRule::BodyFragment
+                                             &fragment) {
+    if (auto generic =
+            std::get_if<TranslationRule::GenericFragment>(&fragment)) {
+      used.insert(generic->n);
+    }
+    if (auto call =
+            std::get_if<std::unique_ptr<TranslationRule::GenericCallFragment>>(
+                &fragment)) {
+      used.insert((*call)->generic);
+    }
+    return false;
+  });
 }
 
 void collectGenerics(llvm::StringRef type, std::unordered_set<unsigned> &used) {
@@ -120,6 +121,27 @@ void collectGenerics(llvm::StringRef type, std::unordered_set<unsigned> &used) {
   }
 }
 
+bool isBoundArgument(const TranslationRule::ExprRule &rule, unsigned n) {
+  return llvm::any_of(rule.generics, [&](const auto &bounds) {
+    return llvm::any_of(bounds, [&](const TranslationRule::Bound &bound) {
+      return llvm::is_contained(bound.args, n);
+    });
+  });
+}
+
+unsigned iteratorOverGeneric(const TranslationRule::ExprRule &rule,
+                             unsigned n) {
+  for (unsigned i = 0; i < rule.generics.size(); ++i) {
+    for (const auto &bound : rule.generics[i]) {
+      if (llvm::StringRef(bound.trait_name).ends_with("Iterator") &&
+          llvm::is_contained(bound.args, n)) {
+        return i + 1;
+      }
+    }
+  }
+  return 0;
+}
+
 void checkGenerics(const std::string &dir, const std::string &name,
                    const clang::FunctionDecl *decl,
                    const TranslationRule::ExprRule &rule) {
@@ -136,7 +158,8 @@ void checkGenerics(const std::string &dir, const std::string &name,
     collectGenerics(param.type, used);
   }
   for (unsigned i : used) {
-    if (!declared.contains(std::format("T{}", i))) {
+    if (!declared.contains(std::format("T{}", i)) &&
+        !isBoundArgument(rule, i)) {
       llvm::errs() << dir << "::" << name << ": generic T" << i
                    << " used by the target but missing from src\n";
       llvm::report_fatal_error("Absent generic from src");
@@ -381,6 +404,46 @@ Matcher::Match<TranslationRule::ExprRule> Search(clang::ASTContext &ctx,
           getBindings(match.rule_decl->decl, match.args)};
 }
 
+clang::QualType iteratorElementType(clang::ASTContext &ctx,
+                                    clang::QualType iterator) {
+  iterator = iterator.getNonReferenceType().getUnqualifiedType();
+  if (iterator->isPointerType()) {
+    return iterator->getPointeeType().getUnqualifiedType();
+  }
+  auto [rule, bindings] = Search(ctx, iterator);
+  assert(rule && !bindings.empty() &&
+         bindings[0].getKind() == clang::TemplateArgument::Type &&
+         "iterator type rule declares no element generic T1");
+  return bindings[0].getAsType();
+}
+
+clang::QualType GetGenericType(clang::ASTContext &ctx, const clang::Expr *expr,
+                               unsigned n) {
+  auto [rule, bindings] = Search(ctx, expr);
+  assert(rule && "expression must have a translation rule");
+  if (n <= bindings.size() &&
+      bindings[n - 1].getKind() == clang::TemplateArgument::Type) {
+    return bindings[n - 1].getAsType();
+  }
+  auto iterator = iteratorOverGeneric(*rule, n);
+  assert(iterator &&
+         "generic is neither bound by the src nor the element of an iterator");
+  return iteratorElementType(ctx, GetGenericType(ctx, expr, iterator));
+}
+
+clang::QualType GetConversionSourceType(clang::ASTContext &ctx,
+                                        const clang::Expr *expr, unsigned to) {
+  auto rule = Search(ctx, expr).first;
+  assert(rule && "expression must have a translation rule");
+  for (const auto &bound : rule->generics.at(to - 1)) {
+    if (bound.trait_name == "CppFrom" || bound.trait_name == "CppFromUnsafe") {
+      assert(bound.args.size() == 1 && "CppFrom takes one generic");
+      return GetGenericType(ctx, expr, bound.args[0]);
+    }
+  }
+  llvm::report_fatal_error("converted generic has no CppFrom bound");
+}
+
 clang::QualType GetInitType(const clang::Expr *expr) {
   auto match = findExpr(expr);
   assert(match.rule_decl && "expression must have a translation rule");
@@ -461,6 +524,30 @@ bool ParamIsPointer(clang::ASTContext &ctx, const clang::Expr *expr,
   return rule->params.at(index).is_pointer();
 }
 
+clang::Expr *BuildParamConversion(clang::ASTContext &ctx,
+                                  const clang::Expr *expr, unsigned index,
+                                  clang::Expr *arg) {
+  auto [rule, bindings] = Search(ctx, expr);
+  assert(rule && "expression must have a translation rule");
+  llvm::StringRef type = rule->params.at(index).type;
+  unsigned n = 0;
+  if (!type.consume_front("T") || type.empty() || type.getAsInteger(10, n)) {
+    return nullptr;
+  }
+  auto &binding = bindings.at(n - 1);
+  assert(binding.getKind() == clang::TemplateArgument::Type &&
+         "parameter typed by a non-type generic");
+  auto target = binding.getAsType();
+  if ((arg->getType()->isArrayType() && target->isPointerType()) ||
+      ctx.hasSameUnqualifiedType(arg->getType().getNonReferenceType(),
+                                 target)) {
+    return nullptr;
+  }
+  auto *init = BuildInitExpr(*sema_, target, arg, arg->getExprLoc());
+  assert(init && "argument cannot be converted to the parameter type");
+  return init;
+}
+
 bool IsLibcPassthrough(clang::ASTContext &ctx, const clang::Expr *expr) {
   const auto *tgt_ir = GetExprRule(ctx, expr);
   if (tgt_ir == nullptr || !tgt_ir->body.empty() || !tgt_ir->is_extern) {
diff --git a/cpp2rust/converter/rules/registry.h b/cpp2rust/converter/rules/registry.h
index 8de311400c..a84fb45611 100644
--- a/cpp2rust/converter/rules/registry.h
+++ b/cpp2rust/converter/rules/registry.h
@@ -38,12 +38,24 @@ Matcher::Match<TranslationRule::TypeRule> Search(clang::ASTContext &ctx,
 const TranslationRule::ExprRule *GetExprRule(clang::ASTContext &ctx,
                                              const clang::Expr *expr);
 clang::QualType GetInitType(const clang::Expr *expr);
+
+clang::QualType GetGenericType(clang::ASTContext &ctx, const clang::Expr *expr,
+                               unsigned n);
+
+clang::QualType GetConversionSourceType(clang::ASTContext &ctx,
+                                        const clang::Expr *expr, unsigned to);
+
 bool HasExprRule(const clang::FunctionDecl *decl);
 bool IsLibcPassthrough(clang::ASTContext &ctx, const clang::Expr *expr);
 bool ReturnsPointer(clang::ASTContext &ctx, const clang::Expr *expr);
 bool ReturnsReference(const clang::Expr *expr);
 bool ParamIsPointer(clang::ASTContext &ctx, const clang::Expr *expr,
                     unsigned index);
+
+clang::Expr *BuildParamConversion(clang::ASTContext &ctx,
+                                  const clang::Expr *expr, unsigned index,
+                                  clang::Expr *arg);
+
 bool MapsToPointer(clang::ASTContext &ctx, clang::QualType qual_type);
 bool MapsToRefcountPointer(clang::ASTContext &ctx, clang::QualType qual_type);
 
diff --git a/cpp2rust/converter/translation_rule.cpp b/cpp2rust/converter/translation_rule.cpp
index b8adc57408..f634a20aa4 100644
--- a/cpp2rust/converter/translation_rule.cpp
+++ b/cpp2rust/converter/translation_rule.cpp
@@ -3,6 +3,7 @@
 
 #include "converter/translation_rule.h"
 
+#include <llvm/ADT/STLExtras.h>
 #include <llvm/Support/JSON.h>
 
 #include <algorithm>
@@ -72,6 +73,21 @@ MethodCallFragment ParseMethodCallFragmentJSON(const llvm::json::Object &obj) {
   return mc;
 }
 
+GenericCallFragment
+ParseGenericCallFragmentJSON(const llvm::json::Object &obj) {
+  GenericCallFragment call;
+  call.generic = obj.getInteger("generic").value_or(0);
+  call.method = obj.getString("method").value_or("").str();
+  if (auto *args = obj.getArray("args")) {
+    for (auto &arg : *args) {
+      if (auto *fragments = arg.getAsArray()) {
+        call.args.push_back(ParseBodyFragmentsJSON(*fragments));
+      }
+    }
+  }
+  return call;
+}
+
 RefExprFragment ParseRefExprFragmentJSON(const llvm::json::Object &obj) {
   RefExprFragment re;
   re.prefix = obj.getString("prefix").value_or("").str();
@@ -91,8 +107,6 @@ std::vector<BodyFragment> ParseBodyFragmentsJSON(const llvm::json::Array &arr) {
       result.push_back(TextFragment{str->str()});
     } else if (auto n = frag_obj->getInteger("generic")) {
       result.push_back(GenericFragment{(unsigned)*n});
-    } else if (auto n = frag_obj->getInteger("default")) {
-      result.push_back(DefaultFragment{(unsigned)*n});
     } else if (auto *ph = frag_obj->getObject("placeholder")) {
       result.push_back(ParsePlaceholderFragmentJSON(*ph));
     } else if (auto *mc = frag_obj->getObject("method_call")) {
@@ -101,6 +115,9 @@ std::vector<BodyFragment> ParseBodyFragmentsJSON(const llvm::json::Array &arr) {
     } else if (auto *re = frag_obj->getObject("ref_expr")) {
       result.push_back(
           std::make_unique<RefExprFragment>(ParseRefExprFragmentJSON(*re)));
+    } else if (auto *call = frag_obj->getObject("generic_call")) {
+      result.push_back(std::make_unique<GenericCallFragment>(
+          ParseGenericCallFragmentJSON(*call)));
     } else if (frag_obj->get("va_args")) {
       result.push_back(VaArgsFragment{});
     } else if (frag_obj->get("init")) {
@@ -137,6 +154,11 @@ bool AnyFragment(const std::vector<BodyFragment> &body,
     if (auto *re = std::get_if<std::unique_ptr<RefExprFragment>>(&frag)) {
       return AnyFragment((*re)->inner, pred);
     }
+    if (auto *call = std::get_if<std::unique_ptr<GenericCallFragment>>(&frag)) {
+      return llvm::any_of((*call)->args, [&](const auto &arg) {
+        return AnyFragment(arg, pred);
+      });
+    }
     return false;
   });
 }
@@ -202,7 +224,10 @@ void ExprRule::dump() const {
   for (auto &bounds : generics) {
     log() << "  generic T" << ++i << ':';
     for (auto &b : bounds) {
-      log() << ' ' << b;
+      log() << ' ' << b.trait_name;
+      for (unsigned arg : b.args) {
+        log() << " T" << arg;
+      }
     }
     log() << '\n';
   }
@@ -232,9 +257,16 @@ void RefExprFragment::dump() const {
   }
 }
 
-void GenericFragment::dump() const { log() << "  generic: " << n << '\n'; }
+void GenericCallFragment::dump() const {
+  log() << "  generic_call: T" << generic << "::" << method << '\n';
+  for (auto &arg : args) {
+    for (auto &frag : arg) {
+      BodyFragmentDump(frag);
+    }
+  }
+}
 
-void DefaultFragment::dump() const { log() << "  default: " << n << '\n'; }
+void GenericFragment::dump() const { log() << "  generic: " << n << '\n'; }
 
 void TypeInfo::dump() const {
   log() << type;
@@ -285,16 +317,33 @@ ExprRule ParseExprRuleJSON(const llvm::json::Object &obj) {
 
   if (auto *generics = obj.getObject("generics")) {
     for (auto &[key, val] : *generics) {
-      if (auto *arr = val.getAsArray()) {
-        std::vector<std::string> bounds;
-        for (auto &b : *arr) {
-          if (auto s = b.getAsString())
-            bounds.push_back(s->str());
+      auto *arr = val.getAsArray();
+      if (!arr) {
+        continue;
+      }
+      std::vector<Bound> bounds;
+      for (auto &b : *arr) {
+        auto *bound = b.getAsObject();
+        if (!bound) {
+          continue;
+        }
+        Bound parsed;
+        parsed.trait_name = bound->getString("trait").value_or("").str();
+        if (auto *args = bound->getArray("args")) {
+          for (auto &arg : *args) {
+            llvm::StringRef name = arg.getAsString().value_or("");
+            unsigned n = 0;
+            if (name.consume_front("T") && !name.empty() &&
+                !name.getAsInteger(10, n)) {
+              parsed.args.push_back(n);
+            }
+          }
         }
-        size_t id = atoi(llvm::StringRef(key).data() + 1) - 1; // starts in T1
-        ir.generics.resize(std::max(ir.generics.size(), id + 1));
-        ir.generics[id] = std::move(bounds);
+        bounds.push_back(std::move(parsed));
       }
+      size_t id = atoi(llvm::StringRef(key).data() + 1) - 1; // starts in T1
+      ir.generics.resize(std::max(ir.generics.size(), id + 1));
+      ir.generics[id] = std::move(bounds);
     }
   }
 
diff --git a/cpp2rust/converter/translation_rule.h b/cpp2rust/converter/translation_rule.h
index a923c6868c..1bb3ae9d4c 100644
--- a/cpp2rust/converter/translation_rule.h
+++ b/cpp2rust/converter/translation_rule.h
@@ -9,7 +9,6 @@
 
 #include <filesystem>
 #include <string>
-#include <unordered_map>
 #include <variant>
 #include <vector>
 
@@ -41,12 +40,6 @@ struct GenericFragment {
   void dump() const;
 };
 
-struct DefaultFragment {
-  unsigned n;
-
-  void dump() const;
-};
-
 struct VaArgsFragment {
   void dump() const;
 };
@@ -57,12 +50,12 @@ struct InitFragment {
 
 struct MethodCallFragment; // forward declaration
 struct RefExprFragment;
+struct GenericCallFragment;
 
-using BodyFragment =
-    std::variant<TextFragment, PlaceholderFragment, GenericFragment,
-                 DefaultFragment, VaArgsFragment, InitFragment,
-                 std::unique_ptr<MethodCallFragment>,
-                 std::unique_ptr<RefExprFragment>>;
+using BodyFragment = std::variant<
+    TextFragment, PlaceholderFragment, GenericFragment, VaArgsFragment,
+    InitFragment, std::unique_ptr<MethodCallFragment>,
+    std::unique_ptr<RefExprFragment>, std::unique_ptr<GenericCallFragment>>;
 
 struct MethodCallFragment {
   std::vector<BodyFragment> receiver;
@@ -79,6 +72,19 @@ struct RefExprFragment {
   void dump() const;
 };
 
+struct GenericCallFragment {
+  unsigned generic;
+  std::string method;
+  std::vector<std::vector<BodyFragment>> args;
+
+  void dump() const;
+};
+
+struct Bound {
+  std::string trait_name;
+  std::vector<unsigned> args;
+};
+
 // Whether pred holds for a fragment of body, or for one nested in them.
 bool AnyFragment(const std::vector<BodyFragment> &body,
                  llvm::function_ref<bool(const BodyFragment &)> pred);
@@ -97,7 +103,7 @@ struct TypeInfo {
 struct ExprRule {
   std::vector<TypeInfo> params;
   TypeInfo return_type;
-  std::vector<std::vector<std::string>> generics; // "T1" -> ["Ord", "Clone"]
+  std::vector<std::vector<Bound>> generics; // "T1" -> [Ord, Clone]
   std::vector<BodyFragment> body;
   bool multi_statement = false;
   bool is_extern = false;
diff --git a/libcc2rs-macros/src/cpp_from.rs b/libcc2rs-macros/src/cpp_from.rs
new file mode 100644
index 0000000000..aed5ec94d1
--- /dev/null
+++ b/libcc2rs-macros/src/cpp_from.rs
@@ -0,0 +1,220 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{format_ident, quote};
+use syn::parse::{Parse, ParseStream};
+use syn::{DeriveInput, Ident, Token, Type, parse_macro_input};
+
+//     #[derive(CppFrom)]
+//     #[cpp_from(i32, new, value)]        // S(int)
+//     #[cpp_from(i32, new_1, some_value)] // S(int = 0)
+//     #[cpp_from(T, new_2, ptr)]          // S(const T &)
+//     #[cpp_from(T, new_3, mut_ptr)]      // S(T &)
+//     #[cpp_from_move(T, new_4, ptr)]     // S(T &&)
+//     #[cpp_into(i32, to_i32)]            // operator int() const
+//     pub struct S { ... }
+//
+// Implements libcc2rs::CppFrom<Source> for S with each converting constructor
+// of S, and libcc2rs::CppFrom<S> for each type S converts to with a
+// conversion operator, such that the rules convert values as C++ does
+// implicitly. `value` passes the pointee to the constructor, `ptr` the
+// pointer, `mut_ptr` a mutable pointer, and `some_` wraps the argument in
+// Some for a defaulted parameter. CppFromUnsafe is the same for the unsafe
+// model.
+
+#[derive(Clone, Copy)]
+enum Kind {
+    Value,
+    Ptr,
+    MutPtr,
+}
+
+struct Conversion {
+    ty: Type,
+    method: Ident,
+    kind: Kind,
+    some: bool,
+}
+
+impl Parse for Conversion {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let ty = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let method = input.parse()?;
+        let mut kind = Kind::Ptr;
+        let mut some = false;
+        if input.peek(Token![,]) {
+            input.parse::<Token![,]>()?;
+            let spelled: Ident = input.parse()?;
+            let name = spelled.to_string();
+            let name = match name.strip_prefix("some_") {
+                Some(rest) => {
+                    some = true;
+                    rest
+                }
+                None => name.as_str(),
+            };
+            kind = match name {
+                "value" => Kind::Value,
+                "ptr" => Kind::Ptr,
+                "mut_ptr" => Kind::MutPtr,
+                _ => {
+                    return Err(syn::Error::new(
+                        spelled.span(),
+                        "expected `value`, `ptr` or `mut_ptr`, optionally prefixed by `some_`",
+                    ));
+                }
+            };
+        }
+        Ok(Conversion {
+            ty,
+            method,
+            kind,
+            some,
+        })
+    }
+}
+
+#[derive(Default)]
+struct Source {
+    from: Option<Conversion>,
+    from_move: Option<Conversion>,
+}
+
+fn ctor_call(
+    name: &Ident,
+    conversion: &Conversion,
+    is_unsafe: bool,
+    is_move: bool,
+) -> TokenStream2 {
+    let method = &conversion.method;
+    let arg = match (conversion.kind, is_unsafe) {
+        (Kind::Value, true) => quote!((*src).clone()),
+        (Kind::Value, false) => quote!(src.read()),
+        (Kind::MutPtr, true) if !is_move => quote!(src.cast_mut()),
+        (Kind::Ptr | Kind::MutPtr, _) => quote!(src),
+    };
+    let arg = if conversion.some {
+        quote!(Some(#arg))
+    } else {
+        arg
+    };
+    quote!(#name::#method(#arg))
+}
+
+fn method(is_unsafe: bool, signature: TokenStream2, body: TokenStream2) -> TokenStream2 {
+    if is_unsafe {
+        quote! { unsafe #signature { unsafe { #body } } }
+    } else {
+        quote! { #signature { #body } }
+    }
+}
+
+pub fn expand(input: TokenStream, is_unsafe: bool) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let mut sources: Vec<(String, Source)> = Vec::new();
+    let mut intos: Vec<Conversion> = Vec::new();
+    for attr in &input.attrs {
+        let Some(attr_name) = attr.path().get_ident().map(ToString::to_string) else {
+            continue;
+        };
+        let is_move = match attr_name.as_str() {
+            "cpp_from" => false,
+            "cpp_from_move" => true,
+            "cpp_into" => {
+                intos.push(attr.parse_args().expect("cpp_into(Type, method)"));
+                continue;
+            }
+            _ => continue,
+        };
+        let conversion: Conversion = attr
+            .parse_args()
+            .expect("cpp_from(Type, method, value|ptr|mut_ptr)");
+        let ty = &conversion.ty;
+        let key = quote!(#ty).to_string();
+        let source = match sources.iter().position(|(k, _)| *k == key) {
+            Some(i) => &mut sources[i].1,
+            None => {
+                sources.push((key.clone(), Source::default()));
+                &mut sources.last_mut().unwrap().1
+            }
+        };
+        let slot = if is_move {
+            &mut source.from_move
+        } else {
+            &mut source.from
+        };
+        assert!(slot.is_none(), "two conversions from {key}");
+        *slot = Some(conversion);
+    }
+
+    let tr = if is_unsafe {
+        quote!(::libcc2rs::CppFromUnsafe)
+    } else {
+        quote!(::libcc2rs::CppFrom)
+    };
+    let pointer = |ty: &Type, is_mut: bool| {
+        if is_unsafe && is_mut {
+            quote!(*mut #ty)
+        } else if is_unsafe {
+            quote!(*const #ty)
+        } else {
+            quote!(::libcc2rs::Ptr<#ty>)
+        }
+    };
+
+    let from_impls = sources.iter().map(|(_, source)| {
+        let any = source.from.as_ref().or(source.from_move.as_ref()).unwrap();
+        let ty = &any.ty;
+        let src = pointer(ty, false);
+        let from_body = match &source.from {
+            Some(conversion) => ctor_call(name, conversion, is_unsafe, false),
+            None => quote!(unreachable!("no conversion from an lvalue")),
+        };
+        let from_fn = method(is_unsafe, quote!(fn cpp_from(src: #src) -> Self), from_body);
+        let move_fn = source.from_move.as_ref().map(|conversion| {
+            let src = pointer(ty, true);
+            method(
+                is_unsafe,
+                quote!(fn cpp_from_move(src: #src) -> Self),
+                ctor_call(name, conversion, is_unsafe, true),
+            )
+        });
+        quote! {
+            impl #impl_generics #tr<#ty> for #name #ty_generics #where_clause {
+                #from_fn
+                #move_fn
+            }
+        }
+    });
+
+    let impl_trait = format_ident!("{}Impl", name);
+    let into_impls = intos.iter().map(|conversion| {
+        let ty = &conversion.ty;
+        let op = &conversion.method;
+        let self_ty = quote!(#name #ty_generics);
+        let src = pointer(&syn::parse_quote!(#self_ty), false);
+        let body = if is_unsafe {
+            quote!((*src).#op())
+        } else {
+            quote!(#impl_trait::#op(&src))
+        };
+        let from_fn = method(is_unsafe, quote!(fn cpp_from(src: #src) -> Self), body);
+        quote! {
+            impl #impl_generics #tr<#self_ty> for #ty #where_clause {
+                #from_fn
+            }
+        }
+    });
+
+    quote! {
+        #(#from_impls)*
+        #(#into_impls)*
+    }
+    .into()
+}
diff --git a/libcc2rs-macros/src/lib.rs b/libcc2rs-macros/src/lib.rs
index 9d0076c753..0471f4c453 100644
--- a/libcc2rs-macros/src/lib.rs
+++ b/libcc2rs-macros/src/lib.rs
@@ -5,6 +5,7 @@ use proc_macro::TokenStream;
 
 mod assign;
 mod byte_repr;
+mod cpp_from;
 mod destructor;
 mod fn_ptr_arg;
 mod goto;
@@ -217,3 +218,20 @@ pub fn derive_destructor(input: TokenStream) -> TokenStream {
 pub fn derive_destructor_unsafe(input: TokenStream) -> TokenStream {
     destructor::expand(input, true)
 }
+
+//     #[derive(CppFrom)]
+//     #[cpp_from(i32, new, value)]
+//     #[cpp_into(i32, to_i32)]
+//     pub struct S { ... }
+//
+// Encodes the C++ converting construction and conversion operators in rules.
+
+#[proc_macro_derive(CppFrom, attributes(cpp_from, cpp_from_move, cpp_into))]
+pub fn derive_cpp_from(input: TokenStream) -> TokenStream {
+    cpp_from::expand(input, false)
+}
+
+#[proc_macro_derive(CppFromUnsafe, attributes(cpp_from, cpp_from_move, cpp_into))]
+pub fn derive_cpp_from_unsafe(input: TokenStream) -> TokenStream {
+    cpp_from::expand(input, true)
+}
diff --git a/libcc2rs/src/conversion.rs b/libcc2rs/src/conversion.rs
new file mode 100644
index 0000000000..946e6aee3d
--- /dev/null
+++ b/libcc2rs/src/conversion.rs
@@ -0,0 +1,37 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use crate::rc::Ptr;
+use crate::reinterpret::ByteRepr;
+
+pub trait CppFrom<S>: Sized {
+    fn cpp_from(src: Ptr<S>) -> Self;
+
+    fn cpp_from_move(src: Ptr<S>) -> Self {
+        Self::cpp_from(src)
+    }
+}
+
+pub trait CppFromUnsafe<S>: Sized {
+    /// # Safety
+    /// `src` must point to a live value.
+    unsafe fn cpp_from(src: *const S) -> Self;
+
+    /// # Safety
+    /// `src` must point to a live value.
+    unsafe fn cpp_from_move(src: *mut S) -> Self {
+        unsafe { Self::cpp_from(src) }
+    }
+}
+
+impl<T: Clone + ByteRepr> CppFrom<T> for T {
+    fn cpp_from(src: Ptr<T>) -> T {
+        src.read()
+    }
+}
+
+impl<T: Clone> CppFromUnsafe<T> for T {
+    unsafe fn cpp_from(src: *const T) -> T {
+        unsafe { (*src).clone() }
+    }
+}
diff --git a/libcc2rs/src/lib.rs b/libcc2rs/src/lib.rs
index 82649cc40e..054d91d25a 100644
--- a/libcc2rs/src/lib.rs
+++ b/libcc2rs/src/lib.rs
@@ -48,6 +48,9 @@ pub use capture::{
 mod cmp;
 pub use cmp::*;
 
+mod conversion;
+pub use conversion::{CppFrom, CppFromUnsafe};
+
 mod swap;
 // Used by cpp_swap! and cpp_swap_unsafe!.
 #[doc(hidden)]
@@ -99,7 +102,7 @@ mod format;
 pub use format::*;
 
 pub use libcc2rs_macros::{
-    ByteRepr, CopyAssign, CopyAssignUnsafe, Destructor, DestructorUnsafe, FnPtrArg, MoveAssign,
-    MoveAssignUnsafe, MoveCtor, MoveCtorUnsafe, Record, VaArg, goto, goto_block, lambda,
-    lambda_unsafe, switch,
+    ByteRepr, CopyAssign, CopyAssignUnsafe, CppFrom, CppFromUnsafe, Destructor, DestructorUnsafe,
+    FnPtrArg, MoveAssign, MoveAssignUnsafe, MoveCtor, MoveCtorUnsafe, Record, VaArg, goto,
+    goto_block, lambda, lambda_unsafe, switch,
 };
diff --git a/rule-preprocessor/src/ir.rs b/rule-preprocessor/src/ir.rs
index a767bf3766..09014cd82b 100644
--- a/rule-preprocessor/src/ir.rs
+++ b/rule-preprocessor/src/ir.rs
@@ -76,7 +76,7 @@ pub struct TypeInfo {
 pub struct FnIr {
     pub body: Vec<BodyFragment>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub generics: Option<BTreeMap<String, Vec<String>>>,
+    pub generics: Option<BTreeMap<String, Vec<Bound>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub multi_statement: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -110,6 +110,9 @@ impl FnIr {
                     check(&method_call.receiver) || check(&method_call.body)
                 }
                 BodyFragment::RefExpr { ref_expr } => check(&ref_expr.inner),
+                BodyFragment::GenericCall { generic_call } => {
+                    generic_call.args.iter().any(|arg| check(arg))
+                }
                 _ => false,
             })
         }
@@ -161,9 +164,6 @@ pub enum BodyFragment {
     Generic {
         generic: i32,
     },
-    Default {
-        default: i32,
-    },
     MethodCall {
         method_call: MethodCallInner,
     },
@@ -176,6 +176,9 @@ pub enum BodyFragment {
     Init {
         init: std::marker::PhantomData<()>,
     },
+    GenericCall {
+        generic_call: GenericCallInner,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -208,6 +211,20 @@ pub struct RefExprInner {
     pub inner: Vec<BodyFragment>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GenericCallInner {
+    pub generic: i32,
+    pub method: String,
+    pub args: Vec<Vec<BodyFragment>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Bound {
+    #[serde(rename = "trait")]
+    pub trait_name: String,
+    pub args: Vec<String>,
+}
+
 // For convenience: match on fragment kind
 impl BodyFragment {
     pub fn as_text_mut(&mut self) -> Option<&mut String> {
@@ -258,6 +275,13 @@ fn resolve_nth_unknown(
                         return true;
                     }
                 }
+                BodyFragment::GenericCall { generic_call } => {
+                    for arg in &mut generic_call.args {
+                        if resolve(arg, param, nth, count, patch) {
+                            return true;
+                        }
+                    }
+                }
                 _ => {}
             }
         }
diff --git a/rule-preprocessor/src/syntactic.rs b/rule-preprocessor/src/syntactic.rs
index 17fc7b50be..1441fc7ee6 100644
--- a/rule-preprocessor/src/syntactic.rs
+++ b/rule-preprocessor/src/syntactic.rs
@@ -11,8 +11,8 @@ use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
 use crate::ir::{
-    Access, BodyFragment, FileIr, FnIr, MethodCallInner, Model, PlaceholderInner, RefExprInner,
-    RuleIr, RulesIR, TypeInfo, TypeIr,
+    Access, BodyFragment, Bound, FileIr, FnIr, GenericCallInner, MethodCallInner, Model,
+    PlaceholderInner, RefExprInner, RuleIr, RulesIR, TypeInfo, TypeIr,
 };
 
 /// Classify a type AST node as refcount pointer (`Ptr<T>`), unsafe pointer
@@ -190,12 +190,12 @@ impl<'a> FragmentCtx<'a> {
                     self.emit_method_call(&call);
                     return;
                 }
-                if let Some(generic) =
-                    ast::CallExpr::cast(node.clone()).and_then(|call| self.generic_default(&call))
+                if let Some(generic_call) =
+                    ast::CallExpr::cast(node.clone()).and_then(|call| self.generic_call(&call))
                 {
                     self.flush_text();
                     self.fragments
-                        .push(BodyFragment::Default { default: generic });
+                        .push(BodyFragment::GenericCall { generic_call });
                     return;
                 }
                 for child in node.children_with_tokens() {
@@ -260,22 +260,11 @@ impl<'a> FragmentCtx<'a> {
         self.text_buf.push_str(token.text());
     }
 
-    fn generic_default(&self, call: &ast::CallExpr) -> Option<i32> {
-        if call.arg_list()?.args().next().is_some() {
+    fn generic_of_path(&self, path: &ast::Path) -> Option<i32> {
+        if path.qualifier().is_some() {
             return None;
         }
-        let ast::Expr::PathExpr(path_expr) = call.expr()? else {
-            return None;
-        };
-        let path = path_expr.path()?;
-        if path.segment()?.name_ref()?.text() != "default" {
-            return None;
-        }
-        let qualifier = path.qualifier()?;
-        if qualifier.qualifier().is_some() {
-            return None;
-        }
-        let segment = qualifier.segment()?;
+        let segment = path.segment()?;
         let name = match segment.name_ref() {
             Some(name_ref) => name_ref.text().to_string(),
             None => segment
@@ -292,6 +281,29 @@ impl<'a> FragmentCtx<'a> {
         Some(name[1..].parse().unwrap_or(0))
     }
 
+    fn generic_call(&self, call: &ast::CallExpr) -> Option<GenericCallInner> {
+        let ast::Expr::PathExpr(path_expr) = call.expr()? else {
+            return None;
+        };
+        let path = path_expr.path()?;
+        let method = path.segment()?.name_ref()?.text().to_string();
+        let generic = self.generic_of_path(&path.qualifier()?)?;
+        let args = call
+            .arg_list()?
+            .args()
+            .map(|arg| {
+                let mut ctx = FragmentCtx::new(self.builder, self.params, self.generic_names);
+                ctx.visit(ra_ap_syntax::NodeOrToken::Node(arg.syntax().clone()));
+                ctx.finish()
+            })
+            .collect();
+        Some(GenericCallInner {
+            generic,
+            method,
+            args,
+        })
+    }
+
     fn emit_method_call(&mut self, call: &ast::MethodCallExpr) {
         assert!(
             call.receiver().is_some(),
@@ -401,14 +413,37 @@ impl<'a> FnIrBuilder<'a> {
         }
     }
 
-    fn generics(&self) -> BTreeMap<String, Vec<String>> {
+    fn generics(&self) -> BTreeMap<String, Vec<Bound>> {
         let mut generics = BTreeMap::new();
 
-        let extract_bounds = |tbl: Option<ast::TypeBoundList>| -> Vec<String> {
+        let extract_bounds = |tbl: Option<ast::TypeBoundList>| -> Vec<Bound> {
             tbl.into_iter()
                 .flat_map(|tbl| tbl.bounds())
-                .map(|b| b.syntax().text().to_string())
-                .filter(|s| s != "'static")
+                .filter(|b| b.lifetime().is_none())
+                .map(|b| {
+                    let segment = match b.ty() {
+                        Some(ast::Type::PathType(path)) => path.path().and_then(|p| p.segment()),
+                        _ => None,
+                    };
+                    let Some(segment) = segment else {
+                        return Bound {
+                            trait_name: b.syntax().text().to_string(),
+                            args: Vec::new(),
+                        };
+                    };
+                    Bound {
+                        trait_name: segment
+                            .name_ref()
+                            .map(|name| name.text().to_string())
+                            .unwrap_or_default(),
+                        args: segment
+                            .generic_arg_list()
+                            .into_iter()
+                            .flat_map(|args| args.generic_args())
+                            .map(|arg| arg.syntax().text().to_string())
+                            .collect(),
+                    }
+                })
                 .collect()
         };
 
diff --git a/rules/algorithm/tgt_refcount.rs b/rules/algorithm/tgt_refcount.rs
index 00ebd32424..69a2f5bd53 100644
--- a/rules/algorithm/tgt_refcount.rs
+++ b/rules/algorithm/tgt_refcount.rs
@@ -17,8 +17,8 @@ fn f1<T1: CppRandomAccessIterator<T2>, T2: CppLess + Clone + ByteRepr>(a0: T1, a
 fn f2<
     T1: CppInputIterator<T3>,
     T2: CppIterator<T4>,
-    T3: Clone + ByteRepr,
-    T4: From<T3> + ByteRepr,
+    T3: ByteRepr,
+    T4: CppFrom<T3> + ByteRepr,
 >(
     a0: T1,
     a1: T1,
@@ -28,7 +28,7 @@ fn f2<
     let __last = a1;
     let mut __out = a2;
     while __first != __last {
-        __out.iter_deref().write(__first.iter_deref().read().into());
+        __out.iter_deref().write(T4::cpp_from(__first.iter_deref()));
         __first.iter_inc();
         __out.iter_inc();
     }
diff --git a/rules/algorithm/tgt_unsafe.rs b/rules/algorithm/tgt_unsafe.rs
index 9aafbe9397..85f35d9325 100644
--- a/rules/algorithm/tgt_unsafe.rs
+++ b/rules/algorithm/tgt_unsafe.rs
@@ -18,7 +18,7 @@ unsafe fn f1<T1: UnsafeCppRandomAccessIterator<T2>, T2: Ord>(a0: T1, a1: T1) {
     }
 }
 
-unsafe fn f2<T1: UnsafeCppInputIterator<T3>, T2: UnsafeCppIterator<T4>, T3: Clone, T4: From<T3>>(
+unsafe fn f2<T1: UnsafeCppInputIterator<T3>, T2: UnsafeCppIterator<T4>, T3, T4: CppFromUnsafe<T3>>(
     a0: T1,
     a1: T1,
     a2: T2,
@@ -27,7 +27,7 @@ unsafe fn f2<T1: UnsafeCppInputIterator<T3>, T2: UnsafeCppIterator<T4>, T3: Clon
     let __last = a1;
     let mut __out = a2;
     while __first != __last {
-        *__out.iter_deref() = (*__first.iter_deref()).clone().into();
+        *__out.iter_deref() = T4::cpp_from(__first.iter_deref());
         __first.iter_inc();
         __out.iter_inc();
     }
diff --git a/rules/cctype/src.cpp b/rules/cctype/src.cpp
index 2b21305769..8832bf218c 100644
--- a/rules/cctype/src.cpp
+++ b/rules/cctype/src.cpp
@@ -3,4 +3,4 @@
 
 #include <ctype.h>
 
-template <typename T1> int f1(T1 a0) { return toupper(a0); }
+int f1(int a0) { return toupper(a0); }
diff --git a/rules/cctype/tgt_unsafe.rs b/rules/cctype/tgt_unsafe.rs
index 2d1f5b9806..17725e43ce 100644
--- a/rules/cctype/tgt_unsafe.rs
+++ b/rules/cctype/tgt_unsafe.rs
@@ -1,11 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-unsafe fn f1<T1: Into<i32>>(a0: T1) -> i32 {
-    let __c: i32 = a0.into();
-    if (0..=255).contains(&__c) {
-        (__c as u8).to_ascii_uppercase() as i32
+unsafe fn f1(a0: i32) -> i32 {
+    if (0..=255).contains(&a0) {
+        (a0 as u8).to_ascii_uppercase() as i32
     } else {
-        __c
+        a0
     }
 }
diff --git a/rules/fstream/src.cpp b/rules/fstream/src.cpp
index 3e27d32bde..05905f6fe8 100644
--- a/rules/fstream/src.cpp
+++ b/rules/fstream/src.cpp
@@ -7,7 +7,7 @@
 
 using t1 = std::ifstream;
 using t2 = std::ofstream;
-using t3 = std::ostream_iterator<char>;
+template <typename T1> using t3 = std::ostream_iterator<T1>;
 using t4 = std::ostream_iterator<char>::ostream_type;
 
 std::ofstream f1(const char *filename, std::ios_base::openmode mode) {
diff --git a/rules/fstream/tgt_unsafe.rs b/rules/fstream/tgt_unsafe.rs
index 9542e030a7..b43ad125d0 100644
--- a/rules/fstream/tgt_unsafe.rs
+++ b/rules/fstream/tgt_unsafe.rs
@@ -9,7 +9,7 @@ fn t2() -> ::std::fs::File {
     ::std::fs::File::open("").unwrap()
 }
 
-fn t3() -> ::std::fs::File {
+fn t3<T1>() -> ::std::fs::File {
     ::std::fs::File::open("").unwrap()
 }
 
diff --git a/rules/iterator_category/src.cpp b/rules/iterator_category/src.cpp
index 35c3670e71..3895c49cdb 100644
--- a/rules/iterator_category/src.cpp
+++ b/rules/iterator_category/src.cpp
@@ -387,3 +387,18 @@ template <
 T1 &f26(T3 &&a0) {
   return --a0;
 }
+
+template <
+    typename T1, typename T2,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::input_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        std::is_base_of<
+            std::input_iterator_tag,
+            typename std::iterator_traits<T2>::iterator_category>::value &&
+        !std::is_same<T1, T2>::value && !std::is_pointer<T1>::value &&
+        !std::is_pointer<T2>::value>::type>
+auto f27(const T1 &a0, const T2 &a1) -> decltype(a0 == a1) {
+  return a0 == a1;
+}
diff --git a/rules/iterator_category/tgt_refcount.rs b/rules/iterator_category/tgt_refcount.rs
index 30d6500464..8e3828931d 100644
--- a/rules/iterator_category/tgt_refcount.rs
+++ b/rules/iterator_category/tgt_refcount.rs
@@ -128,3 +128,7 @@ fn f26<T1: CppBidirectionalIterator<T2>, T2>(a0: T1) -> T1 {
     let mut __it = a0;
     __it.iter_dec()
 }
+
+fn f27<T1: CppInputIterator<T3> + PartialEq<T2>, T2: CppInputIterator<T3>, T3>(a0: T1, a1: T2) -> bool {
+    a0 == a1
+}
diff --git a/rules/iterator_category/tgt_unsafe.rs b/rules/iterator_category/tgt_unsafe.rs
index 49694d5eb3..e288beda66 100644
--- a/rules/iterator_category/tgt_unsafe.rs
+++ b/rules/iterator_category/tgt_unsafe.rs
@@ -128,3 +128,7 @@ unsafe fn f26<T1: UnsafeCppBidirectionalIterator<T2>, T2>(a0: T1) -> T1 {
     let mut __it = a0;
     __it.iter_dec()
 }
+
+unsafe fn f27<T1: UnsafeCppInputIterator<T3> + PartialEq<T2>, T2: UnsafeCppInputIterator<T3>, T3>(a0: T1, a1: T2) -> bool {
+    a0 == a1
+}
diff --git a/rules/pair/src.cpp b/rules/pair/src.cpp
index f085066f66..e6c24349c4 100644
--- a/rules/pair/src.cpp
+++ b/rules/pair/src.cpp
@@ -78,3 +78,35 @@ template <typename T1, typename T2> T1 &&f21(std::pair<T1, T2> &&a0) {
 template <typename T1, typename T2> T2 &&f22(std::pair<T1, T2> &&a0) {
   return std::get<1>(std::move(a0));
 }
+
+template <
+    typename T1, typename T2, typename T3, typename T4,
+    typename = typename std::enable_if<!(std::is_same<T1, T3>::value &&
+                                         std::is_same<T2, T4>::value)>::type>
+std::pair<T1, T2> f23(std::pair<T3, T4> &&a0) {
+  return std::pair<T1, T2>(std::move(a0));
+}
+
+template <
+    typename T1, typename T2, typename T3, typename T4,
+    typename = typename std::enable_if<!(std::is_same<T1, T3>::value &&
+                                         std::is_same<T2, T4>::value)>::type>
+std::pair<T1, T2> f24(const std::pair<T3, T4> &a0) {
+  return std::pair<T1, T2>(a0);
+}
+
+template <
+    typename T1, typename T2, typename T3, typename T4,
+    typename = typename std::enable_if<!(std::is_same<T1, T3>::value &&
+                                         std::is_same<T2, T4>::value)>::type>
+std::pair<T1, T2> &f25(std::pair<T1, T2> &a0, const std::pair<T3, T4> &a1) {
+  return a0.template operator= <T3, T4>(a1);
+}
+
+template <
+    typename T1, typename T2, typename T3, typename T4,
+    typename = typename std::enable_if<!(std::is_same<T1, T3>::value &&
+                                         std::is_same<T2, T4>::value)>::type>
+std::pair<T1, T2> &f26(std::pair<T1, T2> &a0, std::pair<T3, T4> &&a1) {
+  return a0.template operator= <T3, T4>(std::move(a1));
+}
diff --git a/rules/pair/tgt_refcount.rs b/rules/pair/tgt_refcount.rs
index 07757ab396..5ca871e600 100644
--- a/rules/pair/tgt_refcount.rs
+++ b/rules/pair/tgt_refcount.rs
@@ -20,24 +20,15 @@ fn f2<T1: Clone, T2: Clone>(a0: (Value<T1>, Value<T2>)) -> (Value<T1>, Value<T2>
 }
 
 fn f7<T1, T2>(a0: T1, a1: T2) -> (Value<T1>, Value<T2>) {
-    (
-        Rc::new(RefCell::new(a0.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(a1.try_into().expect("failed conversion"))),
-    )
+    (Rc::new(RefCell::new(a0)), Rc::new(RefCell::new(a1)))
 }
 
 fn f9<T1, T2>(a0: T1, a1: T2) -> (Value<T1>, Value<T2>) {
-    (
-        Rc::new(RefCell::new(a0.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(a1.try_into().expect("failed conversion"))),
-    )
+    (Rc::new(RefCell::new(a0)), Rc::new(RefCell::new(a1)))
 }
 
 fn f10<T1, T2>(a0: T1, a1: T2) -> (Value<T1>, Value<T2>) {
-    (
-        Rc::new(RefCell::new(a0.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(a1.try_into().expect("failed conversion"))),
-    )
+    (Rc::new(RefCell::new(a0)), Rc::new(RefCell::new(a1)))
 }
 
 fn f12<T1: Default, T2: Default>(a0: &mut (Value<T1>, Value<T2>)) -> (Value<T1>, Value<T2>) {
@@ -92,3 +83,45 @@ fn f21<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Ptr<T1> {
 fn f22<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Ptr<T2> {
     a0.1.as_pointer()
 }
+
+fn f23<T1: CppFrom<T3>, T2: CppFrom<T4>, T3, T4>(
+    a0: &mut (Value<T3>, Value<T4>),
+) -> (Value<T1>, Value<T2>) {
+    let __a0 = a0;
+    (
+        Rc::new(RefCell::new(T1::cpp_from_move(__a0.0.as_pointer()))),
+        Rc::new(RefCell::new(T2::cpp_from_move(__a0.1.as_pointer()))),
+    )
+}
+
+fn f24<T1: CppFrom<T3>, T2: CppFrom<T4>, T3, T4>(
+    a0: (Value<T3>, Value<T4>),
+) -> (Value<T1>, Value<T2>) {
+    let __a0 = a0;
+    (
+        Rc::new(RefCell::new(T1::cpp_from(__a0.0.as_pointer()))),
+        Rc::new(RefCell::new(T2::cpp_from(__a0.1.as_pointer()))),
+    )
+}
+
+fn f25<T1: CppFrom<T3> + ByteRepr, T2: CppFrom<T4> + ByteRepr, T3, T4>(
+    a0: Ptr<(Value<T1>, Value<T2>)>,
+    a1: (Value<T3>, Value<T4>),
+) {
+    let __a1 = a1;
+    a0.write((
+        Rc::new(RefCell::new(T1::cpp_from(__a1.0.as_pointer()))),
+        Rc::new(RefCell::new(T2::cpp_from(__a1.1.as_pointer()))),
+    ))
+}
+
+fn f26<T1: CppFrom<T3> + ByteRepr, T2: CppFrom<T4> + ByteRepr, T3, T4>(
+    a0: Ptr<(Value<T1>, Value<T2>)>,
+    a1: &mut (Value<T3>, Value<T4>),
+) {
+    let __a1 = a1;
+    a0.write((
+        Rc::new(RefCell::new(T1::cpp_from_move(__a1.0.as_pointer()))),
+        Rc::new(RefCell::new(T2::cpp_from_move(__a1.1.as_pointer()))),
+    ))
+}
diff --git a/rules/pair/tgt_unsafe.rs b/rules/pair/tgt_unsafe.rs
index 0604e05526..b49796e166 100644
--- a/rules/pair/tgt_unsafe.rs
+++ b/rules/pair/tgt_unsafe.rs
@@ -1,6 +1,8 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+use libcc2rs::*;
+
 fn t1<T1: Default, T2: Default>() -> (T1, T2) {
     <(T1, T2)>::default()
 }
@@ -17,13 +19,13 @@ unsafe fn f2<T1: Clone, T2: Clone>(a0: (T1, T2)) -> (T1, T2) {
     a0.clone()
 }
 unsafe fn f7<T1, T2>(a0: T1, a1: T2) -> (T1, T2) {
-    (a0.into(), a1.into())
+    (a0, a1)
 }
 unsafe fn f9<T1, T2>(a0: T1, a1: T2) -> (T1, T2) {
-    (a0.into(), a1.into())
+    (a0, a1)
 }
 unsafe fn f10<T1, T2>(a0: T1, a1: T2) -> (T1, T2) {
-    (a0.into(), a1.into())
+    (a0, a1)
 }
 
 unsafe fn f12<T1: Default, T2: Default>(a0: &mut (T1, T2)) -> (T1, T2) {
@@ -69,3 +71,23 @@ unsafe fn f21<T1, T2>(a0: &mut (T1, T2)) -> *mut T1 {
 unsafe fn f22<T1, T2>(a0: &mut (T1, T2)) -> *mut T2 {
     &mut a0.1
 }
+
+unsafe fn f23<T1: CppFromUnsafe<T3>, T2: CppFromUnsafe<T4>, T3, T4>(a0: &mut (T3, T4)) -> (T1, T2) {
+    let mut __a0 = a0;
+    (T1::cpp_from_move(&mut __a0.0), T2::cpp_from_move(&mut __a0.1))
+}
+
+unsafe fn f24<T1: CppFromUnsafe<T3>, T2: CppFromUnsafe<T4>, T3, T4>(a0: &(T3, T4)) -> (T1, T2) {
+    let __a0 = a0;
+    (T1::cpp_from(&__a0.0), T2::cpp_from(&__a0.1))
+}
+
+unsafe fn f25<T1: CppFromUnsafe<T3>, T2: CppFromUnsafe<T4>, T3, T4>(a0: &mut (T1, T2), a1: &(T3, T4)) {
+    let __a1 = a1;
+    *a0 = (T1::cpp_from(&__a1.0), T2::cpp_from(&__a1.1))
+}
+
+unsafe fn f26<T1: CppFromUnsafe<T3>, T2: CppFromUnsafe<T4>, T3, T4>(a0: &mut (T1, T2), a1: &mut (T3, T4)) {
+    let mut __a1 = a1;
+    *a0 = (T1::cpp_from_move(&mut __a1.0), T2::cpp_from_move(&mut __a1.1))
+}
diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs
index 5036c81e62..26814061c3 100644
--- a/rules/vector/tgt_refcount.rs
+++ b/rules/vector/tgt_refcount.rs
@@ -62,11 +62,11 @@ fn f79<T1: ByteRepr>(a0: &mut Vec<T1>, a1: RandomAccessIterator<T1>, a2: T1) ->
     __it
 }
 
-fn f92<T1: TryFrom<T2>, T2: Clone + ByteRepr, T3: CppInputIterator<T2>>(a0: T3, a1: T3) -> Vec<T1> {
+fn f92<T1: CppFrom<T4>, T2, T3: CppInputIterator<T4>, T4: ByteRepr>(a0: T3, a1: T3) -> Vec<T1> {
     let mut __v = Vec::new();
     let mut __it = a0;
     while __it != a1 {
-        __v.push(<T1>::try_from(__it.iter_deref().read()).ok().unwrap());
+        __v.push(T1::cpp_from(__it.iter_deref()));
         __it.iter_inc();
     }
     __v
diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs
index 4fe004b704..7f7a30e909 100644
--- a/rules/vector/tgt_unsafe.rs
+++ b/rules/vector/tgt_unsafe.rs
@@ -148,11 +148,11 @@ unsafe fn f91<T1>(a0: Vec<T1>) -> Vec<T1> {
     a0
 }
 
-unsafe fn f92<T1: TryFrom<T2>, T2: Clone, T3: UnsafeCppInputIterator<T2>>(a0: T3, a1: T3) -> Vec<T1> {
+unsafe fn f92<T1: CppFromUnsafe<T4>, T2, T3: UnsafeCppInputIterator<T4>, T4>(a0: T3, a1: T3) -> Vec<T1> {
     let mut __v = Vec::new();
     let mut __it = a0;
     while __it != a1 {
-        __v.push(<T1>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+        __v.push(T1::cpp_from(__it.iter_deref()));
         __it.iter_inc();
     }
     __v
diff --git a/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs b/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs
index 38069e3e4e..10d03e072d 100644
--- a/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs
+++ b/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, MoveAssign)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, MoveAssign)]
+#[cpp_from(i32, new, value)]
 #[byte_size(32)]
 pub struct S {
     #[offset(0)]
diff --git a/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs b/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs
index b87f18149f..b38d5709fe 100644
--- a/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs
+++ b/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, MoveAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct S {
     pub v: Vec<i32>,
     pub n: [i32; 2],
diff --git a/tests/ub/out/refcount/ctor_ref_member.rs b/tests/ub/out/refcount/ctor_ref_member.rs
index b68843205a..7bade32e0c 100644
--- a/tests/ub/out/refcount/ctor_ref_member.rs
+++ b/tests/ub/out/refcount/ctor_ref_member.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, ptr)]
 #[byte_size(8)]
 pub struct S {
     #[offset(0)]
diff --git a/tests/ub/out/unsafe/ctor_ref_member.rs b/tests/ub/out/unsafe/ctor_ref_member.rs
index c79840e0b2..21de4ecc9a 100644
--- a/tests/ub/out/unsafe/ctor_ref_member.rs
+++ b/tests/ub/out/unsafe/ctor_ref_member.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, ptr)]
 pub struct S {
     pub r: *const i32,
 }
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index ebd577ad16..294e7c90b5 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -213,8 +213,8 @@ fn main_0() -> i32 {
         (*i.borrow_mut()).prefix_inc();
     }
     let pair1: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(1)),
+        Rc::new(RefCell::new(2)),
     )));
     let pair2: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new((*pair1.borrow()).0.borrow().clone())),
@@ -228,13 +228,9 @@ fn main_0() -> i32 {
     assert!(((*(*pair1.borrow()).1.borrow()) == 2));
     let pair3: Value<(Value<Vec<i32>>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new(
-            (0..(0_usize) as usize)
-                .map(|_| 0_i32)
-                .collect::<Vec<_>>()
-                .try_into()
-                .expect("failed conversion"),
+            (0..(0_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>(),
         )),
-        Rc::new(RefCell::new(0.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(0)),
     )));
     let pair4: Value<(Value<Vec<i32>>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new((*pair3.borrow()).0.borrow().clone())),
diff --git a/tests/unit/out/refcount/constructor.rs b/tests/unit/out/refcount/constructor.rs
index 99d1805402..9035fdb03f 100644
--- a/tests/unit/out/refcount/constructor.rs
+++ b/tests/unit/out/refcount/constructor.rs
@@ -9,7 +9,8 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static total_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Destructor, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Destructor, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct S {
     #[offset(0)]
@@ -24,7 +25,8 @@ impl S {
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom)]
+#[cpp_from(i32, new_1, value)]
 #[byte_size(8)]
 pub struct Point {
     #[offset(0)]
@@ -33,11 +35,11 @@ pub struct Point {
     pub y: i32,
 }
 impl Point {
-    pub fn new_1(mut x: i32, mut y: i32) -> Self {
+    pub fn new_2(mut x: i32, mut y: i32) -> Self {
         Self { x: x, y: y }
     }
-    pub fn new_2(mut v: i32) -> Self {
-        let __this: Value<Point> = Rc::new(RefCell::new(Point::new_1({ v }, { (v + 1) })));
+    pub fn new_1(mut v: i32) -> Self {
+        let __this: Value<Point> = Rc::new(RefCell::new(Point::new_2({ v }, { (v + 1) })));
         let this: Ptr<Point> = __this.as_pointer();
         {
             field!(this, y).with_mut(|__v| *__v = *__v * 10)
@@ -45,7 +47,7 @@ impl Point {
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
     pub fn new_3() -> Self {
-        let __this: Value<Point> = Rc::new(RefCell::new(Point::new_2({ 4 })));
+        let __this: Value<Point> = Rc::new(RefCell::new(Point::new_1({ 4 })));
         let this: Ptr<Point> = __this.as_pointer();
         {
             field!(this, x).with_mut(|__v| *__v = *__v + 100)
@@ -73,7 +75,7 @@ fn main_0() -> i32 {
     let mut p: Point = Point::new_3();
     assert!((p.x == 104));
     assert!((p.y == 50));
-    let mut q: Point = Point::new_2({ 7 });
+    let mut q: Point = Point::new_1({ 7 });
     assert!((q.x == 7));
     assert!((q.y == 80));
     return 0;
diff --git a/tests/unit/out/refcount/conversion_operator_same_translation.rs b/tests/unit/out/refcount/conversion_operator_same_translation.rs
index ec3fc43cd8..0479837a24 100644
--- a/tests/unit/out/refcount/conversion_operator_same_translation.rs
+++ b/tests/unit/out/refcount/conversion_operator_same_translation.rs
@@ -6,13 +6,16 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_into(i8, to_i8)]
+#[cpp_into(u8, to_u8)]
 #[byte_size(4)]
 pub struct S {
     #[offset(0)]
     pub v: i32,
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_into(i64, to_i64_1)]
 #[byte_size(4)]
 pub struct T {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/copy_assign.rs b/tests/unit/out/refcount/copy_assign.rs
index 7eda28563b..75007299c3 100644
--- a/tests/unit/out/refcount/copy_assign.rs
+++ b/tests/unit/out/refcount/copy_assign.rs
@@ -94,7 +94,8 @@ impl Default for Holder {
 thread_local!(
     pub static copies_1: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct CopyCounted {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/copy_ctor.rs b/tests/unit/out/refcount/copy_ctor.rs
index 26ad076bed..a9408f9443 100644
--- a/tests/unit/out/refcount/copy_ctor.rs
+++ b/tests/unit/out/refcount/copy_ctor.rs
@@ -9,7 +9,8 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static copies_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Counted {
     #[offset(0)]
@@ -67,7 +68,8 @@ impl Default for NonConst {
         { NonConst::new() }
     }
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Ignored {
     #[offset(0)]
@@ -111,7 +113,8 @@ impl Default for Holder {
         }
     }
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Box_int_ {
     #[offset(0)]
@@ -155,7 +158,8 @@ impl Owner {
         }
     }
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct OutOfLine {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/copy_move_defaulted.rs b/tests/unit/out/refcount/copy_move_defaulted.rs
index fb4d4c66e6..d2d204987c 100644
--- a/tests/unit/out/refcount/copy_move_defaulted.rs
+++ b/tests/unit/out/refcount/copy_move_defaulted.rs
@@ -12,7 +12,8 @@ pub struct Inner {
     #[offset(0)]
     pub x: i32,
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Destructor)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Destructor)]
+#[cpp_from(i32, new, value)]
 #[byte_size(16)]
 pub struct Explicit {
     #[offset(0)]
@@ -67,7 +68,8 @@ impl Default for Implicit {
         }
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, MoveAssign, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, MoveAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct DefaultCopyUserMove {
     #[offset(0)]
@@ -85,7 +87,8 @@ impl DefaultCopyUserMove {
         __this
     }
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, MoveAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, CopyAssign, MoveAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct UserCopyDefaultMove {
     #[offset(0)]
@@ -113,7 +116,8 @@ impl Clone for UserCopyDefaultMove {
         UserCopyDefaultMove::copy_from(__src.as_pointer())
     }
 }
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, MoveAssign)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, MoveAssign)]
+#[cpp_from(i32, new, value)]
 #[byte_size(64)]
 pub struct Buffer {
     #[offset(0)]
@@ -219,7 +223,8 @@ impl Copyable {
         }
     }
 }
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, MoveAssign, Destructor, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, MoveAssign, Destructor, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(32)]
 pub struct Holder {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/copy_move_deleted.rs b/tests/unit/out/refcount/copy_move_deleted.rs
index e088db3b82..a853b47e90 100644
--- a/tests/unit/out/refcount/copy_move_deleted.rs
+++ b/tests/unit/out/refcount/copy_move_deleted.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, MoveAssign, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, MoveAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct NoCopy {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/default_function_arguments.rs b/tests/unit/out/refcount/default_function_arguments.rs
index 955cd0f47d..05161592a2 100644
--- a/tests/unit/out/refcount/default_function_arguments.rs
+++ b/tests/unit/out/refcount/default_function_arguments.rs
@@ -14,7 +14,8 @@ pub fn baz_1(mut a: Ptr<i32>, b: Option<Ptr<i32>>) -> bool {
     let mut b: Ptr<i32> = b.unwrap_or_else(|| Ptr::<i32>::null());
     return ({ a } == { b });
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom)]
+#[cpp_from(i32, new, some_value)]
 #[byte_size(4)]
 pub struct Bar {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/fn_ptr.rs b/tests/unit/out/refcount/fn_ptr.rs
index 885ca183f3..236c7d38f0 100644
--- a/tests/unit/out/refcount/fn_ptr.rs
+++ b/tests/unit/out/refcount/fn_ptr.rs
@@ -28,7 +28,8 @@ pub fn call_fn_5(mut f: FnPtr<fn(i32) -> usize>, mut v: i32) -> usize {
 pub fn identity_hash_6(mut v: bool) -> usize {
     return (v as usize);
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(FnPtr<fn(bool  ,) -> u64  >  , new, ptr)]
 #[byte_size(8)]
 pub struct HashHolder_unsigned_long__ptr__bool__ {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/fn_ptr_struct.rs b/tests/unit/out/refcount/fn_ptr_struct.rs
index 661face3dc..e5db915746 100644
--- a/tests/unit/out/refcount/fn_ptr_struct.rs
+++ b/tests/unit/out/refcount/fn_ptr_struct.rs
@@ -35,7 +35,8 @@ impl S {
         return (x + 3);
     }
 }
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct MoveOnly {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/forward_basic.rs b/tests/unit/out/refcount/forward_basic.rs
index 43a6863f28..9d8e4a7581 100644
--- a/tests/unit/out/refcount/forward_basic.rs
+++ b/tests/unit/out/refcount/forward_basic.rs
@@ -9,7 +9,8 @@ use std::rc::{Rc, Weak};
 pub type Overload = u32;
 pub const Overload_kLvalueOverload: Overload = 1;
 pub const Overload_kRvalueOverload: Overload = 2;
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(12)]
 pub struct Tracked {
     #[offset(0)]
@@ -74,7 +75,9 @@ impl Holder {
         }
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(Tracked, new_1, mut_ptr)]
+#[cpp_from_move(Tracked, new_2, ptr)]
 #[byte_size(12)]
 pub struct Holder {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/forward_decltype.rs b/tests/unit/out/refcount/forward_decltype.rs
index 75c79b963a..8b73ead5f0 100644
--- a/tests/unit/out/refcount/forward_decltype.rs
+++ b/tests/unit/out/refcount/forward_decltype.rs
@@ -9,7 +9,8 @@ use std::rc::{Rc, Weak};
 pub type Overload = u32;
 pub const Overload_kLvalueOverload: Overload = 1;
 pub const Overload_kRvalueOverload: Overload = 2;
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(12)]
 pub struct Tracked {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/forward_explicit.rs b/tests/unit/out/refcount/forward_explicit.rs
index da69f55d02..0f1c4de973 100644
--- a/tests/unit/out/refcount/forward_explicit.rs
+++ b/tests/unit/out/refcount/forward_explicit.rs
@@ -11,7 +11,8 @@ pub const Overload_kLvalueOverload: Overload = 1;
 pub const Overload_kRvalueOverload: Overload = 2;
 pub const Overload_kIntLvalueOverload: Overload = 3;
 pub const Overload_kIntRvalueOverload: Overload = 4;
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(12)]
 pub struct Tracked {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/forward_pack.rs b/tests/unit/out/refcount/forward_pack.rs
index 9def6d5d6f..c0add9eab0 100644
--- a/tests/unit/out/refcount/forward_pack.rs
+++ b/tests/unit/out/refcount/forward_pack.rs
@@ -11,7 +11,8 @@ pub const Overload_kLvalueOverload: Overload = 1;
 pub const Overload_kRvalueOverload: Overload = 2;
 pub const Overload_kIntLvalueOverload: Overload = 3;
 pub const Overload_kIntRvalueOverload: Overload = 4;
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(12)]
 pub struct Tracked {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/global_init_side_effect.rs b/tests/unit/out/refcount/global_init_side_effect.rs
index 062c8aa6dc..41110c2d18 100644
--- a/tests/unit/out/refcount/global_init_side_effect.rs
+++ b/tests/unit/out/refcount/global_init_side_effect.rs
@@ -9,7 +9,8 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static total_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(1)]
 pub struct S {}
 impl S {
diff --git a/tests/unit/out/refcount/lambda_as_field.rs b/tests/unit/out/refcount/lambda_as_field.rs
index 4507fd71fd..abd36c086b 100644
--- a/tests/unit/out/refcount/lambda_as_field.rs
+++ b/tests/unit/out/refcount/lambda_as_field.rs
@@ -63,7 +63,8 @@ pub struct Holder__lambda_at_lambda_as_field_cpp_51_12__ {
     #[offset(4)]
     pub calls: i32,
 }
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom)]
+#[cpp_from(FnPtr<fn(i32  ,) -> i32  >  , new, value)]
 #[byte_size(8)]
 pub struct Moving__lambda_at_lambda_as_field_cpp_64_12__ {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/lambda_move_only_capture.rs b/tests/unit/out/refcount/lambda_move_only_capture.rs
index fe42942aed..47e5ee9bad 100644
--- a/tests/unit/out/refcount/lambda_move_only_capture.rs
+++ b/tests/unit/out/refcount/lambda_move_only_capture.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, Destructor, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, Destructor, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(8)]
 pub struct Owner {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs
index 51afb82e4b..7031aac499 100644
--- a/tests/unit/out/refcount/map.rs
+++ b/tests/unit/out/refcount/map.rs
@@ -388,8 +388,8 @@ fn main_0() -> i32 {
     > = Rc::new(RefCell::new(Map::new()));
     assert!(((*other_map.borrow()).len() == 0_usize));
     let key0: Value<(Value<i32>, Value<i64>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(1)),
+        Rc::new(RefCell::new((1 as i64))),
     )));
     let mut value: f64 = 2_f64;
     Map::subscript(other_map.as_pointer(), key0.as_pointer()).write(value);
diff --git a/tests/unit/out/refcount/map_key_copy_ctor.rs b/tests/unit/out/refcount/map_key_copy_ctor.rs
index 1edf3a7ac3..f64a830b0e 100644
--- a/tests/unit/out/refcount/map_key_copy_ctor.rs
+++ b/tests/unit/out/refcount/map_key_copy_ctor.rs
@@ -15,7 +15,8 @@ thread_local!(
 thread_local!(
     pub static made_2: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Key {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/max.rs b/tests/unit/out/refcount/max.rs
index d39c7e6fad..fcd3341220 100644
--- a/tests/unit/out/refcount/max.rs
+++ b/tests/unit/out/refcount/max.rs
@@ -16,7 +16,8 @@ pub fn pick_2(mut i: i32) -> Ptr<i32> {
     (*calls_0.with(Value::clone).borrow_mut()).prefix_inc();
     return (xs_1.with(|v| v.as_pointer()) as Ptr<i32>).offset(i);
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Bag {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/move_assign.rs b/tests/unit/out/refcount/move_assign.rs
index cdf64fbb65..434943399c 100644
--- a/tests/unit/out/refcount/move_assign.rs
+++ b/tests/unit/out/refcount/move_assign.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, MoveAssign, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, MoveAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct MoveOnly {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/move_ctor.rs b/tests/unit/out/refcount/move_ctor.rs
index fe40d4ca44..c3f03e4add 100644
--- a/tests/unit/out/refcount/move_ctor.rs
+++ b/tests/unit/out/refcount/move_ctor.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct MoveOnly {
     #[offset(0)]
@@ -50,7 +51,8 @@ impl Default for ConstMove {
         { ConstMove::new() }
     }
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(12)]
 pub struct ThrowingMove {
     #[offset(0)]
@@ -95,7 +97,8 @@ impl Clone for ThrowingMove {
         ThrowingMove::copy_from(__src.as_pointer())
     }
 }
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(12)]
 pub struct NoexceptMove {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/move_this.rs b/tests/unit/out/refcount/move_this.rs
index b84e960519..fbd3a5ecd5 100644
--- a/tests/unit/out/refcount/move_this.rs
+++ b/tests/unit/out/refcount/move_this.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Chain {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/operator_comparison_nonbool.rs b/tests/unit/out/refcount/operator_comparison_nonbool.rs
index 3e9fe73ea9..dfb5f0bfcf 100644
--- a/tests/unit/out/refcount/operator_comparison_nonbool.rs
+++ b/tests/unit/out/refcount/operator_comparison_nonbool.rs
@@ -68,7 +68,8 @@ impl CppEq for Mixed {
         ((MixedImpl::operator_eq(__lhs, __rhs.clone())) != 0)
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_into(bool, to_bool)]
 #[byte_size(1)]
 pub struct MyBool {
     #[offset(0)]
@@ -107,7 +108,8 @@ pub fn operator_eq_7(mut a: Boolish, mut b: Boolish) -> MyBool {
 pub fn operator_lt_6(mut a: Boolish, mut b: Boolish) -> MyBool {
     return MyBool::new({ (a.v < b.v) });
 }
-#[derive(Record, ByteRepr, FnPtrArg, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, CppFrom, Default)]
+#[cpp_into(bool, to_bool)]
 #[byte_size(1)]
 pub struct RefBool {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/operator_comparison_noncopyable.rs b/tests/unit/out/refcount/operator_comparison_noncopyable.rs
index ee1d62c80f..d45af15f2f 100644
--- a/tests/unit/out/refcount/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/refcount/operator_comparison_noncopyable.rs
@@ -12,7 +12,8 @@ pub fn operator_eq_0(x: Ptr<S>, y: Ptr<S>) -> bool {
 pub fn operator_lt_1(x: Ptr<S>, y: Ptr<S>) -> bool {
     return ({ x.with(|__s| __s.data_) } < { y.with(|__s| __s.data_) });
 }
-#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct S {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/operator_other_member.rs b/tests/unit/out/refcount/operator_other_member.rs
index 5218bfa551..07a49e8dae 100644
--- a/tests/unit/out/refcount/operator_other_member.rs
+++ b/tests/unit/out/refcount/operator_other_member.rs
@@ -14,7 +14,8 @@ impl Static {
         return (a * b);
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_into(i32, to_i32)]
 #[byte_size(4)]
 pub struct S {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/overload_mangling.rs b/tests/unit/out/refcount/overload_mangling.rs
index 3ad28effd8..797b83c793 100644
--- a/tests/unit/out/refcount/overload_mangling.rs
+++ b/tests/unit/out/refcount/overload_mangling.rs
@@ -61,10 +61,7 @@ fn main_0() -> i32 {
         (({
             SImpl::pick_8(
                 &s.as_pointer(),
-                (
-                    Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-                    Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
-                ),
+                (Rc::new(RefCell::new(1)), Rc::new(RefCell::new(2))),
             )
         }) == 101)
     );
@@ -72,10 +69,7 @@ fn main_0() -> i32 {
         (({
             SImpl::pick_9(
                 &s.as_pointer(),
-                (
-                    Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-                    Rc::new(RefCell::new(2_i64.try_into().expect("failed conversion"))),
-                ),
+                (Rc::new(RefCell::new(1)), Rc::new(RefCell::new(2_i64))),
             )
         }) == 102)
     );
@@ -90,8 +84,8 @@ fn main_0() -> i32 {
     assert!(
         (({
             let _p: Value<(Value<i32>, Value<i64>)> = Rc::new(RefCell::new((
-                Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-                Rc::new(RefCell::new(2_i64.try_into().expect("failed conversion"))),
+                Rc::new(RefCell::new(1)),
+                Rc::new(RefCell::new(2_i64)),
             )));
             SImpl::combine_13(
                 &s.as_pointer(),
@@ -106,8 +100,8 @@ fn main_0() -> i32 {
     assert!(
         (({
             let _p: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
-                Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-                Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+                Rc::new(RefCell::new(1)),
+                Rc::new(RefCell::new(2)),
             )));
             SImpl::combine_14(
                 &s.as_pointer(),
diff --git a/tests/unit/out/refcount/pair.rs b/tests/unit/out/refcount/pair.rs
index 4fd402bece..f35fe5c266 100644
--- a/tests/unit/out/refcount/pair.rs
+++ b/tests/unit/out/refcount/pair.rs
@@ -12,21 +12,24 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let p1: Value<(Value<f64>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new((1 as f64))),
+        Rc::new(RefCell::new(2)),
     )));
     assert!(((*(*p1.borrow()).0.borrow()) == 1_f64));
     assert!(((*(*p1.borrow()).1.borrow()) == 2));
     let p2: Value<(Value<f64>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(3.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(4.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new((3 as f64))),
+        Rc::new(RefCell::new(4)),
     )));
     assert!(((*(*p2.borrow()).0.borrow()) == 3_f64));
     assert!(((*(*p2.borrow()).1.borrow()) == 4));
-    let p3: Value<(Value<f64>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(5.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(6.try_into().expect("failed conversion"))),
-    )));
+    let p3: Value<(Value<f64>, Value<i32>)> = Rc::new(RefCell::new({
+        let __a0 = (Rc::new(RefCell::new(5)), Rc::new(RefCell::new(6)));
+        (
+            Rc::new(RefCell::new(((__a0.0.as_pointer().read()) as f64))),
+            Rc::new(RefCell::new((__a0.1.as_pointer().read()))),
+        )
+    }));
     assert!(((*(*p3.borrow()).0.borrow()) == 5_f64));
     assert!(((*(*p3.borrow()).1.borrow()) == 6));
     let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2])));
@@ -41,15 +44,20 @@ fn main_0() -> i32 {
             })
             .collect::<Vec<_>>(),
     ));
-    (*const_ptr_pairs.borrow_mut())[0_usize] = (
-        Rc::new(RefCell::new(
-            (arr.as_pointer() as Ptr<i32>)
-                .offset((1) as isize)
-                .try_into()
-                .expect("failed conversion"),
-        )),
-        Rc::new(RefCell::new(n.try_into().expect("failed conversion"))),
-    );
+    {
+        let __a1 = (
+            Rc::new(RefCell::new(
+                (arr.as_pointer() as Ptr<i32>).offset((1) as isize),
+            )),
+            Rc::new(RefCell::new(n)),
+        );
+        const_ptr_pairs.decay().offset(0_usize).write((
+            Rc::new(RefCell::new(
+                <Ptr<i32> as CppFrom<Ptr<i32>>>::cpp_from_move(__a1.0.as_pointer()),
+            )),
+            Rc::new(RefCell::new(((__a1.1.as_pointer().read()) as u64))),
+        ))
+    };
     assert!(
         (((*(*const_ptr_pairs.borrow())[0_usize].0.borrow()).read()) == 2)
             && ((*(*const_ptr_pairs.borrow())[0_usize].1.borrow()) == 2_u64)
diff --git a/tests/unit/out/refcount/pair_converting_construction.rs b/tests/unit/out/refcount/pair_converting_construction.rs
new file mode 100644
index 0000000000..902cffbfd0
--- /dev/null
+++ b/tests/unit/out/refcount/pair_converting_construction.rs
@@ -0,0 +1,342 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
+#[byte_size(4)]
+pub struct Celsius {
+    #[offset(0)]
+    pub degrees: i32,
+}
+impl Celsius {
+    pub fn new(mut d: i32) -> Self {
+        Self { degrees: d }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_into(i32, to_i32)]
+#[byte_size(4)]
+pub struct Meters {
+    #[offset(0)]
+    pub value: i32,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Celsius, new, ptr)]
+#[byte_size(4)]
+pub struct Label {
+    #[offset(0)]
+    pub id: i32,
+}
+impl Label {
+    pub fn new(c: Ptr<Celsius>) -> Self {
+        Self {
+            id: c.with(|__s| __s.degrees),
+        }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Celsius, new_1, ptr)]
+#[cpp_from_move(Celsius, new_2, ptr)]
+#[byte_size(8)]
+pub struct Owner {
+    #[offset(0)]
+    pub taken: i32,
+    #[offset(4)]
+    pub copied: i32,
+}
+impl Owner {
+    pub fn new_1(c: Ptr<Celsius>) -> Self {
+        Self {
+            taken: 0,
+            copied: c.with(|__s| __s.degrees),
+        }
+    }
+    pub fn new_2(c: Ptr<Celsius>) -> Self {
+        Self {
+            taken: c.with(|__s| __s.degrees),
+            copied: 0,
+        }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Celsius, new, value)]
+#[byte_size(4)]
+pub struct Holder {
+    #[offset(0)]
+    pub value: i32,
+}
+impl Holder {
+    pub fn new(mut c: Celsius) -> Self {
+        Self { value: c.degrees }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom)]
+#[cpp_from(i32, new, some_value)]
+#[byte_size(4)]
+pub struct Fallback {
+    #[offset(0)]
+    pub value: i32,
+}
+impl Fallback {
+    pub fn new(v: Option<i32>) -> Self {
+        let mut v: i32 = v.unwrap_or_else(|| -1_i32);
+        Self { value: v }
+    }
+}
+impl Default for Fallback {
+    fn default() -> Self {
+        { Fallback::new(None) }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(4)]
+pub struct Counter {
+    #[offset(0)]
+    pub hits: i32,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Counter, new, mut_ptr)]
+#[byte_size(4)]
+pub struct Observer {
+    #[offset(0)]
+    pub seen: i32,
+}
+impl Observer {
+    pub fn new(c: Ptr<Counter>) -> Self {
+        let __this: Observer = Self {
+            seen: c.with(|__s| __s.hits),
+        };
+        field!(c, hits).with_mut(|__v| __v.postfix_inc());
+        __this
+    }
+}
+impl Tag {
+    pub fn new(u: Ptr<Celsius>) -> Self {
+        Self {
+            code: (u.with(|__s| __s.degrees) + 100),
+        }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Celsius, new, ptr)]
+#[byte_size(4)]
+pub struct Tag {
+    #[offset(0)]
+    pub code: i32,
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Ptr< i8  >  , new, value)]
+#[byte_size(4)]
+pub struct Name {
+    #[offset(0)]
+    pub len: i32,
+}
+impl Name {
+    pub fn new(mut s: Ptr<i8>) -> Self {
+        let __this: Value<Name> = Rc::new(RefCell::new(Self { len: 0 }));
+        let this: Ptr<Name> = __this.as_pointer();
+        'loop_: while ((elem!(s, this.with(|__s| __s.len)).read()) != 0) {
+            field!(this, len).with_mut(|__v| __v.prefix_inc());
+        }
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let widened: Value<(Value<i64>, Value<u32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new((-1_i32 as i64))),
+        Rc::new(RefCell::new(2_u32)),
+    )));
+    assert!(((*(*widened.borrow()).0.borrow()) == -1_i64));
+    assert!(((*(*widened.borrow()).1.borrow()) == 2_u32));
+    let from_ints: Value<(Value<Celsius>, Value<Celsius>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(Celsius::new({ 1 }))),
+        Rc::new(RefCell::new(Celsius::new({ 2 }))),
+    )));
+    assert!(({ (*(*from_ints.borrow()).0.borrow()).degrees } == 1));
+    assert!(({ (*(*from_ints.borrow()).1.borrow()).degrees } == 2));
+    let m: Value<Meters> = Rc::new(RefCell::new(Meters { value: 7 }));
+    let from_operators: Value<(Value<i32>, Value<i64>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(({ MetersImpl::to_i32(&m.as_pointer()) }))),
+        Rc::new(RefCell::new(
+            (({ MetersImpl::to_i32(&m.as_pointer()) }) as i64),
+        )),
+    )));
+    assert!(((*(*from_operators.borrow()).0.borrow()) == 7));
+    assert!(((*(*from_operators.borrow()).1.borrow()) == 7_i64));
+    let from_moved_pair: Value<(Value<i64>, Value<f64>)> = Rc::new(RefCell::new({
+        let __a0 = (Rc::new(RefCell::new(3)), Rc::new(RefCell::new(4)));
+        (
+            Rc::new(RefCell::new(((__a0.0.as_pointer().read()) as i64))),
+            Rc::new(RefCell::new(((__a0.1.as_pointer().read()) as f64))),
+        )
+    }));
+    assert!(((*(*from_moved_pair.borrow()).0.borrow()) == 3_i64));
+    assert!(((*(*from_moved_pair.borrow()).1.borrow()) == 4_f64));
+    let ints: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(5)),
+        Rc::new(RefCell::new(6)),
+    )));
+    let from_copied_pair: Value<(Value<Celsius>, Value<i64>)> = Rc::new(RefCell::new({
+        let __a0 = (*ints.borrow()).clone();
+        (
+            Rc::new(RefCell::new(<Celsius as CppFrom<i32>>::cpp_from(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(((__a0.1.as_pointer().read()) as i64))),
+        )
+    }));
+    assert!(({ (*(*from_copied_pair.borrow()).0.borrow()).degrees } == 5));
+    assert!(((*(*from_copied_pair.borrow()).1.borrow()) == 6_i64));
+    let meters: Value<(Value<Meters>, Value<Meters>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(Meters { value: 8 })),
+        Rc::new(RefCell::new(Meters { value: 9 })),
+    )));
+    let from_operator_pair: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new({
+        let __a0 = (*meters.borrow()).clone();
+        (
+            Rc::new(RefCell::new(<i32 as CppFrom<Meters>>::cpp_from(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(<i32 as CppFrom<Meters>>::cpp_from(
+                __a0.1.as_pointer(),
+            ))),
+        )
+    }));
+    assert!(((*(*from_operator_pair.borrow()).0.borrow()) == 8));
+    assert!(((*(*from_operator_pair.borrow()).1.borrow()) == 9));
+    let celsius: Value<(Value<Celsius>, Value<Celsius>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(Celsius::new({ 10 }))),
+        Rc::new(RefCell::new(Celsius::new({ 11 }))),
+    )));
+    let from_record_pair: Value<(Value<Label>, Value<Owner>)> = Rc::new(RefCell::new({
+        let __a0 = (*celsius.borrow()).clone();
+        (
+            Rc::new(RefCell::new(<Label as CppFrom<Celsius>>::cpp_from(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(<Owner as CppFrom<Celsius>>::cpp_from(
+                __a0.1.as_pointer(),
+            ))),
+        )
+    }));
+    assert!(({ (*(*from_record_pair.borrow()).0.borrow()).id } == 10));
+    assert!(({ (*(*from_record_pair.borrow()).1.borrow()).copied } == 11));
+    assert!(({ (*(*from_record_pair.borrow()).1.borrow()).taken } == 0));
+    let from_moved_record_pair: Value<(Value<Label>, Value<Owner>)> = Rc::new(RefCell::new({
+        let __a0 = (
+            Rc::new(RefCell::new(Celsius::new({ 12 }))),
+            Rc::new(RefCell::new(Celsius::new({ 13 }))),
+        );
+        (
+            Rc::new(RefCell::new(<Label as CppFrom<Celsius>>::cpp_from_move(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(<Owner as CppFrom<Celsius>>::cpp_from_move(
+                __a0.1.as_pointer(),
+            ))),
+        )
+    }));
+    assert!(({ (*(*from_moved_record_pair.borrow()).0.borrow()).id } == 12));
+    assert!(({ (*(*from_moved_record_pair.borrow()).1.borrow()).taken } == 13));
+    assert!(({ (*(*from_moved_record_pair.borrow()).1.borrow()).copied } == 0));
+    let from_by_value_pair: Value<(Value<Holder>, Value<Holder>)> = Rc::new(RefCell::new({
+        let __a0 = (*celsius.borrow()).clone();
+        (
+            Rc::new(RefCell::new(<Holder as CppFrom<Celsius>>::cpp_from(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(<Holder as CppFrom<Celsius>>::cpp_from(
+                __a0.1.as_pointer(),
+            ))),
+        )
+    }));
+    assert!(({ (*(*from_by_value_pair.borrow()).0.borrow()).value } == 10));
+    assert!(({ (*(*from_by_value_pair.borrow()).1.borrow()).value } == 11));
+    let from_moved_by_value_pair: Value<(Value<Holder>, Value<Holder>)> = Rc::new(RefCell::new({
+        let __a0 = (
+            Rc::new(RefCell::new(Celsius::new({ 14 }))),
+            Rc::new(RefCell::new(Celsius::new({ 15 }))),
+        );
+        (
+            Rc::new(RefCell::new(<Holder as CppFrom<Celsius>>::cpp_from_move(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(<Holder as CppFrom<Celsius>>::cpp_from_move(
+                __a0.1.as_pointer(),
+            ))),
+        )
+    }));
+    assert!(({ (*(*from_moved_by_value_pair.borrow()).0.borrow()).value } == 14));
+    assert!(({ (*(*from_moved_by_value_pair.borrow()).1.borrow()).value } == 15));
+    let mut defaulted: Fallback = Fallback::new(None);
+    assert!((defaulted.value == -1_i32));
+    let from_defaulted_ctor: Value<(Value<Fallback>, Value<i64>)> = Rc::new(RefCell::new({
+        let __a0 = (*ints.borrow()).clone();
+        (
+            Rc::new(RefCell::new(<Fallback as CppFrom<i32>>::cpp_from(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(((__a0.1.as_pointer().read()) as i64))),
+        )
+    }));
+    assert!(({ (*(*from_defaulted_ctor.borrow()).0.borrow()).value } == 5));
+    assert!(((*(*from_defaulted_ctor.borrow()).1.borrow()) == 6_i64));
+    let counter: Value<Counter> = Rc::new(RefCell::new(Counter { hits: 3 }));
+    let forwarded_mutable_ref: Value<(Value<Observer>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(Observer::new({ counter.as_pointer() }))),
+        Rc::new(RefCell::new(0)),
+    )));
+    assert!(({ (*(*forwarded_mutable_ref.borrow()).0.borrow()).seen } == 3));
+    assert!(({ (*counter.borrow()).hits } == 4));
+    let from_template_ctor: Value<(Value<Tag>, Value<Tag>)> = Rc::new(RefCell::new({
+        let __a0 = (*celsius.borrow()).clone();
+        (
+            Rc::new(RefCell::new(<Tag as CppFrom<Celsius>>::cpp_from(
+                __a0.0.as_pointer(),
+            ))),
+            Rc::new(RefCell::new(<Tag as CppFrom<Celsius>>::cpp_from(
+                __a0.1.as_pointer(),
+            ))),
+        )
+    }));
+    assert!(({ (*(*from_template_ctor.borrow()).0.borrow()).code } == 110));
+    assert!(({ (*(*from_template_ctor.borrow()).1.borrow()).code } == 111));
+    let lvalue_source: Value<Celsius> = Rc::new(RefCell::new(Celsius::new({ 16 })));
+    let moved_source: Value<Celsius> = Rc::new(RefCell::new(Celsius::new({ 17 })));
+    let forwarded_records: Value<(Value<Label>, Value<Owner>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(Label::new({ lvalue_source.as_pointer() }))),
+        Rc::new(RefCell::new(Owner::new_2({ moved_source.as_pointer() }))),
+    )));
+    assert!(({ (*(*forwarded_records.borrow()).0.borrow()).id } == 16));
+    assert!(({ (*(*forwarded_records.borrow()).1.borrow()).taken } == 17));
+    assert!(({ (*(*forwarded_records.borrow()).1.borrow()).copied } == 0));
+    let from_string_literals: Value<(Value<Name>, Value<Name>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(Name::new({
+            Ptr::<i8>::from_string_literal(b"ab")
+        }))),
+        Rc::new(RefCell::new(Name::new({
+            Ptr::<i8>::from_string_literal(b"cde")
+        }))),
+    )));
+    assert!(({ (*(*from_string_literals.borrow()).0.borrow()).len } == 2));
+    assert!(({ (*(*from_string_literals.borrow()).1.borrow()).len } == 3));
+    return 0;
+}
+pub trait MetersImpl {
+    fn to_i32(&self) -> i32;
+}
+impl MetersImpl for Ptr<Meters> {
+    fn to_i32(&self) -> i32 {
+        return (*self).with(|__s| __s.value);
+    }
+}
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pair_get.rs b/tests/unit/out/refcount/pair_get.rs
index dc4d45cfda..42bb3bac90 100644
--- a/tests/unit/out/refcount/pair_get.rs
+++ b/tests/unit/out/refcount/pair_get.rs
@@ -18,8 +18,8 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let p: Value<(Value<f64>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(1.5_f64.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(1.5_f64)),
+        Rc::new(RefCell::new(2)),
     )));
     assert!((((*p.borrow()).0.as_pointer().read()) == 1.5_f64));
     assert!((((*p.borrow()).1.as_pointer().read()) == 2));
diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs
index 2b598b1190..c00b10ec95 100644
--- a/tests/unit/out/refcount/push_emplace_back.rs
+++ b/tests/unit/out/refcount/push_emplace_back.rs
@@ -59,7 +59,7 @@ pub fn push_local_from_field_1(mut jpg: Ptr<JPEGData>, mut cond: bool) {
             let mut __v = Vec::new();
             let mut __it = (head.as_pointer() as Ptr<u8>);
             while __it != (head.as_pointer() as Ptr<u8>).offset((3) as isize) {
-                __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
+                __v.push((__it.iter_deref().read()));
                 __it.iter_inc();
             }
             __v
@@ -90,7 +90,7 @@ pub fn emplace_local_from_field_4(mut jpg: Ptr<JPEGData>, mut cond: bool) {
             let mut __v = Vec::new();
             let mut __it = (head.as_pointer() as Ptr<u8>);
             while __it != (head.as_pointer() as Ptr<u8>).offset((3) as isize) {
-                __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
+                __v.push((__it.iter_deref().read()));
                 __it.iter_inc();
             }
             __v
@@ -111,7 +111,8 @@ pub fn self_ref_push_6(mut comps: Ptr<Vec<Chunk>>) {
         comps.with_mut(|__v: &mut Vec<Chunk>| __v.push(a0_clone))
     };
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom)]
+#[cpp_from(i32, new_1, value)]
 #[byte_size(8)]
 pub struct Pair {
     #[offset(0)]
@@ -120,13 +121,13 @@ pub struct Pair {
     pub second: i32,
 }
 impl Pair {
-    pub fn new_1() -> Self {
+    pub fn new_2() -> Self {
         Self {
             first: -1_i32,
             second: -1_i32,
         }
     }
-    pub fn new_2(mut a: i32) -> Self {
+    pub fn new_1(mut a: i32) -> Self {
         Self {
             first: a,
             second: 0,
@@ -141,16 +142,16 @@ impl Pair {
 }
 impl Default for Pair {
     fn default() -> Self {
-        { Pair::new_1() }
+        { Pair::new_2() }
     }
 }
 pub fn emplace_ctor_args_7(mut pairs: Ptr<Vec<Pair>>) {
     {
-        let __init = Pair::new_1();
+        let __init = Pair::new_2();
         pairs.with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
     {
-        let __init = Pair::new_2({ 3 });
+        let __init = Pair::new_1({ 3 });
         pairs.with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
     {
@@ -164,7 +165,7 @@ pub fn emplace_deque_8(mut queue: Ptr<Vec<Pair>>) {
         queue.with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
     {
-        let __init = Pair::new_1();
+        let __init = Pair::new_2();
         queue.with_mut(|__v: &mut Vec<Pair>| __v.push(__init))
     };
 }
diff --git a/tests/unit/out/refcount/redundant_copy_in_conversion.rs b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
index 872e2040ad..b6a5a727a0 100644
--- a/tests/unit/out/refcount/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
@@ -59,6 +59,14 @@ fn main_0() -> i32 {
         1
     };
     assert!((r == 2));
+    let values: Value<Vec<u32>> = Rc::new(RefCell::new(Vec::from([7_u32, 8_u32, 9_u32])));
+    let middle: Value<RandomAccessIterator<u32>> =
+        Rc::new(RefCell::new(values.decay().begin().iter_add(1_isize)));
+    let const_middle: Value<RandomAccessIterator<u32>> = Rc::new(RefCell::new(
+        <RandomAccessIterator<u32>>::from((*middle.borrow()).clone()),
+    ));
+    assert!((((*const_middle.borrow()).iter_deref().read()) == 8_u32));
+    assert!((*const_middle.borrow()) == (*middle.borrow()));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/rule_of_five.rs b/tests/unit/out/refcount/rule_of_five.rs
index ac6ea1da11..d7229e1d69 100644
--- a/tests/unit/out/refcount/rule_of_five.rs
+++ b/tests/unit/out/refcount/rule_of_five.rs
@@ -15,7 +15,10 @@ thread_local!(
 thread_local!(
     pub static moves_2: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, MoveAssign, Destructor)]
+#[derive(
+    Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, CopyAssign, MoveAssign, Destructor,
+)]
+#[cpp_from(i32, new, value)]
 #[byte_size(20)]
 pub struct Buffer {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/rule_of_three.rs b/tests/unit/out/refcount/rule_of_three.rs
index 3909b13908..7dbddad36f 100644
--- a/tests/unit/out/refcount/rule_of_three.rs
+++ b/tests/unit/out/refcount/rule_of_three.rs
@@ -12,7 +12,8 @@ thread_local!(
 thread_local!(
     pub static copies_1: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Destructor)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Destructor)]
+#[cpp_from(i32, new, value)]
 #[byte_size(20)]
 pub struct Buffer {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/rvalue_rule_arg_move.rs b/tests/unit/out/refcount/rvalue_rule_arg_move.rs
index 43c0181599..684a72b26e 100644
--- a/tests/unit/out/refcount/rvalue_rule_arg_move.rs
+++ b/tests/unit/out/refcount/rvalue_rule_arg_move.rs
@@ -12,7 +12,8 @@ thread_local!(
 thread_local!(
     pub static moves_1: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, CopyAssign, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Elem {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/size_t_ssize_t.rs b/tests/unit/out/refcount/size_t_ssize_t.rs
index fa468641db..6d8ce914ca 100644
--- a/tests/unit/out/refcount/size_t_ssize_t.rs
+++ b/tests/unit/out/refcount/size_t_ssize_t.rs
@@ -194,12 +194,8 @@ fn main_0() -> i32 {
     assert!((mins[(1) as usize] == 1_usize));
     assert!((mins[(2) as usize] == 2_usize));
     let pr: Value<(Value<u64>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(
-            ((*sz.borrow()) as u64)
-                .try_into()
-                .expect("failed conversion"),
-        )),
-        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(((*sz.borrow()) as u64))),
+        Rc::new(RefCell::new(1)),
     )));
     assert!(((*(*pr.borrow()).0.borrow()) == 21_u64));
     let sizes: Value<Box<[usize]>> =
diff --git a/tests/unit/out/refcount/size_t_template_param.rs b/tests/unit/out/refcount/size_t_template_param.rs
index 0af31c7710..e76293ec31 100644
--- a/tests/unit/out/refcount/size_t_template_param.rs
+++ b/tests/unit/out/refcount/size_t_template_param.rs
@@ -10,7 +10,8 @@ pub fn array_ref_0(a: Ptr<u64>) -> u64 {
     elem!((a), 0).write({ (elem!((a), 0).read()).wrapping_add(1_u64) });
     return (elem!((a), (3_u64 as u64).wrapping_sub(1_u64)).read());
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(Ptr< u64  >  , new, value)]
 #[byte_size(8)]
 pub struct PtrCtor_unsigned_long_ {
     #[offset(0)]
@@ -23,7 +24,8 @@ impl PtrCtor_unsigned_long_ {
         }
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(u64, new, ptr)]
 #[byte_size(8)]
 pub struct RefCtor_unsigned_long_ {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/sort_no_copy.rs b/tests/unit/out/refcount/sort_no_copy.rs
index 6f97b7e0a5..238f272826 100644
--- a/tests/unit/out/refcount/sort_no_copy.rs
+++ b/tests/unit/out/refcount/sort_no_copy.rs
@@ -9,17 +9,18 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static copies_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, MoveAssign)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, CopyAssign, MoveAssign)]
+#[cpp_from(i32, new_1, value)]
 #[byte_size(4)]
 pub struct Tracked {
     #[offset(0)]
     pub v: i32,
 }
 impl Tracked {
-    pub fn new_1() -> Self {
+    pub fn new_2() -> Self {
         Self { v: 0 }
     }
-    pub fn new_2(mut v: i32) -> Self {
+    pub fn new_1(mut v: i32) -> Self {
         Self { v: v }
     }
     pub fn copy_from(o: Ptr<Tracked>) -> Self {
@@ -54,7 +55,7 @@ impl Clone for Tracked {
 }
 impl Default for Tracked {
     fn default() -> Self {
-        { Tracked::new_1() }
+        { Tracked::new_2() }
     }
 }
 pub fn operator_lt_1(a: Ptr<Tracked>, b: Ptr<Tracked>) -> bool {
@@ -99,11 +100,11 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let arr: Value<Box<[Tracked]>> = Rc::new(RefCell::new(Box::new([
-        Tracked::new_2({ 3 }),
-        Tracked::new_2({ 1 }),
-        Tracked::new_2({ 4 }),
-        Tracked::new_2({ 1 }),
-        Tracked::new_2({ 5 }),
+        Tracked::new_1({ 3 }),
+        Tracked::new_1({ 1 }),
+        Tracked::new_1({ 4 }),
+        Tracked::new_1({ 1 }),
+        Tracked::new_1({ 5 }),
     ])));
     {
         let __first = (arr.as_pointer() as Ptr<Tracked>);
@@ -128,19 +129,19 @@ fn main_0() -> i32 {
         (*vec_.borrow_mut()).reserve_exact(4_usize as usize - len_0 as usize);
     };
     {
-        let __init = Tracked::new_2({ 2 });
+        let __init = Tracked::new_1({ 2 });
         (*vec_.borrow_mut()).push(__init)
     };
     {
-        let __init = Tracked::new_2({ 7 });
+        let __init = Tracked::new_1({ 7 });
         (*vec_.borrow_mut()).push(__init)
     };
     {
-        let __init = Tracked::new_2({ 1 });
+        let __init = Tracked::new_1({ 1 });
         (*vec_.borrow_mut()).push(__init)
     };
     {
-        let __init = Tracked::new_2({ 8 });
+        let __init = Tracked::new_1({ 8 });
         (*vec_.borrow_mut()).push(__init)
     };
     {
@@ -229,15 +230,15 @@ fn main_0() -> i32 {
         (0..3).map(|_| <Bag>::default()).collect::<Box<[Bag]>>(),
     ));
     {
-        let __init = Tracked::new_2({ 1 });
+        let __init = Tracked::new_1({ 1 });
         (*bags.borrow_mut())[(0) as usize].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 2 });
+        let __init = Tracked::new_1({ 2 });
         (*bags.borrow_mut())[(0) as usize].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 3 });
+        let __init = Tracked::new_1({ 3 });
         (*bags.borrow_mut())[(2) as usize].items.push(__init)
     };
     {
@@ -261,15 +262,15 @@ fn main_0() -> i32 {
             .collect::<Vec<_>>(),
     ));
     {
-        let __init = Tracked::new_2({ 4 });
+        let __init = Tracked::new_1({ 4 });
         (*bag_vec.borrow_mut())[1_usize].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 5 });
+        let __init = Tracked::new_1({ 5 });
         (*bag_vec.borrow_mut())[1_usize].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 6 });
+        let __init = Tracked::new_1({ 6 });
         (*bag_vec.borrow_mut())[2_usize].items.push(__init)
     };
     {
diff --git a/tests/unit/out/refcount/stdcopy.rs b/tests/unit/out/refcount/stdcopy.rs
index 9b79dc9e66..739ee37bba 100644
--- a/tests/unit/out/refcount/stdcopy.rs
+++ b/tests/unit/out/refcount/stdcopy.rs
@@ -6,6 +6,18 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
+#[byte_size(4)]
+pub struct Degrees {
+    #[offset(0)]
+    pub value: i32,
+}
+impl Degrees {
+    pub fn new(mut v: i32) -> Self {
+        Self { value: v }
+    }
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -19,12 +31,64 @@ fn main_0() -> i32 {
         let __last = (input.as_pointer() as Ptr<i32>).offset((3) as isize);
         let mut __out = (output.as_pointer() as Ptr<i32>);
         while __first != __last {
-            __out.iter_deref().write(__first.iter_deref().read().into());
+            __out.iter_deref().write((__first.iter_deref().read()));
+            __first.iter_inc();
+            __out.iter_inc();
+        }
+        __out
+    };
+    let widened: Value<Vec<i64>> = Rc::new(RefCell::new(vec![0_i64; 3_usize as usize]));
+    {
+        let mut __first = (input.as_pointer() as Ptr<i32>);
+        let __last = (input.as_pointer() as Ptr<i32>).offset((3) as isize);
+        let mut __out = widened.decay().begin();
+        while __first != __last {
+            __out
+                .iter_deref()
+                .write(((__first.iter_deref().read()) as i64));
+            __first.iter_inc();
+            __out.iter_inc();
+        }
+        __out
+    };
+    assert!(
+        ({ (*widened.borrow())[0_usize] } == 1_i64) && ({ (*widened.borrow())[2_usize] } == 3_i64)
+    );
+    let constructed: Value<Vec<Degrees>> =
+        Rc::new(RefCell::new(vec![Degrees::new({ 0 },); 3_usize as usize]));
+    {
+        let mut __first = (input.as_pointer() as Ptr<i32>);
+        let __last = (input.as_pointer() as Ptr<i32>).offset((3) as isize);
+        let mut __out = constructed.decay().begin();
+        while __first != __last {
+            __out
+                .iter_deref()
+                .write(<Degrees as CppFrom<i32>>::cpp_from(__first.iter_deref()));
+            __first.iter_inc();
+            __out.iter_inc();
+        }
+        __out
+    };
+    assert!(
+        ({ (*constructed.borrow())[0_usize].value } == 1)
+            && ({ (*constructed.borrow())[2_usize].value } == 3)
+    );
+    let wide: Value<Box<[i64]>> = Rc::new(RefCell::new(Box::new([7_i64, 8_i64])));
+    let floating: Value<Vec<f64>> = Rc::new(RefCell::new(vec![0_f64; 2_usize as usize]));
+    {
+        let mut __first = (wide.as_pointer() as Ptr<i64>);
+        let __last = (wide.as_pointer() as Ptr<i64>).offset((2) as isize);
+        let mut __out = floating.decay().begin();
+        while __first != __last {
+            __out
+                .iter_deref()
+                .write(((__first.iter_deref().read()) as f64));
             __first.iter_inc();
             __out.iter_inc();
         }
         __out
     };
+    assert!(({ (*floating.borrow())[1_usize] } == 8_f64));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/struct_ctor.rs b/tests/unit/out/refcount/struct_ctor.rs
index 2455fc2fe2..a7527c6673 100644
--- a/tests/unit/out/refcount/struct_ctor.rs
+++ b/tests/unit/out/refcount/struct_ctor.rs
@@ -26,7 +26,8 @@ impl StructWithCtor {
 pub fn foo_0(x: Ptr<i32>) -> Ptr<i32> {
     return (x).clone();
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Value_ {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/structured_binding_element_ctor.rs b/tests/unit/out/refcount/structured_binding_element_ctor.rs
index 85fef2b42b..9dc730b538 100644
--- a/tests/unit/out/refcount/structured_binding_element_ctor.rs
+++ b/tests/unit/out/refcount/structured_binding_element_ctor.rs
@@ -12,7 +12,8 @@ thread_local!(
 thread_local!(
     pub static moves_1: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Elem {
     #[offset(0)]
@@ -101,12 +102,8 @@ fn main_0() -> i32 {
     assert!((moves_1.with(|rc| *rc.borrow()) == before_moves));
     assert!(({ (*__decomp_6.borrow()).a.v } == 1));
     let p: Value<(Value<Elem>, Value<Elem>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(
-            Elem::new({ 7 }).try_into().expect("failed conversion"),
-        )),
-        Rc::new(RefCell::new(
-            Elem::new({ 8 }).try_into().expect("failed conversion"),
-        )),
+        Rc::new(RefCell::new(Elem::new({ 7 }))),
+        Rc::new(RefCell::new(Elem::new({ 8 }))),
     )));
     before_copies = copies_0.with(|rc| *rc.borrow());
     let __decomp_7: Value<(Value<Elem>, Value<Elem>)> = Rc::new(RefCell::new((
diff --git a/tests/unit/out/refcount/structured_binding_pair.rs b/tests/unit/out/refcount/structured_binding_pair.rs
index c00bd9f9a9..ceec5d1595 100644
--- a/tests/unit/out/refcount/structured_binding_pair.rs
+++ b/tests/unit/out/refcount/structured_binding_pair.rs
@@ -7,10 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn make_std_pair_0(mut x: i32) -> (Value<i32>, Value<bool>) {
-    return (
-        Rc::new(RefCell::new(x.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new((x > 0).try_into().expect("failed conversion"))),
-    );
+    return (Rc::new(RefCell::new(x)), Rc::new(RefCell::new((x > 0))));
 }
 pub fn main() {
     __cpp2rust_init_globals();
@@ -24,8 +21,8 @@ fn main_0() -> i32 {
     assert!(((value.read()) == 5));
     assert!(((positive.read()) as bool));
     let p: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
-        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
-        Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+        Rc::new(RefCell::new(1)),
+        Rc::new(RefCell::new(2)),
     )));
     let __decomp_2: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new((*p.borrow()).0.borrow().clone())),
diff --git a/tests/unit/out/refcount/swap_map_no_copy.rs b/tests/unit/out/refcount/swap_map_no_copy.rs
index fb0ebe3fde..e6963364dc 100644
--- a/tests/unit/out/refcount/swap_map_no_copy.rs
+++ b/tests/unit/out/refcount/swap_map_no_copy.rs
@@ -9,17 +9,18 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static copies_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, MoveAssign)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CppFrom, CopyAssign, MoveAssign)]
+#[cpp_from(i32, new_1, value)]
 #[byte_size(4)]
 pub struct Tracked {
     #[offset(0)]
     pub v: i32,
 }
 impl Tracked {
-    pub fn new_1() -> Self {
+    pub fn new_2() -> Self {
         Self { v: 0 }
     }
-    pub fn new_2(mut v: i32) -> Self {
+    pub fn new_1(mut v: i32) -> Self {
         Self { v: v }
     }
     pub fn copy_from(o: Ptr<Tracked>) -> Self {
@@ -43,7 +44,7 @@ impl Clone for Tracked {
 }
 impl Default for Tracked {
     fn default() -> Self {
-        { Tracked::new_1() }
+        { Tracked::new_2() }
     }
 }
 #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, MoveAssign, Default)]
@@ -106,7 +107,8 @@ thread_local!(
 thread_local!(
     pub static copy_only_dtors_2: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Destructor, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Destructor, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct CopyOnly {
     #[offset(0)]
@@ -150,8 +152,18 @@ thread_local!(
     pub static moved_dtors_5: Value<i32> = Rc::new(RefCell::new(0));
 );
 #[derive(
-    Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, CopyAssign, MoveAssign, Destructor, Default,
+    Record,
+    ByteRepr,
+    VaArg,
+    FnPtrArg,
+    MoveCtor,
+    CppFrom,
+    CopyAssign,
+    MoveAssign,
+    Destructor,
+    Default,
 )]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct Moved {
     #[offset(0)]
@@ -239,14 +251,14 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let a: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 1 })));
-    let b: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 2 })));
+    let a: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 1 })));
+    let b: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 2 })));
     cpp_swap!(a.as_pointer(), b.as_pointer());
     assert!(({ (*a.borrow()).v } == 2) && ({ (*b.borrow()).v } == 1));
     assert!((copies_0.with(|rc| *rc.borrow()) == 0));
     let m1: Value<Map<i32, (Value<i32>, Value<Tracked>)>> = Rc::new(RefCell::new(Map::new()));
     ({
-        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 10 })));
+        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 10 })));
         TrackedImpl::move_assign(
             &Map::subscript_move(
                 m1.as_pointer(),
@@ -257,7 +269,7 @@ fn main_0() -> i32 {
         )
     });
     ({
-        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 20 })));
+        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 20 })));
         TrackedImpl::move_assign(
             &Map::subscript_move(
                 m1.as_pointer(),
@@ -269,7 +281,7 @@ fn main_0() -> i32 {
     });
     let m2: Value<Map<i32, (Value<i32>, Value<Tracked>)>> = Rc::new(RefCell::new(Map::new()));
     ({
-        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 30 })));
+        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 30 })));
         TrackedImpl::move_assign(
             &Map::subscript_move(
                 m2.as_pointer(),
@@ -339,9 +351,9 @@ fn main_0() -> i32 {
     );
     assert!((copies_0.with(|rc| *rc.borrow()) == 0));
     let arr: Value<Box<[Tracked]>> = Rc::new(RefCell::new(Box::new([
-        Tracked::new_2({ 1 }),
-        Tracked::new_2({ 2 }),
-        Tracked::new_2({ 3 }),
+        Tracked::new_1({ 1 }),
+        Tracked::new_1({ 2 }),
+        Tracked::new_1({ 3 }),
     ])));
     cpp_swap!(
         (arr.as_pointer() as Ptr<Tracked>).offset(0),
@@ -358,11 +370,11 @@ fn main_0() -> i32 {
     assert!((copies_0.with(|rc| *rc.borrow()) == 0));
     let vec_: Value<Vec<Tracked>> = Rc::new(RefCell::new(Vec::new()));
     {
-        let __init = Tracked::new_2({ 4 });
+        let __init = Tracked::new_1({ 4 });
         (*vec_.borrow_mut()).push(__init)
     };
     {
-        let __init = Tracked::new_2({ 5 });
+        let __init = Tracked::new_1({ 5 });
         (*vec_.borrow_mut()).push(__init)
     };
     cpp_swap!(vec_.decay().offset(0_usize), vec_.decay().offset(1_usize));
@@ -370,17 +382,17 @@ fn main_0() -> i32 {
     assert!((copies_0.with(|rc| *rc.borrow()) == 0));
     let pairs: Value<Box<[Pair]>> = Rc::new(RefCell::new(Box::new([
         Pair {
-            x: Tracked::new_2({ 6 }),
-            y: Tracked::new_2({ 7 }),
+            x: Tracked::new_1({ 6 }),
+            y: Tracked::new_1({ 7 }),
         },
         Pair {
-            x: Tracked::new_2({ 8 }),
-            y: Tracked::new_2({ 9 }),
+            x: Tracked::new_1({ 8 }),
+            y: Tracked::new_1({ 9 }),
         },
     ])));
     let p: Value<Pair> = Rc::new(RefCell::new(Pair {
-        x: Tracked::new_2({ 10 }),
-        y: Tracked::new_2({ 11 }),
+        x: Tracked::new_1({ 10 }),
+        y: Tracked::new_1({ 11 }),
     }));
     cpp_swap!(
         field_ptr!((pairs.as_pointer() as Ptr<Pair>).offset(0), x),
@@ -433,15 +445,15 @@ fn main_0() -> i32 {
             .collect::<Vec<_>>(),
     ));
     {
-        let __init = Tracked::new_2({ 1 });
+        let __init = Tracked::new_1({ 1 });
         elem!(grid.decay(), 0_usize).with_mut(|__v: &mut Vec<Tracked>| __v.push(__init))
     };
     {
-        let __init = Tracked::new_2({ 2 });
+        let __init = Tracked::new_1({ 2 });
         elem!(grid.decay(), 0_usize).with_mut(|__v: &mut Vec<Tracked>| __v.push(__init))
     };
     {
-        let __init = Tracked::new_2({ 3 });
+        let __init = Tracked::new_1({ 3 });
         elem!(grid.decay(), 1_usize).with_mut(|__v: &mut Vec<Tracked>| __v.push(__init))
     };
     cpp_swap!(
@@ -464,7 +476,7 @@ fn main_0() -> i32 {
             .collect::<Box<[Map<i32, (Value<i32>, Value<Tracked>)>]>>(),
     ));
     ({
-        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 1 })));
+        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 1 })));
         TrackedImpl::move_assign(
             &Map::subscript_move(
                 (maps.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<Tracked>)>>).offset(0),
@@ -475,7 +487,7 @@ fn main_0() -> i32 {
         )
     });
     ({
-        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_2({ 2 })));
+        let _o: Value<Tracked> = Rc::new(RefCell::new(Tracked::new_1({ 2 })));
         TrackedImpl::move_assign(
             &Map::subscript_move(
                 (maps.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<Tracked>)>>).offset(1),
diff --git a/tests/unit/out/refcount/template_default_arg.rs b/tests/unit/out/refcount/template_default_arg.rs
index b0f2d39a36..239584b9e5 100644
--- a/tests/unit/out/refcount/template_default_arg.rs
+++ b/tests/unit/out/refcount/template_default_arg.rs
@@ -6,23 +6,24 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom)]
+#[cpp_from(i32, new_1, value)]
 #[byte_size(4)]
 pub struct A {
     #[offset(0)]
     pub v: i32,
 }
 impl A {
-    pub fn new_1() -> Self {
+    pub fn new_2() -> Self {
         Self { v: 1 }
     }
-    pub fn new_2(mut v: i32) -> Self {
+    pub fn new_1(mut v: i32) -> Self {
         Self { v: v }
     }
 }
 impl Default for A {
     fn default() -> Self {
-        { A::new_1() }
+        { A::new_2() }
     }
 }
 #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
@@ -41,7 +42,8 @@ impl Default for B {
         { B::new() }
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct NoDefault {
     #[offset(0)]
@@ -53,7 +55,7 @@ impl NoDefault {
     }
 }
 pub fn used_0(x: Option<A>) -> i32 {
-    let mut x: A = x.unwrap_or_else(|| A::new_1());
+    let mut x: A = x.unwrap_or_else(|| A::new_2());
     return x.v;
 }
 pub fn used_1(x: Option<B>) -> i32 {
@@ -67,7 +69,8 @@ pub fn scaled_2(mut x: A, n: Option<i32>) -> i32 {
 pub fn always_given_3(mut x: NoDefault) -> i32 {
     return x.v;
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct S_NoDefault_ {
     #[offset(0)]
@@ -84,10 +87,10 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     assert!((({ used_0(None,) }) == 1));
-    assert!((({ used_0(Some(A::new_2({ 5 },)),) }) == 5));
+    assert!((({ used_0(Some(A::new_1({ 5 },)),) }) == 5));
     assert!((({ used_1(None,) }) == 2));
-    assert!((({ scaled_2(A::new_2({ 3 },), None,) }) == (3 * (4usize as i32))));
-    assert!((({ scaled_2(A::new_2({ 3 },), Some(2),) }) == 6));
+    assert!((({ scaled_2(A::new_1({ 3 },), None,) }) == (3 * (4usize as i32))));
+    assert!((({ scaled_2(A::new_1({ 3 },), Some(2),) }) == 6));
     assert!((({ always_given_3(NoDefault::new({ 3 },),) }) == 3));
     let s: Value<S_NoDefault_> = Rc::new(RefCell::new(S_NoDefault_::new({ 1 })));
     assert!((({ S_NoDefault_Impl::get(&s.as_pointer(), NoDefault::new({ 4 },),) }) == 5));
diff --git a/tests/unit/out/refcount/template_rule_unqualified_call.rs b/tests/unit/out/refcount/template_rule_unqualified_call.rs
index 4882145e2b..ca66f62bd6 100644
--- a/tests/unit/out/refcount/template_rule_unqualified_call.rs
+++ b/tests/unit/out/refcount/template_rule_unqualified_call.rs
@@ -12,33 +12,24 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     assert!(
-        ({
-            let __c: i32 = (('a' as i8) as i32).into();
-            if (0..=255).contains(&__c) {
-                (__c as u8).to_ascii_uppercase() as i32
-            } else {
-                __c
-            }
+        (if (0..=255).contains(&(('a' as i8) as i32)) {
+            ((('a' as i8) as i32) as u8).to_ascii_uppercase() as i32
+        } else {
+            (('a' as i8) as i32)
         } == (('A' as i8) as i32))
     );
     assert!(
-        ({
-            let __c: i32 = (('Z' as i8) as i32).into();
-            if (0..=255).contains(&__c) {
-                (__c as u8).to_ascii_uppercase() as i32
-            } else {
-                __c
-            }
+        (if (0..=255).contains(&(('Z' as i8) as i32)) {
+            ((('Z' as i8) as i32) as u8).to_ascii_uppercase() as i32
+        } else {
+            (('Z' as i8) as i32)
         } == (('Z' as i8) as i32))
     );
     assert!(
-        ({
-            let __c: i32 = (('5' as i8) as i32).into();
-            if (0..=255).contains(&__c) {
-                (__c as u8).to_ascii_uppercase() as i32
-            } else {
-                __c
-            }
+        (if (0..=255).contains(&(('5' as i8) as i32)) {
+            ((('5' as i8) as i32) as u8).to_ascii_uppercase() as i32
+        } else {
+            (('5' as i8) as i32)
         } == (('5' as i8) as i32))
     );
     return 0;
diff --git a/tests/unit/out/refcount/this.rs b/tests/unit/out/refcount/this.rs
index 9e7d4c7608..1b5c5ae758 100644
--- a/tests/unit/out/refcount/this.rs
+++ b/tests/unit/out/refcount/this.rs
@@ -6,7 +6,8 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new_1, value)]
 #[byte_size(16)]
 pub struct S {
     #[offset(0)]
@@ -50,7 +51,8 @@ impl S {
 pub fn bump_0(mut p: Ptr<S>) {
     field!(p, a_).with_mut(|__v| __v.postfix_inc());
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
 #[byte_size(4)]
 pub struct D {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/va_list_field.rs b/tests/unit/out/refcount/va_list_field.rs
index cd06e88e19..c4d5f74f75 100644
--- a/tests/unit/out/refcount/va_list_field.rs
+++ b/tests/unit/out/refcount/va_list_field.rs
@@ -21,7 +21,8 @@ pub fn sum_0(n: i32, __args: Box<[VaArg]>) -> i32 {
     }
     return total;
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Destructor, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Destructor, Default)]
+#[cpp_from(Ptr<VaArg> , new, mut_ptr)]
 #[byte_size(16)]
 pub struct Guard_1 {
     #[offset(0)]
diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs
index a0e54089bb..8d4aae2b19 100644
--- a/tests/unit/out/refcount/vector_iter_range_ctor.rs
+++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs
@@ -6,6 +6,25 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_from(i32, new, value)]
+#[byte_size(4)]
+pub struct Degrees {
+    #[offset(0)]
+    pub value: i32,
+}
+impl Degrees {
+    pub fn new(mut v: i32) -> Self {
+        Self { value: v }
+    }
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CppFrom, Default)]
+#[cpp_into(i64, to_i64)]
+#[byte_size(4)]
+pub struct Reading {
+    #[offset(0)]
+    pub raw_: i32,
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -16,7 +35,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push((__it.iter_deref().read()));
             __it.iter_inc();
         }
         __v
@@ -27,7 +46,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(<u64>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(((__it.iter_deref().read()) as u64));
             __it.iter_inc();
         }
         __v
@@ -38,7 +57,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(<i32>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(((__it.iter_deref().read()) as i32));
             __it.iter_inc();
         }
         __v
@@ -50,7 +69,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src1.as_pointer() as Ptr<u32>);
         while __it != (src1.as_pointer() as Ptr<u32>).to_end() {
-            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push((__it.iter_deref().read()));
             __it.iter_inc();
         }
         __v
@@ -65,7 +84,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (start).clone();
         while __it != start.offset((len) as isize) {
-            __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push((__it.iter_deref().read()));
             __it.iter_inc();
         }
         __v
@@ -100,11 +119,10 @@ fn main_0() -> i32 {
             != m.as_pointer()
                 .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.end())
         {
-            __v.push(
-                <(Value<i32>, Value<i32>)>::try_from(__it.iter_deref().read())
-                    .ok()
-                    .unwrap(),
-            );
+            __v.push(<(Value<i32>, Value<i32>) as CppFrom<(
+                Value<i32>,
+                Value<i32>,
+            )>>::cpp_from(__it.iter_deref()));
             __it.iter_inc();
         }
         __v
@@ -146,6 +164,39 @@ fn main_0() -> i32 {
             && ((*(*v6.borrow())[3_usize].0.borrow()) == 3))
             && ((*(*v6.borrow())[4_usize].0.borrow()) == 2)
     );
+    let ints: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([4, 5, 6])));
+    let mut v7: Vec<Degrees> = {
+        let mut __v = Vec::new();
+        let mut __it = (ints.as_pointer() as Ptr<i32>);
+        while __it != (ints.as_pointer() as Ptr<i32>).offset((3) as isize) {
+            __v.push(<Degrees as CppFrom<i32>>::cpp_from(__it.iter_deref()));
+            __it.iter_inc();
+        }
+        __v
+    };
+    assert!((v7[1_usize].value == 5));
+    let readings: Value<Box<[Reading]>> = Rc::new(RefCell::new(Box::new([
+        Reading { raw_: 4 },
+        Reading { raw_: 5 },
+    ])));
+    let mut v8: Vec<i64> = {
+        let mut __v = Vec::new();
+        let mut __it = (readings.as_pointer() as Ptr<Reading>);
+        while __it != (readings.as_pointer() as Ptr<Reading>).offset((2) as isize) {
+            __v.push(<i64 as CppFrom<Reading>>::cpp_from(__it.iter_deref()));
+            __it.iter_inc();
+        }
+        __v
+    };
+    assert!((v8[0_usize] == 40_i64) && (v8[1_usize] == 50_i64));
     return 0;
 }
+pub trait ReadingImpl {
+    fn to_i64(&self) -> i64;
+}
+impl ReadingImpl for Ptr<Reading> {
+    fn to_i64(&self) -> i64 {
+        return (((*self).with(|__s| __s.raw_) as i64) * 10_i64);
+    }
+}
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs
index 036cdef71a..cb0712bc21 100644
--- a/tests/unit/out/refcount/vector_with_allocator.rs
+++ b/tests/unit/out/refcount/vector_with_allocator.rs
@@ -239,7 +239,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push((__it.iter_deref().read()));
             __it.iter_inc();
         }
         __v
@@ -250,7 +250,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(<u64>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(((__it.iter_deref().read()) as u64));
             __it.iter_inc();
         }
         __v
@@ -261,7 +261,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(<i32>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(((__it.iter_deref().read()) as i32));
             __it.iter_inc();
         }
         __v
@@ -273,7 +273,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src1.as_pointer() as Ptr<u32>);
         while __it != (src1.as_pointer() as Ptr<u32>).to_end() {
-            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push((__it.iter_deref().read()));
             __it.iter_inc();
         }
         __v
@@ -288,7 +288,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (start).clone();
         while __it != start.offset((len) as isize) {
-            __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push((__it.iter_deref().read()));
             __it.iter_inc();
         }
         __v
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index 0d1cc1429a..a07cc906c9 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -183,7 +183,7 @@ unsafe fn main_0() -> i32 {
         assert!(((*map2.subscript(&i)) == ((i) + (1))));
         i.prefix_inc();
     }
-    let mut pair1: (i32, i32) = (1.into(), 2.into());
+    let mut pair1: (i32, i32) = (1, 2);
     let mut pair2: (i32, i32) = pair1.clone();
     pair2.0 = ((pair2.0) * (10));
     pair2.1 = ((pair2.1) * (10));
@@ -192,11 +192,8 @@ unsafe fn main_0() -> i32 {
     assert!(((pair1.0) == (1)));
     assert!(((pair1.1) == (2)));
     let mut pair3: (Vec<i32>, i32) = (
-        (0..(0_usize) as usize)
-            .map(|_| 0_i32)
-            .collect::<Vec<_>>()
-            .into(),
-        0.into(),
+        (0..(0_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>(),
+        0,
     );
     let mut pair4: (Vec<i32>, i32) = pair3.clone();
     {
diff --git a/tests/unit/out/unsafe/constructor.rs b/tests/unit/out/unsafe/constructor.rs
index e948545064..7ec124cf60 100644
--- a/tests/unit/out/unsafe/constructor.rs
+++ b/tests/unit/out/unsafe/constructor.rs
@@ -8,7 +8,8 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut total_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, DestructorUnsafe, Default)]
+#[derive(Clone, VaArg, FnPtrArg, CppFromUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct S {
     pub v: i32,
 }
@@ -33,23 +34,24 @@ impl S {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe)]
+#[cpp_from(i32, new_1, value)]
 pub struct Point {
     pub x: i32,
     pub y: i32,
 }
 impl Point {
-    pub unsafe fn new_1(mut x: i32, mut y: i32) -> Self {
+    pub unsafe fn new_2(mut x: i32, mut y: i32) -> Self {
         let mut this = Self { x: x, y: y };
         this
     }
-    pub unsafe fn new_2(mut v: i32) -> Self {
-        let mut this = Point::new_1({ v }, { ((v) + (1)) });
+    pub unsafe fn new_1(mut v: i32) -> Self {
+        let mut this = Point::new_2({ v }, { ((v) + (1)) });
         this.y *= 10;
         this
     }
     pub unsafe fn new_3() -> Self {
-        let mut this = Point::new_2({ 4 });
+        let mut this = Point::new_1({ 4 });
         this.x += 100;
         this
     }
@@ -76,7 +78,7 @@ unsafe fn main_0() -> i32 {
     let mut p: Point = Point::new_3();
     assert!(((p.x) == (104)));
     assert!(((p.y) == (50)));
-    let mut q: Point = Point::new_2({ 7 });
+    let mut q: Point = Point::new_1({ 7 });
     assert!(((q.x) == (7)));
     assert!(((q.y) == (80)));
     return 0;
diff --git a/tests/unit/out/unsafe/conversion_operator_same_translation.rs b/tests/unit/out/unsafe/conversion_operator_same_translation.rs
index 2047aea925..a34276f7ce 100644
--- a/tests/unit/out/unsafe/conversion_operator_same_translation.rs
+++ b/tests/unit/out/unsafe/conversion_operator_same_translation.rs
@@ -7,7 +7,9 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(libc::c_char, to_libcc_char)]
+#[cpp_into(u8, to_u8)]
 pub struct S {
     pub v: i32,
 }
@@ -20,7 +22,8 @@ impl S {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(i64, to_i64_1)]
 pub struct T {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/copy_assign.rs b/tests/unit/out/unsafe/copy_assign.rs
index 146600c931..1e131429c0 100644
--- a/tests/unit/out/unsafe/copy_assign.rs
+++ b/tests/unit/out/unsafe/copy_assign.rs
@@ -108,7 +108,8 @@ impl Holder {
 }
 pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct CopyCounted {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/copy_ctor.rs b/tests/unit/out/unsafe/copy_ctor.rs
index 28350c3564..37445e854e 100644
--- a/tests/unit/out/unsafe/copy_ctor.rs
+++ b/tests/unit/out/unsafe/copy_ctor.rs
@@ -8,7 +8,8 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Counted {
     pub v: i32,
 }
@@ -70,7 +71,8 @@ impl Default for NonConst {
     }
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Ignored {
     pub v: i32,
 }
@@ -120,7 +122,8 @@ impl Holder {
     }
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Box_int_ {
     pub val: i32,
 }
@@ -157,7 +160,8 @@ impl Owner {
     }
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct OutOfLine {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/copy_move_defaulted.rs b/tests/unit/out/unsafe/copy_move_defaulted.rs
index 90b52db336..0229f91872 100644
--- a/tests/unit/out/unsafe/copy_move_defaulted.rs
+++ b/tests/unit/out/unsafe/copy_move_defaulted.rs
@@ -12,7 +12,8 @@ pub struct Inner {
     pub x: i32,
 }
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, DestructorUnsafe, Default)]
+#[derive(Clone, VaArg, FnPtrArg, CppFromUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Explicit {
     pub v: i32,
     pub inner: Inner,
@@ -37,7 +38,10 @@ pub struct Implicit {
     pub arr: [i32; 2],
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, Default)]
+#[derive(
+    Copy, Clone, VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, MoveAssignUnsafe, Default,
+)]
+#[cpp_from(i32, new, value)]
 pub struct DefaultCopyUserMove {
     pub v: i32,
 }
@@ -58,7 +62,10 @@ impl DefaultCopyUserMove {
     }
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CopyAssignUnsafe, MoveAssignUnsafe, Default)]
+#[derive(
+    VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, CopyAssignUnsafe, MoveAssignUnsafe, Default,
+)]
+#[cpp_from(i32, new, value)]
 pub struct UserCopyDefaultMove {
     pub v: i32,
 }
@@ -98,7 +105,8 @@ impl Clone for UserCopyDefaultMove {
     }
 }
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, MoveAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Buffer {
     pub data: Vec<i32>,
     pub rows: Vec<Vec<i32>>,
@@ -198,7 +206,8 @@ impl Copyable {
     }
 }
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, DestructorUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, MoveAssignUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Holder {
     pub inner: Inner,
     pub e: Explicit,
diff --git a/tests/unit/out/unsafe/copy_move_deleted.rs b/tests/unit/out/unsafe/copy_move_deleted.rs
index fcbea82b70..025f47297f 100644
--- a/tests/unit/out/unsafe/copy_move_deleted.rs
+++ b/tests/unit/out/unsafe/copy_move_deleted.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, MoveAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct NoCopy {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/default_function_arguments.rs b/tests/unit/out/unsafe/default_function_arguments.rs
index c757e79caf..cbf7612ed0 100644
--- a/tests/unit/out/unsafe/default_function_arguments.rs
+++ b/tests/unit/out/unsafe/default_function_arguments.rs
@@ -15,7 +15,8 @@ pub unsafe fn baz_1(mut a: *mut i32, mut b: Option<*mut i32>) -> bool {
     return ((a) == (b));
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe)]
+#[cpp_from(i32, new, some_value)]
 pub struct Bar {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/fn_ptr.rs b/tests/unit/out/unsafe/fn_ptr.rs
index b1c1ecf33a..1ef79431be 100644
--- a/tests/unit/out/unsafe/fn_ptr.rs
+++ b/tests/unit/out/unsafe/fn_ptr.rs
@@ -32,7 +32,8 @@ pub unsafe fn identity_hash_6(mut v: bool) -> usize {
     return (v as usize);
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(Option<unsafe fn(bool ,) -> u64 > , new, ptr)]
 pub struct HashHolder_unsigned_long__ptr__bool__ {
     pub h: Option<unsafe fn(bool) -> u64>,
 }
diff --git a/tests/unit/out/unsafe/fn_ptr_struct.rs b/tests/unit/out/unsafe/fn_ptr_struct.rs
index 93f9334af4..d09ca754a8 100644
--- a/tests/unit/out/unsafe/fn_ptr_struct.rs
+++ b/tests/unit/out/unsafe/fn_ptr_struct.rs
@@ -33,7 +33,8 @@ impl S {
     }
 }
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct MoveOnly {
     pub data_: i32,
 }
diff --git a/tests/unit/out/unsafe/forward_basic.rs b/tests/unit/out/unsafe/forward_basic.rs
index a9726b1785..8f4450a91a 100644
--- a/tests/unit/out/unsafe/forward_basic.rs
+++ b/tests/unit/out/unsafe/forward_basic.rs
@@ -10,7 +10,8 @@ pub type Overload = u32;
 pub const Overload_kLvalueOverload: Overload = 1;
 pub const Overload_kRvalueOverload: Overload = 2;
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Tracked {
     pub v: i32,
     pub copies: i32,
@@ -71,7 +72,9 @@ impl Holder {
     }
 }
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(Tracked, new_1, mut_ptr)]
+#[cpp_from_move(Tracked, new_2, ptr)]
 pub struct Holder {
     pub t: Tracked,
 }
diff --git a/tests/unit/out/unsafe/forward_decltype.rs b/tests/unit/out/unsafe/forward_decltype.rs
index 8b590f335e..52854756d9 100644
--- a/tests/unit/out/unsafe/forward_decltype.rs
+++ b/tests/unit/out/unsafe/forward_decltype.rs
@@ -10,7 +10,8 @@ pub type Overload = u32;
 pub const Overload_kLvalueOverload: Overload = 1;
 pub const Overload_kRvalueOverload: Overload = 2;
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Tracked {
     pub v: i32,
     pub copies: i32,
diff --git a/tests/unit/out/unsafe/forward_explicit.rs b/tests/unit/out/unsafe/forward_explicit.rs
index bca567b928..50ff757761 100644
--- a/tests/unit/out/unsafe/forward_explicit.rs
+++ b/tests/unit/out/unsafe/forward_explicit.rs
@@ -12,7 +12,8 @@ pub const Overload_kRvalueOverload: Overload = 2;
 pub const Overload_kIntLvalueOverload: Overload = 3;
 pub const Overload_kIntRvalueOverload: Overload = 4;
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Tracked {
     pub v: i32,
     pub copies: i32,
diff --git a/tests/unit/out/unsafe/forward_pack.rs b/tests/unit/out/unsafe/forward_pack.rs
index b4ce3fef31..04e30c2827 100644
--- a/tests/unit/out/unsafe/forward_pack.rs
+++ b/tests/unit/out/unsafe/forward_pack.rs
@@ -12,7 +12,8 @@ pub const Overload_kRvalueOverload: Overload = 2;
 pub const Overload_kIntLvalueOverload: Overload = 3;
 pub const Overload_kIntRvalueOverload: Overload = 4;
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Tracked {
     pub v: i32,
     pub copies: i32,
diff --git a/tests/unit/out/unsafe/global_init_side_effect.rs b/tests/unit/out/unsafe/global_init_side_effect.rs
index 9913864afc..8a82f9361f 100644
--- a/tests/unit/out/unsafe/global_init_side_effect.rs
+++ b/tests/unit/out/unsafe/global_init_side_effect.rs
@@ -8,7 +8,8 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut total_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct S {}
 impl S {
     pub unsafe fn new(mut x: i32) -> Self {
diff --git a/tests/unit/out/unsafe/lambda_as_field.rs b/tests/unit/out/unsafe/lambda_as_field.rs
index cde749b378..ceb03288f2 100644
--- a/tests/unit/out/unsafe/lambda_as_field.rs
+++ b/tests/unit/out/unsafe/lambda_as_field.rs
@@ -76,7 +76,8 @@ impl Holder__lambda_at_lambda_as_field_cpp_51_12__ {
     }
 }
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe)]
+#[cpp_from(FnPtr<fn(i32 ,) -> i32 > , new, value)]
 pub struct Moving__lambda_at_lambda_as_field_cpp_64_12__ {
     pub f: FnPtr<fn(i32) -> i32>,
     pub moves: i32,
diff --git a/tests/unit/out/unsafe/lambda_move_only_capture.rs b/tests/unit/out/unsafe/lambda_move_only_capture.rs
index 1d16cf92b5..edd3c44cba 100644
--- a/tests/unit/out/unsafe/lambda_move_only_capture.rs
+++ b/tests/unit/out/unsafe/lambda_move_only_capture.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, DestructorUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Owner {
     pub p: *mut i32,
 }
diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs
index ef97ba55bd..a07f253dda 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -110,7 +110,7 @@ unsafe fn main_0() -> i32 {
     assert!(m.find(&8_i16) == m.end());
     let mut other_map: UnsafeMap<(i32, i64), ((i32, i64), f64)> = UnsafeMap::new();
     assert!(((other_map.len()) == (0_usize)));
-    let mut key0: (i32, i64) = (1.into(), 1.into());
+    let mut key0: (i32, i64) = (1, (1 as i64));
     let mut value: f64 = 2_f64;
     (*other_map.subscript(&key0)) = value;
     value = (*other_map.subscript(&key0));
diff --git a/tests/unit/out/unsafe/map_key_copy_ctor.rs b/tests/unit/out/unsafe/map_key_copy_ctor.rs
index deb31ebe87..f461dad5ce 100644
--- a/tests/unit/out/unsafe/map_key_copy_ctor.rs
+++ b/tests/unit/out/unsafe/map_key_copy_ctor.rs
@@ -10,7 +10,8 @@ pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(||
 pub static mut moves_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub static mut made_2: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Key {
     pub k: i32,
 }
diff --git a/tests/unit/out/unsafe/max.rs b/tests/unit/out/unsafe/max.rs
index 4a981f52ae..e2b456d50f 100644
--- a/tests/unit/out/unsafe/max.rs
+++ b/tests/unit/out/unsafe/max.rs
@@ -13,7 +13,8 @@ pub unsafe fn pick_2(mut i: i32) -> *mut i32 {
     return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut xs_1))[(i) as usize];
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Bag {
     pub n: i32,
 }
diff --git a/tests/unit/out/unsafe/move_assign.rs b/tests/unit/out/unsafe/move_assign.rs
index 04b824eaef..156f36d8dd 100644
--- a/tests/unit/out/unsafe/move_assign.rs
+++ b/tests/unit/out/unsafe/move_assign.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, MoveAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct MoveOnly {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/move_ctor.rs b/tests/unit/out/unsafe/move_ctor.rs
index c3e486d7f0..e31e507e0b 100644
--- a/tests/unit/out/unsafe/move_ctor.rs
+++ b/tests/unit/out/unsafe/move_ctor.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct MoveOnly {
     pub v: i32,
 }
@@ -51,7 +52,8 @@ impl Default for ConstMove {
     }
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct ThrowingMove {
     pub v: i32,
     pub copies: i32,
@@ -90,7 +92,8 @@ impl Clone for ThrowingMove {
     }
 }
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct NoexceptMove {
     pub v: i32,
     pub copies: i32,
diff --git a/tests/unit/out/unsafe/move_this.rs b/tests/unit/out/unsafe/move_this.rs
index 948c58fd90..e57b4f4938 100644
--- a/tests/unit/out/unsafe/move_this.rs
+++ b/tests/unit/out/unsafe/move_this.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Chain {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/operator_comparison_nonbool.rs b/tests/unit/out/unsafe/operator_comparison_nonbool.rs
index 71d3b86c1c..bb9808dacc 100644
--- a/tests/unit/out/unsafe/operator_comparison_nonbool.rs
+++ b/tests/unit/out/unsafe/operator_comparison_nonbool.rs
@@ -113,7 +113,8 @@ impl std::cmp::PartialEq for Mixed {
 }
 impl std::cmp::Eq for Mixed {}
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(bool, to_bool)]
 pub struct MyBool {
     pub value: bool,
 }
@@ -173,7 +174,8 @@ pub unsafe fn operator_lt_6(mut a: Boolish, mut b: Boolish) -> MyBool {
     return MyBool::new({ ((a.v) < (b.v)) });
 }
 #[repr(C)]
-#[derive(FnPtrArg, Default)]
+#[derive(FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(bool, to_bool)]
 pub struct RefBool {
     pub value: bool,
 }
diff --git a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
index 67304d49f6..8a714d2888 100644
--- a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
@@ -13,7 +13,8 @@ pub unsafe fn operator_lt_1(x: *const S, y: *const S) -> bool {
     return (((*x).data_) < ((*y).data_));
 }
 #[repr(C)]
-#[derive(FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct S {
     data_: i32,
 }
diff --git a/tests/unit/out/unsafe/operator_other_member.rs b/tests/unit/out/unsafe/operator_other_member.rs
index 380a5dd965..f7232e2e18 100644
--- a/tests/unit/out/unsafe/operator_other_member.rs
+++ b/tests/unit/out/unsafe/operator_other_member.rs
@@ -15,7 +15,8 @@ impl Static {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(i32, to_i32)]
 pub struct S {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/overload_mangling.rs b/tests/unit/out/unsafe/overload_mangling.rs
index 4306e708c7..5a2b0d164d 100644
--- a/tests/unit/out/unsafe/overload_mangling.rs
+++ b/tests/unit/out/unsafe/overload_mangling.rs
@@ -138,22 +138,22 @@ unsafe fn main_0() -> i32 {
             S::take_7(&s, &mut _x)
         }) == (107))
     );
-    assert!(((unsafe { S::pick_8(&s, (1.into(), 2.into()),) }) == (101)));
-    assert!(((unsafe { S::pick_9(&s, (1.into(), 2_i64.into()),) }) == (102)));
+    assert!(((unsafe { S::pick_8(&s, (1, 2),) }) == (101)));
+    assert!(((unsafe { S::pick_9(&s, (1, 2_i64),) }) == (102)));
     assert!(((unsafe { S::apply_10(&s, Some(inc_0), 1,) }) == (102)));
     assert!(((unsafe { S::apply_11(&s, Some(add_1), 1,) }) == (111)));
     assert!(((unsafe { S::apply_12(&s, Some(twice_2), 3,) }) == (106)));
     let c: i32 = 3;
     assert!(
         ((unsafe {
-            let mut _p: (i32, i64) = (1.into(), 2_i64.into());
+            let mut _p: (i32, i64) = (1, 2_i64);
             S::combine_13(&s, &mut _p, Some(twice_2), (&c as *const i32), 4_u64)
         }) == (112))
     );
     let mut z: i32 = 1;
     assert!(
         ((unsafe {
-            let mut _p: (i32, i32) = (1.into(), 2.into());
+            let mut _p: (i32, i32) = (1, 2);
             S::combine_14(&s, &mut _p, Some(add_1), (&mut z as *mut i32), 5_u64)
         }) == (107))
     );
diff --git a/tests/unit/out/unsafe/pair.rs b/tests/unit/out/unsafe/pair.rs
index dafb21c11e..4ec0670896 100644
--- a/tests/unit/out/unsafe/pair.rs
+++ b/tests/unit/out/unsafe/pair.rs
@@ -13,13 +13,16 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p1: (f64, i32) = (1.into(), 2.into());
+    let mut p1: (f64, i32) = ((1 as f64), 2);
     assert!(((p1.0) == (1_f64)));
     assert!(((p1.1) == (2)));
-    let mut p2: (f64, i32) = (3.into(), 4.into());
+    let mut p2: (f64, i32) = ((3 as f64), 4);
     assert!(((p2.0) == (3_f64)));
     assert!(((p2.1) == (4)));
-    let mut p3: (f64, i32) = (5.into(), 6.into());
+    let mut p3: (f64, i32) = {
+        let mut __a0 = (5, 6);
+        (((*&mut __a0.0) as f64), (*&mut __a0.1))
+    };
     assert!(((p3.0) == (5_f64)));
     assert!(((p3.1) == (6)));
     let arr: [i32; 2] = [1, 2];
@@ -27,7 +30,13 @@ unsafe fn main_0() -> i32 {
     let mut const_ptr_pairs: Vec<(*const i32, u64)> = (0..(1_usize) as usize)
         .map(|_| <(*const i32, u64)>::default())
         .collect::<Vec<_>>();
-    const_ptr_pairs[(0_usize)] = (arr.as_ptr().offset((1) as isize).into(), n.into());
+    {
+        let mut __a1 = (arr.as_ptr().offset((1) as isize), n);
+        const_ptr_pairs[(0_usize)] = (
+            <*const i32 as CppFromUnsafe<*const i32>>::cpp_from_move(&mut __a1.0),
+            ((*&mut __a1.1) as u64),
+        )
+    };
     assert!(
         ((*const_ptr_pairs[(0_usize)].0) == (2)) && ((const_ptr_pairs[(0_usize)].1) == (2_u64))
     );
diff --git a/tests/unit/out/unsafe/pair_converting_construction.rs b/tests/unit/out/unsafe/pair_converting_construction.rs
new file mode 100644
index 0000000000..4a4db10254
--- /dev/null
+++ b/tests/unit/out/unsafe/pair_converting_construction.rs
@@ -0,0 +1,271 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
+pub struct Celsius {
+    pub degrees: i32,
+}
+impl Celsius {
+    pub unsafe fn new(mut d: i32) -> Self {
+        let mut this = Self { degrees: d };
+        this
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(i32, to_i32)]
+pub struct Meters {
+    pub value: i32,
+}
+impl Meters {
+    pub unsafe fn to_i32(&self) -> i32 {
+        return self.value;
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(Celsius, new, ptr)]
+pub struct Label {
+    pub id: i32,
+}
+impl Label {
+    pub unsafe fn new(c: *const Celsius) -> Self {
+        let mut this = Self { id: (*c).degrees };
+        this
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(Celsius, new_1, ptr)]
+#[cpp_from_move(Celsius, new_2, ptr)]
+pub struct Owner {
+    pub taken: i32,
+    pub copied: i32,
+}
+impl Owner {
+    pub unsafe fn new_1(c: *const Celsius) -> Self {
+        let mut this = Self {
+            taken: 0,
+            copied: (*c).degrees,
+        };
+        this
+    }
+    pub unsafe fn new_2(c: *mut Celsius) -> Self {
+        let mut this = Self {
+            taken: (*c).degrees,
+            copied: 0,
+        };
+        this
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(Celsius, new, value)]
+pub struct Holder {
+    pub value: i32,
+}
+impl Holder {
+    pub unsafe fn new(mut c: Celsius) -> Self {
+        let mut this = Self { value: c.degrees };
+        this
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe)]
+#[cpp_from(i32, new, some_value)]
+pub struct Fallback {
+    pub value: i32,
+}
+impl Fallback {
+    pub unsafe fn new(mut v: Option<i32>) -> Self {
+        let mut v: i32 = v.unwrap_or_else(|| unsafe { -1_i32 });
+        let mut this = Self { value: v };
+        this
+    }
+}
+impl Default for Fallback {
+    fn default() -> Self {
+        unsafe { Fallback::new(None) }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+pub struct Counter {
+    pub hits: i32,
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(Counter, new, mut_ptr)]
+pub struct Observer {
+    pub seen: i32,
+}
+impl Observer {
+    pub unsafe fn new(c: *mut Counter) -> Self {
+        let mut this = Self { seen: (*c).hits };
+        (*c).hits.postfix_inc();
+        this
+    }
+}
+impl Tag {
+    pub unsafe fn new(u: *const Celsius) -> Self {
+        let mut this = Self {
+            code: (((*u).degrees) + (100)),
+        };
+        this
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(Celsius, new, ptr)]
+pub struct Tag {
+    pub code: i32,
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(*const libc::c_char , new, value)]
+pub struct Name {
+    pub len: i32,
+}
+impl Name {
+    pub unsafe fn new(mut s: *const libc::c_char) -> Self {
+        let mut this = Self { len: 0 };
+        'loop_: while ((*s.offset((this.len) as isize)) != 0) {
+            this.len.prefix_inc();
+        }
+        this
+    }
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut widened: (i64, u32) = ((-1_i32 as i64), 2_u32);
+    assert!(((widened.0) == (-1_i64)));
+    assert!(((widened.1) == (2_u32)));
+    let mut from_ints: (Celsius, Celsius) = (Celsius::new({ 1 }), Celsius::new({ 2 }));
+    assert!(((from_ints.0.degrees) == (1)));
+    assert!(((from_ints.1.degrees) == (2)));
+    let mut m: Meters = Meters { value: 7 };
+    let mut from_operators: (i32, i64) = (
+        (unsafe { Meters::to_i32(&m) }),
+        ((unsafe { Meters::to_i32(&m) }) as i64),
+    );
+    assert!(((from_operators.0) == (7)));
+    assert!(((from_operators.1) == (7_i64)));
+    let mut from_moved_pair: (i64, f64) = {
+        let mut __a0 = (3, 4);
+        (((*&mut __a0.0) as i64), ((*&mut __a0.1) as f64))
+    };
+    assert!(((from_moved_pair.0) == (3_i64)));
+    assert!(((from_moved_pair.1) == (4_f64)));
+    let mut ints: (i32, i32) = (5, 6);
+    let mut from_copied_pair: (Celsius, i64) = {
+        let __a0 = ints;
+        (
+            <Celsius as CppFromUnsafe<i32>>::cpp_from(&__a0.0),
+            ((*&__a0.1) as i64),
+        )
+    };
+    assert!(((from_copied_pair.0.degrees) == (5)));
+    assert!(((from_copied_pair.1) == (6_i64)));
+    let mut meters: (Meters, Meters) = (Meters { value: 8 }, Meters { value: 9 });
+    let mut from_operator_pair: (i32, i32) = {
+        let __a0 = meters;
+        (
+            <i32 as CppFromUnsafe<Meters>>::cpp_from(&__a0.0),
+            <i32 as CppFromUnsafe<Meters>>::cpp_from(&__a0.1),
+        )
+    };
+    assert!(((from_operator_pair.0) == (8)));
+    assert!(((from_operator_pair.1) == (9)));
+    let mut celsius: (Celsius, Celsius) = (Celsius::new({ 10 }), Celsius::new({ 11 }));
+    let mut from_record_pair: (Label, Owner) = {
+        let __a0 = celsius;
+        (
+            <Label as CppFromUnsafe<Celsius>>::cpp_from(&__a0.0),
+            <Owner as CppFromUnsafe<Celsius>>::cpp_from(&__a0.1),
+        )
+    };
+    assert!(((from_record_pair.0.id) == (10)));
+    assert!(((from_record_pair.1.copied) == (11)));
+    assert!(((from_record_pair.1.taken) == (0)));
+    let mut from_moved_record_pair: (Label, Owner) = {
+        let mut __a0 = (Celsius::new({ 12 }), Celsius::new({ 13 }));
+        (
+            <Label as CppFromUnsafe<Celsius>>::cpp_from_move(&mut __a0.0),
+            <Owner as CppFromUnsafe<Celsius>>::cpp_from_move(&mut __a0.1),
+        )
+    };
+    assert!(((from_moved_record_pair.0.id) == (12)));
+    assert!(((from_moved_record_pair.1.taken) == (13)));
+    assert!(((from_moved_record_pair.1.copied) == (0)));
+    let mut from_by_value_pair: (Holder, Holder) = {
+        let __a0 = celsius;
+        (
+            <Holder as CppFromUnsafe<Celsius>>::cpp_from(&__a0.0),
+            <Holder as CppFromUnsafe<Celsius>>::cpp_from(&__a0.1),
+        )
+    };
+    assert!(((from_by_value_pair.0.value) == (10)));
+    assert!(((from_by_value_pair.1.value) == (11)));
+    let mut from_moved_by_value_pair: (Holder, Holder) = {
+        let mut __a0 = (Celsius::new({ 14 }), Celsius::new({ 15 }));
+        (
+            <Holder as CppFromUnsafe<Celsius>>::cpp_from_move(&mut __a0.0),
+            <Holder as CppFromUnsafe<Celsius>>::cpp_from_move(&mut __a0.1),
+        )
+    };
+    assert!(((from_moved_by_value_pair.0.value) == (14)));
+    assert!(((from_moved_by_value_pair.1.value) == (15)));
+    let mut defaulted: Fallback = Fallback::new(None);
+    assert!(((defaulted.value) == (-1_i32)));
+    let mut from_defaulted_ctor: (Fallback, i64) = {
+        let __a0 = ints;
+        (
+            <Fallback as CppFromUnsafe<i32>>::cpp_from(&__a0.0),
+            ((*&__a0.1) as i64),
+        )
+    };
+    assert!(((from_defaulted_ctor.0.value) == (5)));
+    assert!(((from_defaulted_ctor.1) == (6_i64)));
+    let mut counter: Counter = Counter { hits: 3 };
+    let mut forwarded_mutable_ref: (Observer, i32) = (Observer::new({ &mut counter }), 0);
+    assert!(((forwarded_mutable_ref.0.seen) == (3)));
+    assert!(((counter.hits) == (4)));
+    let mut from_template_ctor: (Tag, Tag) = {
+        let __a0 = celsius;
+        (
+            <Tag as CppFromUnsafe<Celsius>>::cpp_from(&__a0.0),
+            <Tag as CppFromUnsafe<Celsius>>::cpp_from(&__a0.1),
+        )
+    };
+    assert!(((from_template_ctor.0.code) == (110)));
+    assert!(((from_template_ctor.1.code) == (111)));
+    let mut lvalue_source: Celsius = Celsius::new({ 16 });
+    let mut moved_source: Celsius = Celsius::new({ 17 });
+    let mut forwarded_records: (Label, Owner) = (
+        Label::new({ &lvalue_source }),
+        Owner::new_2({ &mut moved_source }),
+    );
+    assert!(((forwarded_records.0.id) == (16)));
+    assert!(((forwarded_records.1.taken) == (17)));
+    assert!(((forwarded_records.1.copied) == (0)));
+    let mut from_string_literals: (Name, Name) = (
+        Name::new({ c"ab".as_ptr() }),
+        Name::new({ c"cde".as_ptr() }),
+    );
+    assert!(((from_string_literals.0.len) == (2)));
+    assert!(((from_string_literals.1.len) == (3)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pair_get.rs b/tests/unit/out/unsafe/pair_get.rs
index 2a5bf44c77..a2c391af7a 100644
--- a/tests/unit/out/unsafe/pair_get.rs
+++ b/tests/unit/out/unsafe/pair_get.rs
@@ -19,7 +19,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p: (f64, i32) = (1.5_f64.into(), 2.into());
+    let mut p: (f64, i32) = (1.5_f64, 2);
     assert!(((p.0) == (1.5_f64)));
     assert!(((p.1) == (2)));
     assert!(((unsafe { first_of_1(&p,) }) == (1.5_f64)));
diff --git a/tests/unit/out/unsafe/push_emplace_back.rs b/tests/unit/out/unsafe/push_emplace_back.rs
index b04f3b6355..ee8d3fba57 100644
--- a/tests/unit/out/unsafe/push_emplace_back.rs
+++ b/tests/unit/out/unsafe/push_emplace_back.rs
@@ -56,7 +56,7 @@ pub unsafe fn push_local_from_field_1(mut jpg: *mut JPEGData, mut cond: bool) {
             let mut __v = Vec::new();
             let mut __it = head.as_mut_ptr();
             while __it != head.as_mut_ptr().offset((3) as isize) {
-                __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+                __v.push((*__it.iter_deref()));
                 __it.iter_inc();
             }
             __v
@@ -86,7 +86,7 @@ pub unsafe fn emplace_local_from_field_4(mut jpg: *mut JPEGData, mut cond: bool)
             let mut __v = Vec::new();
             let mut __it = head.as_mut_ptr();
             while __it != head.as_mut_ptr().offset((3) as isize) {
-                __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+                __v.push((*__it.iter_deref()));
                 __it.iter_inc();
             }
             __v
@@ -107,20 +107,21 @@ pub unsafe fn self_ref_push_6(mut comps: *mut Vec<Chunk>) {
     };
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe)]
+#[cpp_from(i32, new_1, value)]
 pub struct Pair {
     pub first: i32,
     pub second: i32,
 }
 impl Pair {
-    pub unsafe fn new_1() -> Self {
+    pub unsafe fn new_2() -> Self {
         let mut this = Self {
             first: -1_i32,
             second: -1_i32,
         };
         this
     }
-    pub unsafe fn new_2(mut a: i32) -> Self {
+    pub unsafe fn new_1(mut a: i32) -> Self {
         let mut this = Self {
             first: a,
             second: 0,
@@ -137,16 +138,16 @@ impl Pair {
 }
 impl Default for Pair {
     fn default() -> Self {
-        unsafe { Pair::new_1() }
+        unsafe { Pair::new_2() }
     }
 }
 pub unsafe fn emplace_ctor_args_7(mut pairs: *mut Vec<Pair>) {
     {
-        let __init = Pair::new_1();
+        let __init = Pair::new_2();
         (*pairs).push(__init)
     };
     {
-        let __init = Pair::new_2({ 3 });
+        let __init = Pair::new_1({ 3 });
         (*pairs).push(__init)
     };
     {
@@ -160,7 +161,7 @@ pub unsafe fn emplace_deque_8(mut queue: *mut Vec<Pair>) {
         (*queue).push(__init)
     };
     {
-        let __init = Pair::new_1();
+        let __init = Pair::new_2();
         (*queue).push(__init)
     };
 }
diff --git a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
index 4313144aab..aca1edac03 100644
--- a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
@@ -36,6 +36,12 @@ unsafe fn main_0() -> i32 {
     r += (unsafe { sink_0((it0).clone()) });
     r += if end == end { 0 } else { 1 };
     assert!(((r) == (2)));
+    let mut values: Vec<u32> = Vec::from([7_u32, 8_u32, 9_u32]);
+    let mut middle: UnsafeRandomAccessIterator<u32> = values.begin().iter_add(1_isize);
+    let mut const_middle: UnsafeRandomAccessIterator<u32> =
+        <UnsafeRandomAccessIterator<u32>>::from((middle).clone());
+    assert!(((*const_middle.iter_deref()) == (8_u32)));
+    assert!(const_middle == middle);
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rule_of_five.rs b/tests/unit/out/unsafe/rule_of_five.rs
index 669d0b6836..7eeff43751 100644
--- a/tests/unit/out/unsafe/rule_of_five.rs
+++ b/tests/unit/out/unsafe/rule_of_five.rs
@@ -11,8 +11,16 @@ pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(||
 pub static mut moves_2: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(
-    VaArg, FnPtrArg, MoveCtorUnsafe, CopyAssignUnsafe, MoveAssignUnsafe, DestructorUnsafe, Default,
+    VaArg,
+    FnPtrArg,
+    MoveCtorUnsafe,
+    CppFromUnsafe,
+    CopyAssignUnsafe,
+    MoveAssignUnsafe,
+    DestructorUnsafe,
+    Default,
 )]
+#[cpp_from(i32, new, value)]
 pub struct Buffer {
     pub data: [i32; 4],
     pub size: i32,
diff --git a/tests/unit/out/unsafe/rule_of_three.rs b/tests/unit/out/unsafe/rule_of_three.rs
index b541fbdd95..ceeea00020 100644
--- a/tests/unit/out/unsafe/rule_of_three.rs
+++ b/tests/unit/out/unsafe/rule_of_three.rs
@@ -9,7 +9,8 @@ use std::rc::Rc;
 pub static mut alive_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, DestructorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Buffer {
     pub data: [i32; 4],
     pub size: i32,
diff --git a/tests/unit/out/unsafe/rvalue_rule_arg_move.rs b/tests/unit/out/unsafe/rvalue_rule_arg_move.rs
index 125d50af1f..696d349e03 100644
--- a/tests/unit/out/unsafe/rvalue_rule_arg_move.rs
+++ b/tests/unit/out/unsafe/rvalue_rule_arg_move.rs
@@ -9,7 +9,8 @@ use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub static mut moves_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CopyAssignUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, CopyAssignUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Elem {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/size_t_ssize_t.rs b/tests/unit/out/unsafe/size_t_ssize_t.rs
index a70846c76f..12499e9e65 100644
--- a/tests/unit/out/unsafe/size_t_ssize_t.rs
+++ b/tests/unit/out/unsafe/size_t_ssize_t.rs
@@ -186,7 +186,7 @@ unsafe fn main_0() -> i32 {
     ];
     assert!(((mins[(1) as usize]) == (1_usize)));
     assert!(((mins[(2) as usize]) == (2_usize)));
-    let mut pr: (u64, i32) = ((sz as u64).into(), 1.into());
+    let mut pr: (u64, i32) = ((sz as u64), 1);
     assert!(((pr.0) == (21_u64)));
     let sizes: [usize; 4] = [1_usize, 2_usize, 3_usize, 4_usize];
     let mut sizes_end: *const usize =
diff --git a/tests/unit/out/unsafe/size_t_template_param.rs b/tests/unit/out/unsafe/size_t_template_param.rs
index 25a1d13f7e..70248f4630 100644
--- a/tests/unit/out/unsafe/size_t_template_param.rs
+++ b/tests/unit/out/unsafe/size_t_template_param.rs
@@ -11,7 +11,8 @@ pub unsafe fn array_ref_0(a: *mut [u64; 3]) -> u64 {
     return (*a)[((3_u64 as u64).wrapping_sub(1_u64)) as usize];
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(*const u64 , new, value)]
 pub struct PtrCtor_unsigned_long_ {
     pub v: u64,
 }
@@ -24,7 +25,8 @@ impl PtrCtor_unsigned_long_ {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(u64, new, ptr)]
 pub struct RefCtor_unsigned_long_ {
     pub v: u64,
 }
diff --git a/tests/unit/out/unsafe/sort_no_copy.rs b/tests/unit/out/unsafe/sort_no_copy.rs
index 7ece5c6328..57b02ee222 100644
--- a/tests/unit/out/unsafe/sort_no_copy.rs
+++ b/tests/unit/out/unsafe/sort_no_copy.rs
@@ -8,16 +8,17 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CopyAssignUnsafe, MoveAssignUnsafe)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, CopyAssignUnsafe, MoveAssignUnsafe)]
+#[cpp_from(i32, new_1, value)]
 pub struct Tracked {
     pub v: i32,
 }
 impl Tracked {
-    pub unsafe fn new_1() -> Self {
+    pub unsafe fn new_2() -> Self {
         let mut this = Self { v: 0 };
         this
     }
-    pub unsafe fn new_2(mut v: i32) -> Self {
+    pub unsafe fn new_1(mut v: i32) -> Self {
         let mut this = Self { v: v };
         this
     }
@@ -74,7 +75,7 @@ impl Clone for Tracked {
 }
 impl Default for Tracked {
     fn default() -> Self {
-        unsafe { Tracked::new_1() }
+        unsafe { Tracked::new_2() }
     }
 }
 pub unsafe fn operator_lt_1(a: *const Tracked, b: *const Tracked) -> bool {
@@ -138,11 +139,11 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut arr: [Tracked; 5] = [
-        Tracked::new_2({ 3 }),
-        Tracked::new_2({ 1 }),
-        Tracked::new_2({ 4 }),
-        Tracked::new_2({ 1 }),
-        Tracked::new_2({ 5 }),
+        Tracked::new_1({ 3 }),
+        Tracked::new_1({ 1 }),
+        Tracked::new_1({ 4 }),
+        Tracked::new_1({ 1 }),
+        Tracked::new_1({ 5 }),
     ];
     {
         let __first = arr.as_mut_ptr();
@@ -173,19 +174,19 @@ unsafe fn main_0() -> i32 {
         vec_.reserve_exact(4_usize as usize - len_0 as usize);
     };
     {
-        let __init = Tracked::new_2({ 2 });
+        let __init = Tracked::new_1({ 2 });
         vec_.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 7 });
+        let __init = Tracked::new_1({ 7 });
         vec_.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 1 });
+        let __init = Tracked::new_1({ 1 });
         vec_.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 8 });
+        let __init = Tracked::new_1({ 8 });
         vec_.push(__init)
     };
     {
@@ -296,15 +297,15 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (0)));
     let mut bags: [Bag; 3] = std::array::from_fn::<_, 3, _>(|_| <Bag>::default());
     {
-        let __init = Tracked::new_2({ 1 });
+        let __init = Tracked::new_1({ 1 });
         bags[(0) as usize].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 2 });
+        let __init = Tracked::new_1({ 2 });
         bags[(0) as usize].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 3 });
+        let __init = Tracked::new_1({ 3 });
         bags[(2) as usize].items.push(__init)
     };
     {
@@ -332,15 +333,15 @@ unsafe fn main_0() -> i32 {
         .map(|_| <Bag>::default())
         .collect::<Vec<_>>();
     {
-        let __init = Tracked::new_2({ 4 });
+        let __init = Tracked::new_1({ 4 });
         bag_vec[(1_usize)].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 5 });
+        let __init = Tracked::new_1({ 5 });
         bag_vec[(1_usize)].items.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 6 });
+        let __init = Tracked::new_1({ 6 });
         bag_vec[(2_usize)].items.push(__init)
     };
     {
diff --git a/tests/unit/out/unsafe/stdcopy.rs b/tests/unit/out/unsafe/stdcopy.rs
index c9da6cfeb6..8ce65d479a 100644
--- a/tests/unit/out/unsafe/stdcopy.rs
+++ b/tests/unit/out/unsafe/stdcopy.rs
@@ -6,6 +6,18 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
+pub struct Degrees {
+    pub value: i32,
+}
+impl Degrees {
+    pub unsafe fn new(mut v: i32) -> Self {
+        let mut this = Self { value: v };
+        this
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -20,12 +32,52 @@ unsafe fn main_0() -> i32 {
         let __last = input.as_mut_ptr().offset((3) as isize);
         let mut __out = output.as_mut_ptr();
         while __first != __last {
-            *__out.iter_deref() = (*__first.iter_deref()).clone().into();
+            *__out.iter_deref() = (*__first.iter_deref());
+            __first.iter_inc();
+            __out.iter_inc();
+        }
+        __out
+    };
+    let mut widened: Vec<i64> = vec![0_i64; 3_usize as usize];
+    {
+        let mut __first = input.as_mut_ptr();
+        let __last = input.as_mut_ptr().offset((3) as isize);
+        let mut __out = widened.begin();
+        while __first != __last {
+            *__out.iter_deref() = ((*__first.iter_deref()) as i64);
+            __first.iter_inc();
+            __out.iter_inc();
+        }
+        __out
+    };
+    assert!(((widened[(0_usize)]) == (1_i64)) && ((widened[(2_usize)]) == (3_i64)));
+    let mut constructed: Vec<Degrees> = vec![Degrees::new({ 0 },); 3_usize as usize];
+    {
+        let mut __first = input.as_mut_ptr();
+        let __last = input.as_mut_ptr().offset((3) as isize);
+        let mut __out = constructed.begin();
+        while __first != __last {
+            *__out.iter_deref() = <Degrees as CppFromUnsafe<i32>>::cpp_from(__first.iter_deref());
+            __first.iter_inc();
+            __out.iter_inc();
+        }
+        __out
+    };
+    assert!(((constructed[(0_usize)].value) == (1)) && ((constructed[(2_usize)].value) == (3)));
+    let mut wide: [i64; 2] = [7_i64, 8_i64];
+    let mut floating: Vec<f64> = vec![0_f64; 2_usize as usize];
+    {
+        let mut __first = wide.as_mut_ptr();
+        let __last = wide.as_mut_ptr().offset((2) as isize);
+        let mut __out = floating.begin();
+        while __first != __last {
+            *__out.iter_deref() = ((*__first.iter_deref()) as f64);
             __first.iter_inc();
             __out.iter_inc();
         }
         __out
     };
+    assert!(((floating[(1_usize)]) == (8_f64)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/struct_ctor.rs b/tests/unit/out/unsafe/struct_ctor.rs
index 8e8b0a7928..3e63641a74 100644
--- a/tests/unit/out/unsafe/struct_ctor.rs
+++ b/tests/unit/out/unsafe/struct_ctor.rs
@@ -30,7 +30,8 @@ pub unsafe fn foo_0(x: *mut i32) -> *mut i32 {
     return x;
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Value_ {
     pub v: i32,
 }
diff --git a/tests/unit/out/unsafe/structured_binding_element_ctor.rs b/tests/unit/out/unsafe/structured_binding_element_ctor.rs
index db6370f5b9..fa1aac1549 100644
--- a/tests/unit/out/unsafe/structured_binding_element_ctor.rs
+++ b/tests/unit/out/unsafe/structured_binding_element_ctor.rs
@@ -9,7 +9,8 @@ use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub static mut moves_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct Elem {
     pub v: i32,
 }
@@ -94,7 +95,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (before_copies)));
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_1)) == (before_moves)));
     assert!(((__decomp_6.a.v) == (1)));
-    let mut p: (Elem, Elem) = (Elem::new({ 7 }).into(), Elem::new({ 8 }).into());
+    let mut p: (Elem, Elem) = (Elem::new({ 7 }), Elem::new({ 8 }));
     before_copies = (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0));
     let mut __decomp_7: (Elem, Elem) = p.clone();
     let x: *mut Elem = &mut __decomp_7.0;
diff --git a/tests/unit/out/unsafe/structured_binding_pair.rs b/tests/unit/out/unsafe/structured_binding_pair.rs
index 0bf6e072c1..0d2f41474c 100644
--- a/tests/unit/out/unsafe/structured_binding_pair.rs
+++ b/tests/unit/out/unsafe/structured_binding_pair.rs
@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn make_std_pair_0(mut x: i32) -> (i32, bool) {
-    return (x.into(), ((x) > (0)).into());
+    return (x, ((x) > (0)));
 }
 pub fn main() {
     unsafe {
@@ -21,7 +21,7 @@ unsafe fn main_0() -> i32 {
     let positive: *mut bool = &mut __decomp_1.1;
     assert!(((*value) == (5)));
     assert!(((*positive) as bool));
-    let mut p: (i32, i32) = (1.into(), 2.into());
+    let mut p: (i32, i32) = (1, 2);
     let mut __decomp_2: (i32, i32) = p.clone();
     let a: *mut i32 = &mut __decomp_2.0;
     let b: *mut i32 = &mut __decomp_2.1;
diff --git a/tests/unit/out/unsafe/swap_map_no_copy.rs b/tests/unit/out/unsafe/swap_map_no_copy.rs
index 4f975df24f..7078d0882e 100644
--- a/tests/unit/out/unsafe/swap_map_no_copy.rs
+++ b/tests/unit/out/unsafe/swap_map_no_copy.rs
@@ -8,16 +8,17 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CopyAssignUnsafe, MoveAssignUnsafe)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, CppFromUnsafe, CopyAssignUnsafe, MoveAssignUnsafe)]
+#[cpp_from(i32, new_1, value)]
 pub struct Tracked {
     pub v: i32,
 }
 impl Tracked {
-    pub unsafe fn new_1() -> Self {
+    pub unsafe fn new_2() -> Self {
         let mut this = Self { v: 0 };
         this
     }
-    pub unsafe fn new_2(mut v: i32) -> Self {
+    pub unsafe fn new_1(mut v: i32) -> Self {
         let mut this = Self { v: v };
         this
     }
@@ -47,7 +48,7 @@ impl Clone for Tracked {
 }
 impl Default for Tracked {
     fn default() -> Self {
-        unsafe { Tracked::new_1() }
+        unsafe { Tracked::new_2() }
     }
 }
 #[repr(C)]
@@ -149,7 +150,8 @@ pub static mut copy_only_copies_1: std::cell::LazyCell<i32> =
 pub static mut copy_only_dtors_2: std::cell::LazyCell<i32> =
     std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, DestructorUnsafe, Default)]
+#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct CopyOnly {
     pub v: i32,
 }
@@ -207,8 +209,16 @@ pub static mut move_assigns_4: std::cell::LazyCell<i32> = std::cell::LazyCell::n
 pub static mut moved_dtors_5: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(
-    VaArg, FnPtrArg, MoveCtorUnsafe, CopyAssignUnsafe, MoveAssignUnsafe, DestructorUnsafe, Default,
+    VaArg,
+    FnPtrArg,
+    MoveCtorUnsafe,
+    CppFromUnsafe,
+    CopyAssignUnsafe,
+    MoveAssignUnsafe,
+    DestructorUnsafe,
+    Default,
 )]
+#[cpp_from(i32, new, value)]
 pub struct Moved {
     pub v: i32,
 }
@@ -335,21 +345,21 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut a: Tracked = Tracked::new_2({ 1 });
-    let mut b: Tracked = Tracked::new_2({ 2 });
+    let mut a: Tracked = Tracked::new_1({ 1 });
+    let mut b: Tracked = Tracked::new_1({ 2 });
     cpp_swap_unsafe!(&mut a, &mut b);
     assert!(((a.v) == (2)) && ((b.v) == (1)));
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (0)));
     let mut m1: UnsafeMap<i32, (i32, Tracked)> = UnsafeMap::new();
     (unsafe {
-        let mut _o: Tracked = Tracked::new_2({ 10 });
+        let mut _o: Tracked = Tracked::new_1({ 10 });
         Tracked::move_assign(
             &mut (*m1.subscript_move(&mut 1, |__k| cpp_move_unsafe!(__k))),
             &mut _o,
         )
     });
     (unsafe {
-        let mut _o: Tracked = Tracked::new_2({ 20 });
+        let mut _o: Tracked = Tracked::new_1({ 20 });
         Tracked::move_assign(
             &mut (*m1.subscript_move(&mut 2, |__k| cpp_move_unsafe!(__k))),
             &mut _o,
@@ -357,7 +367,7 @@ unsafe fn main_0() -> i32 {
     });
     let mut m2: UnsafeMap<i32, (i32, Tracked)> = UnsafeMap::new();
     (unsafe {
-        let mut _o: Tracked = Tracked::new_2({ 30 });
+        let mut _o: Tracked = Tracked::new_1({ 30 });
         Tracked::move_assign(
             &mut (*m2.subscript_move(&mut 3, |__k| cpp_move_unsafe!(__k))),
             &mut _o,
@@ -385,9 +395,9 @@ unsafe fn main_0() -> i32 {
     );
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (0)));
     let mut arr: [Tracked; 3] = [
-        Tracked::new_2({ 1 }),
-        Tracked::new_2({ 2 }),
-        Tracked::new_2({ 3 }),
+        Tracked::new_1({ 1 }),
+        Tracked::new_1({ 2 }),
+        Tracked::new_1({ 3 }),
     ];
     cpp_swap_unsafe!(&mut arr[(0) as usize], &mut arr[(2) as usize]);
     assert!(((arr[(0) as usize].v) == (3)) && ((arr[(2) as usize].v) == (1)));
@@ -396,11 +406,11 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (0)));
     let mut vec_: Vec<Tracked> = Vec::new();
     {
-        let __init = Tracked::new_2({ 4 });
+        let __init = Tracked::new_1({ 4 });
         vec_.push(__init)
     };
     {
-        let __init = Tracked::new_2({ 5 });
+        let __init = Tracked::new_1({ 5 });
         vec_.push(__init)
     };
     cpp_swap_unsafe!(&mut vec_[(0_usize)], &mut vec_[(1_usize)]);
@@ -408,17 +418,17 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (0)));
     let mut pairs: [Pair; 2] = [
         Pair {
-            x: Tracked::new_2({ 6 }),
-            y: Tracked::new_2({ 7 }),
+            x: Tracked::new_1({ 6 }),
+            y: Tracked::new_1({ 7 }),
         },
         Pair {
-            x: Tracked::new_2({ 8 }),
-            y: Tracked::new_2({ 9 }),
+            x: Tracked::new_1({ 8 }),
+            y: Tracked::new_1({ 9 }),
         },
     ];
     let mut p: Pair = Pair {
-        x: Tracked::new_2({ 10 }),
-        y: Tracked::new_2({ 11 }),
+        x: Tracked::new_1({ 10 }),
+        y: Tracked::new_1({ 11 }),
     };
     cpp_swap_unsafe!(&mut pairs[(0) as usize].x, &mut p.y);
     assert!(((pairs[(0) as usize].x.v) == (11)) && ((p.y.v) == (6)));
@@ -442,15 +452,15 @@ unsafe fn main_0() -> i32 {
         .map(|_| Default::default())
         .collect::<Vec<_>>();
     {
-        let __init = Tracked::new_2({ 1 });
+        let __init = Tracked::new_1({ 1 });
         grid[(0_usize)].push(__init)
     };
     {
-        let __init = Tracked::new_2({ 2 });
+        let __init = Tracked::new_1({ 2 });
         grid[(0_usize)].push(__init)
     };
     {
-        let __init = Tracked::new_2({ 3 });
+        let __init = Tracked::new_1({ 3 });
         grid[(1_usize)].push(__init)
     };
     cpp_swap_unsafe!(
@@ -464,14 +474,14 @@ unsafe fn main_0() -> i32 {
     let mut maps: [UnsafeMap<i32, (i32, Tracked)>; 2] =
         std::array::from_fn::<_, 2, _>(|_| UnsafeMap::new());
     (unsafe {
-        let mut _o: Tracked = Tracked::new_2({ 1 });
+        let mut _o: Tracked = Tracked::new_1({ 1 });
         Tracked::move_assign(
             &mut (*maps[(0) as usize].subscript_move(&mut 1, |__k| cpp_move_unsafe!(__k))),
             &mut _o,
         )
     });
     (unsafe {
-        let mut _o: Tracked = Tracked::new_2({ 2 });
+        let mut _o: Tracked = Tracked::new_1({ 2 });
         Tracked::move_assign(
             &mut (*maps[(1) as usize].subscript_move(&mut 2, |__k| cpp_move_unsafe!(__k))),
             &mut _o,
diff --git a/tests/unit/out/unsafe/template_default_arg.rs b/tests/unit/out/unsafe/template_default_arg.rs
index 6c840f91b2..9808d05df4 100644
--- a/tests/unit/out/unsafe/template_default_arg.rs
+++ b/tests/unit/out/unsafe/template_default_arg.rs
@@ -7,23 +7,24 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe)]
+#[cpp_from(i32, new_1, value)]
 pub struct A {
     pub v: i32,
 }
 impl A {
-    pub unsafe fn new_1() -> Self {
+    pub unsafe fn new_2() -> Self {
         let mut this = Self { v: 1 };
         this
     }
-    pub unsafe fn new_2(mut v: i32) -> Self {
+    pub unsafe fn new_1(mut v: i32) -> Self {
         let mut this = Self { v: v };
         this
     }
 }
 impl Default for A {
     fn default() -> Self {
-        unsafe { A::new_1() }
+        unsafe { A::new_2() }
     }
 }
 #[repr(C)]
@@ -43,7 +44,8 @@ impl Default for B {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct NoDefault {
     pub v: i32,
 }
@@ -54,7 +56,7 @@ impl NoDefault {
     }
 }
 pub unsafe fn used_0(mut x: Option<A>) -> i32 {
-    let mut x: A = x.unwrap_or_else(|| unsafe { A::new_1() });
+    let mut x: A = x.unwrap_or_else(|| unsafe { A::new_2() });
     return x.v;
 }
 pub unsafe fn used_1(mut x: Option<B>) -> i32 {
@@ -69,7 +71,8 @@ pub unsafe fn always_given_3(mut x: NoDefault) -> i32 {
     return x.v;
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct S_NoDefault_ {
     pub v: i32,
 }
@@ -90,13 +93,13 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     assert!(((unsafe { used_0(None,) }) == (1)));
-    assert!(((unsafe { used_0(Some(A::new_2({ 5 },)),) }) == (5)));
+    assert!(((unsafe { used_0(Some(A::new_1({ 5 },)),) }) == (5)));
     assert!(((unsafe { used_1(None,) }) == (2)));
     assert!(
-        ((unsafe { scaled_2(A::new_2({ 3 },), None,) })
+        ((unsafe { scaled_2(A::new_1({ 3 },), None,) })
             == ((3) * (::std::mem::size_of::<A>() as i32)))
     );
-    assert!(((unsafe { scaled_2(A::new_2({ 3 },), Some(2),) }) == (6)));
+    assert!(((unsafe { scaled_2(A::new_1({ 3 },), Some(2),) }) == (6)));
     assert!(((unsafe { always_given_3(NoDefault::new({ 3 },),) }) == (3)));
     let mut s: S_NoDefault_ = S_NoDefault_::new({ 1 });
     assert!(((unsafe { S_NoDefault_::get(&s, NoDefault::new({ 4 },),) }) == (5)));
diff --git a/tests/unit/out/unsafe/template_rule_unqualified_call.rs b/tests/unit/out/unsafe/template_rule_unqualified_call.rs
index e7f619cf76..6cf9d71182 100644
--- a/tests/unit/out/unsafe/template_rule_unqualified_call.rs
+++ b/tests/unit/out/unsafe/template_rule_unqualified_call.rs
@@ -14,33 +14,24 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     assert!(
-        (({
-            let __c: i32 = (('a' as libc::c_char) as i32).into();
-            if (0..=255).contains(&__c) {
-                (__c as u8).to_ascii_uppercase() as i32
-            } else {
-                __c
-            }
+        ((if (0..=255).contains(&(('a' as libc::c_char) as i32)) {
+            ((('a' as libc::c_char) as i32) as u8).to_ascii_uppercase() as i32
+        } else {
+            (('a' as libc::c_char) as i32)
         }) == (('A' as libc::c_char) as i32))
     );
     assert!(
-        (({
-            let __c: i32 = (('Z' as libc::c_char) as i32).into();
-            if (0..=255).contains(&__c) {
-                (__c as u8).to_ascii_uppercase() as i32
-            } else {
-                __c
-            }
+        ((if (0..=255).contains(&(('Z' as libc::c_char) as i32)) {
+            ((('Z' as libc::c_char) as i32) as u8).to_ascii_uppercase() as i32
+        } else {
+            (('Z' as libc::c_char) as i32)
         }) == (('Z' as libc::c_char) as i32))
     );
     assert!(
-        (({
-            let __c: i32 = (('5' as libc::c_char) as i32).into();
-            if (0..=255).contains(&__c) {
-                (__c as u8).to_ascii_uppercase() as i32
-            } else {
-                __c
-            }
+        ((if (0..=255).contains(&(('5' as libc::c_char) as i32)) {
+            ((('5' as libc::c_char) as i32) as u8).to_ascii_uppercase() as i32
+        } else {
+            (('5' as libc::c_char) as i32)
         }) == (('5' as libc::c_char) as i32))
     );
     return 0;
diff --git a/tests/unit/out/unsafe/this.rs b/tests/unit/out/unsafe/this.rs
index bedb00b593..d6f623cbf3 100644
--- a/tests/unit/out/unsafe/this.rs
+++ b/tests/unit/out/unsafe/this.rs
@@ -7,7 +7,8 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new_1, value)]
 pub struct S {
     pub a_: i32,
     pub self__: *mut S,
@@ -105,7 +106,8 @@ pub unsafe fn bump_0(mut p: *mut S) {
     (*p).a_.postfix_inc();
 }
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
 pub struct D {
     pub a_: i32,
 }
diff --git a/tests/unit/out/unsafe/va_list_field.rs b/tests/unit/out/unsafe/va_list_field.rs
index 6fbccc3bef..d895f9d4f0 100644
--- a/tests/unit/out/unsafe/va_list_field.rs
+++ b/tests/unit/out/unsafe/va_list_field.rs
@@ -20,7 +20,8 @@ pub unsafe fn sum_0(mut n: i32, __args: Box<[VaArg]>) -> i32 {
     return total;
 }
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, DestructorUnsafe, Default)]
+#[derive(Clone, VaArg, FnPtrArg, CppFromUnsafe, DestructorUnsafe, Default)]
+#[cpp_from(*const VaArg , new, mut_ptr)]
 pub struct Guard_1 {
     pub ap: *mut *const VaArg,
     pub active: bool,
diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs
index 061185273d..7a50d8d894 100644
--- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs
+++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs
@@ -6,6 +6,29 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_from(i32, new, value)]
+pub struct Degrees {
+    pub value: i32,
+}
+impl Degrees {
+    pub unsafe fn new(mut v: i32) -> Self {
+        let mut this = Self { value: v };
+        this
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, CppFromUnsafe, Default)]
+#[cpp_into(i64, to_i64)]
+pub struct Reading {
+    pub raw_: i32,
+}
+impl Reading {
+    pub unsafe fn to_i64(&self) -> i64 {
+        return ((self.raw_ as i64) * (10_i64));
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -18,7 +41,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push((*__it.iter_deref()));
             __it.iter_inc();
         }
         __v
@@ -32,7 +55,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(<u64>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(((*__it.iter_deref()) as u64));
             __it.iter_inc();
         }
         __v
@@ -46,7 +69,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(<i32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(((*__it.iter_deref()) as i32));
             __it.iter_inc();
         }
         __v
@@ -58,7 +81,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src1.as_ptr();
         while __it != src1.as_ptr().add(src1.len()) {
-            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push((*__it.iter_deref()));
             __it.iter_inc();
         }
         __v
@@ -75,7 +98,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = start;
         while __it != start.offset((len) as isize) {
-            __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push((*__it.iter_deref()));
             __it.iter_inc();
         }
         __v
@@ -90,11 +113,9 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = m.begin();
         while __it != m.end() {
-            __v.push(
-                <(i32, i32)>::try_from((*__it.iter_deref()).clone())
-                    .ok()
-                    .unwrap(),
-            );
+            __v.push(<(i32, i32) as CppFromUnsafe<(i32, i32)>>::cpp_from(
+                __it.iter_deref(),
+            ));
             __it.iter_inc();
         }
         __v
@@ -119,6 +140,28 @@ unsafe fn main_0() -> i32 {
     assert!(
         (((v6[(1_usize)].0) == (1)) && ((v6[(3_usize)].0) == (3))) && ((v6[(4_usize)].0) == (2))
     );
+    let mut ints: [i32; 3] = [4, 5, 6];
+    let mut v7: Vec<Degrees> = {
+        let mut __v = Vec::new();
+        let mut __it = ints.as_mut_ptr();
+        while __it != ints.as_mut_ptr().offset((3) as isize) {
+            __v.push(<Degrees as CppFromUnsafe<i32>>::cpp_from(__it.iter_deref()));
+            __it.iter_inc();
+        }
+        __v
+    };
+    assert!(((v7[(1_usize)].value) == (5)));
+    let mut readings: [Reading; 2] = [Reading { raw_: 4 }, Reading { raw_: 5 }];
+    let mut v8: Vec<i64> = {
+        let mut __v = Vec::new();
+        let mut __it = readings.as_mut_ptr();
+        while __it != readings.as_mut_ptr().offset((2) as isize) {
+            __v.push(<i64 as CppFromUnsafe<Reading>>::cpp_from(__it.iter_deref()));
+            __it.iter_inc();
+        }
+        __v
+    };
+    assert!(((v8[(0_usize)]) == (40_i64)) && ((v8[(1_usize)]) == (50_i64)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index ce6fdf1c3e..15bdcac93a 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -253,7 +253,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push((*__it.iter_deref()));
             __it.iter_inc();
         }
         __v
@@ -267,7 +267,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(<u64>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(((*__it.iter_deref()) as u64));
             __it.iter_inc();
         }
         __v
@@ -281,7 +281,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(<i32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(((*__it.iter_deref()) as i32));
             __it.iter_inc();
         }
         __v
@@ -293,7 +293,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src1.as_ptr();
         while __it != src1.as_ptr().add(src1.len()) {
-            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push((*__it.iter_deref()));
             __it.iter_inc();
         }
         __v
@@ -310,7 +310,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = start;
         while __it != start.offset((len) as isize) {
-            __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push((*__it.iter_deref()));
             __it.iter_inc();
         }
         __v
diff --git a/tests/unit/pair_converting_construction.cpp b/tests/unit/pair_converting_construction.cpp
new file mode 100644
index 0000000000..9139a1ae5b
--- /dev/null
+++ b/tests/unit/pair_converting_construction.cpp
@@ -0,0 +1,135 @@
+#include <cassert>
+#include <utility>
+
+struct Celsius {
+  int degrees;
+  Celsius(int d) : degrees(d) {}
+};
+
+struct Meters {
+  int value;
+  operator int() const { return value; }
+};
+
+struct Label {
+  int id;
+  Label(const Celsius &c) : id(c.degrees) {}
+};
+
+struct Owner {
+  int taken;
+  int copied;
+  Owner(const Celsius &c) : taken(0), copied(c.degrees) {}
+  Owner(Celsius &&c) : taken(c.degrees), copied(0) {}
+};
+
+struct Holder {
+  int value;
+  Holder(Celsius c) : value(c.degrees) {}
+};
+
+struct Fallback {
+  int value;
+  Fallback(int v = -1) : value(v) {}
+};
+
+struct Counter {
+  int hits;
+};
+
+struct Observer {
+  int seen;
+  Observer(Counter &c) : seen(c.hits) { c.hits++; }
+};
+
+struct Tag {
+  int code;
+  template <class U> Tag(const U &u) : code(u.degrees + 100) {}
+};
+
+struct Name {
+  int len;
+  Name(const char *s) : len(0) {
+    while (s[len]) {
+      ++len;
+    }
+  }
+};
+
+int main() {
+  std::pair<long, unsigned> widened(-1, 2u);
+  assert(widened.first == -1L);
+  assert(widened.second == 2u);
+
+  std::pair<Celsius, Celsius> from_ints(1, 2);
+  assert(from_ints.first.degrees == 1);
+  assert(from_ints.second.degrees == 2);
+
+  Meters m{7};
+  std::pair<int, long> from_operators(m, m);
+  assert(from_operators.first == 7);
+  assert(from_operators.second == 7L);
+
+  std::pair<long, double> from_moved_pair = std::make_pair(3, 4);
+  assert(from_moved_pair.first == 3L);
+  assert(from_moved_pair.second == 4.0);
+
+  std::pair<int, int> ints(5, 6);
+  std::pair<Celsius, long> from_copied_pair = ints;
+  assert(from_copied_pair.first.degrees == 5);
+  assert(from_copied_pair.second == 6L);
+
+  std::pair<Meters, Meters> meters(Meters{8}, Meters{9});
+  std::pair<int, int> from_operator_pair = meters;
+  assert(from_operator_pair.first == 8);
+  assert(from_operator_pair.second == 9);
+
+  std::pair<Celsius, Celsius> celsius(10, 11);
+  std::pair<Label, Owner> from_record_pair = celsius;
+  assert(from_record_pair.first.id == 10);
+  assert(from_record_pair.second.copied == 11);
+  assert(from_record_pair.second.taken == 0);
+
+  std::pair<Label, Owner> from_moved_record_pair =
+      std::make_pair(Celsius(12), Celsius(13));
+  assert(from_moved_record_pair.first.id == 12);
+  assert(from_moved_record_pair.second.taken == 13);
+  assert(from_moved_record_pair.second.copied == 0);
+
+  std::pair<Holder, Holder> from_by_value_pair = celsius;
+  assert(from_by_value_pair.first.value == 10);
+  assert(from_by_value_pair.second.value == 11);
+
+  std::pair<Holder, Holder> from_moved_by_value_pair =
+      std::make_pair(Celsius(14), Celsius(15));
+  assert(from_moved_by_value_pair.first.value == 14);
+  assert(from_moved_by_value_pair.second.value == 15);
+
+  Fallback defaulted;
+  assert(defaulted.value == -1);
+  std::pair<Fallback, long> from_defaulted_ctor = ints;
+  assert(from_defaulted_ctor.first.value == 5);
+  assert(from_defaulted_ctor.second == 6L);
+
+  Counter counter{3};
+  std::pair<Observer, int> forwarded_mutable_ref(counter, 0);
+  assert(forwarded_mutable_ref.first.seen == 3);
+  assert(counter.hits == 4);
+
+  std::pair<Tag, Tag> from_template_ctor = celsius;
+  assert(from_template_ctor.first.code == 110);
+  assert(from_template_ctor.second.code == 111);
+
+  Celsius lvalue_source(16);
+  Celsius moved_source(17);
+  std::pair<Label, Owner> forwarded_records(lvalue_source,
+                                            std::move(moved_source));
+  assert(forwarded_records.first.id == 16);
+  assert(forwarded_records.second.taken == 17);
+  assert(forwarded_records.second.copied == 0);
+
+  std::pair<Name, Name> from_string_literals("ab", "cde");
+  assert(from_string_literals.first.len == 2);
+  assert(from_string_literals.second.len == 3);
+  return 0;
+}
diff --git a/tests/unit/redundant_copy_in_conversion.cpp b/tests/unit/redundant_copy_in_conversion.cpp
index 0bc8f2726c..5d7e1f3563 100644
--- a/tests/unit/redundant_copy_in_conversion.cpp
+++ b/tests/unit/redundant_copy_in_conversion.cpp
@@ -1,5 +1,6 @@
 #include <cassert>
 #include <map>
+#include <vector>
 
 static int sink(std::map<int, int>::iterator it) {
   std::map<int, int>::const_iterator cit(it);
@@ -24,5 +25,11 @@ int main() {
   r += sink(it0);
   r += end == end ? 0 : 1;
   assert(r == 2);
+
+  std::vector<unsigned> values = {7, 8, 9};
+  std::vector<unsigned>::iterator middle = values.begin() + 1;
+  std::vector<unsigned>::const_iterator const_middle = middle;
+  assert(*const_middle == 8);
+  assert(const_middle == middle);
   return 0;
 }
diff --git a/tests/unit/stdcopy.cpp b/tests/unit/stdcopy.cpp
index 739897079b..cc0d575879 100644
--- a/tests/unit/stdcopy.cpp
+++ b/tests/unit/stdcopy.cpp
@@ -1,8 +1,28 @@
 #include <algorithm>
+#include <cassert>
+#include <vector>
+
+struct Degrees {
+  int value;
+  Degrees(int v) : value(v) {}
+};
 
 int main() {
   int input[] = {1, 2, 3};
   int output[3];
   std::copy(input, input + 3, output);
+
+  std::vector<long> widened(3, 0L);
+  std::copy(input, input + 3, widened.begin());
+  assert(widened[0] == 1L && widened[2] == 3L);
+
+  std::vector<Degrees> constructed(3, Degrees(0));
+  std::copy(input, input + 3, constructed.begin());
+  assert(constructed[0].value == 1 && constructed[2].value == 3);
+
+  long wide[2] = {7L, 8L};
+  std::vector<double> floating(2, 0.0);
+  std::copy(wide, wide + 2, floating.begin());
+  assert(floating[1] == 8.0);
   return 0;
 }
diff --git a/tests/unit/vector_iter_range_ctor.cpp b/tests/unit/vector_iter_range_ctor.cpp
index 03a7868a4e..d6d2a05958 100644
--- a/tests/unit/vector_iter_range_ctor.cpp
+++ b/tests/unit/vector_iter_range_ctor.cpp
@@ -4,6 +4,16 @@
 #include <map>
 #include <vector>
 
+struct Degrees {
+  int value;
+  Degrees(int v) : value(v) {}
+};
+
+struct Reading {
+  int raw;
+  operator long() const { return raw * 10L; }
+};
+
 int main() {
   uint32_t src[3] = {1, 2, 3};
 
@@ -46,5 +56,13 @@ int main() {
   assert(v6.size() == 6);
   assert(v6[1].first == 1 && v6[3].first == 3 && v6[4].first == 2);
 
+  int ints[3] = {4, 5, 6};
+  std::vector<Degrees> v7(ints, ints + 3);
+  assert(v7[1].value == 5);
+
+  Reading readings[2] = {{4}, {5}};
+  std::vector<long> v8(readings, readings + 2);
+  assert(v8[0] == 40L && v8[1] == 50L);
+
   return 0;
 }