diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 54d06ea1da..cc4a32dff0 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -122,6 +122,10 @@ std::string Converter::GetUnboxedTypeAsString(clang::QualType qual_type) {
   return ToString(qual_type);
 }
 
+std::string Converter::GetUnboxedDefaultAsString(clang::QualType qual_type) {
+  return GetDefaultAsString(qual_type);
+}
+
 std::string
 Converter::GetTemplateArgumentAsString(const clang::TemplateArgument &arg) {
   switch (arg.getKind()) {
@@ -5041,15 +5045,16 @@ std::string Converter::ConvertTake(clang::Expr *arg) {
 
 std::string Converter::ConvertMappedMethodCall(
     clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
-    clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx) {
-  return ConvertIRFragment(mc.receiver, expr, args, num_args, ctx) +
-         ConvertIRFragment(mc.body, expr, args, num_args, ctx);
+    llvm::ArrayRef<clang::TemplateArgument> bindings, clang::Expr **args,
+    unsigned num_args, TempMaterializationCtx *ctx) {
+  return ConvertIRFragment(mc.receiver, bindings, expr, args, num_args, ctx) +
+         ConvertIRFragment(mc.body, bindings, expr, args, num_args, ctx);
 }
 
 std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
                                          unsigned num_args,
                                          TempMaterializationCtx *ctx) {
-  auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, expr);
+  auto [tgt_ir, bindings] = RuleRegistry::Search(ctx_, expr);
   if (!tgt_ir)
     return {};
 
@@ -5058,8 +5063,8 @@ std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
   auto saved_borrows = std::exchange(mut_borrows_, {});
   auto *operand = tgt_ir->refExprOperand();
   bool lvalue = operand && !isAddrOf();
-  auto result = ConvertIRFragment(lvalue ? *operand : tgt_ir->body, expr, args,
-                                  num_args, ctx);
+  auto result = ConvertIRFragment(lvalue ? *operand : tgt_ir->body, bindings,
+                                  expr, args, num_args, ctx);
   if (tgt_ir->multi_statement) {
     result = '{' + result + '}';
   }
@@ -5073,19 +5078,28 @@ std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
 
 std::string Converter::ConvertIRFragment(
     const std::vector<TranslationRule::BodyFragment> &fragments,
-    clang::Expr *expr, clang::Expr **args, unsigned num_args,
-    TempMaterializationCtx *ctx) {
+    llvm::ArrayRef<clang::TemplateArgument> bindings, clang::Expr *expr,
+    clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx) {
   using namespace TranslationRule;
 
-  auto all_args = BuildUnifiedArgs(expr, args, num_args);
+  std::vector<clang::Expr *> all_args;
+  if (expr) {
+    all_args = BuildUnifiedArgs(expr, args, num_args);
+  }
 
   std::string result;
   for (auto &frag : fragments) {
     if (auto *t = std::get_if<TextFragment>(&frag)) {
       result += t->text;
     } else if (auto *g = std::get_if<GenericFragment>(&frag)) {
-      result += Mapper::InstantiateTemplate(*this, expr, g->n);
+      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;
       assert(arg_idx < all_args.size());
       auto *arg = all_args[arg_idx];
@@ -5110,16 +5124,20 @@ std::string Converter::ConvertIRFragment(
       };
       result += ConvertPlaceholder(expr, arg, ph_ctx);
     } else if (std::get_if<TranslationRule::VaArgsFragment>(&frag)) {
+      assert(expr && "variadic arguments outside an expression rule");
       result += ConvertVariadicTail(expr, all_args);
     } else if (std::get_if<TranslationRule::InitFragment>(&frag)) {
+      assert(expr && "init outside an expression rule");
       result += ConvertInitFragment(expr, all_args);
     } else if (auto *mc =
                    std::get_if<std::unique_ptr<MethodCallFragment>>(&frag)) {
-      result += ConvertMappedMethodCall(expr, **mc, args, num_args, ctx);
+      result +=
+          ConvertMappedMethodCall(expr, **mc, bindings, args, num_args, ctx);
     } else if (auto *re =
                    std::get_if<std::unique_ptr<RefExprFragment>>(&frag)) {
-      result += (*re)->prefix + ' ' +
-                ConvertIRFragment((*re)->inner, expr, args, num_args, ctx);
+      result +=
+          (*re)->prefix + ' ' +
+          ConvertIRFragment((*re)->inner, bindings, expr, args, num_args, ctx);
     }
   }
 
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index dba18297ad..f6ba0973cf 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -92,6 +92,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual std::string GetUnboxedTypeAsString(clang::QualType qual_type);
 
+  virtual std::string GetUnboxedDefaultAsString(clang::QualType qual_type);
+
   std::string GetTemplateArgumentAsString(const clang::TemplateArgument &arg);
 
   bool VisitRecoveryExpr(clang::RecoveryExpr *expr);
@@ -296,6 +298,12 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     std::vector<std::string> materialized_refs_;
   };
 
+  std::string
+  ConvertIRFragment(const std::vector<TranslationRule::BodyFragment> &fragments,
+                    llvm::ArrayRef<clang::TemplateArgument> bindings,
+                    clang::Expr *expr, clang::Expr **args, unsigned num_args,
+                    TempMaterializationCtx *ctx);
+
   struct PlaceholderCtx {
     unsigned arg_idx;
     std::optional<clang::QualType> implicit_convert_to;
@@ -834,11 +842,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                 unsigned num_args = 0,
                                 TempMaterializationCtx *ctx = nullptr);
 
-  std::string
-  ConvertIRFragment(const std::vector<TranslationRule::BodyFragment> &fragments,
-                    clang::Expr *expr, clang::Expr **args, unsigned num_args,
-                    TempMaterializationCtx *ctx);
-
   std::string ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
                                  const PlaceholderCtx &ph_ctx);
 
@@ -868,7 +871,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual std::string ConvertMappedMethodCall(
       clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
-      clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx);
+      llvm::ArrayRef<clang::TemplateArgument> bindings, clang::Expr **args,
+      unsigned num_args, TempMaterializationCtx *ctx);
 
   virtual std::string AccessLValueObject(clang::MemberExpr *member);
 
diff --git a/cpp2rust/converter/mapper.cpp b/cpp2rust/converter/mapper.cpp
index dca1462ea0..0384f76170 100644
--- a/cpp2rust/converter/mapper.cpp
+++ b/cpp2rust/converter/mapper.cpp
@@ -44,15 +44,6 @@ std::string MapFunctionName(clang::ASTContext &ctx,
   return GetNamedDeclAsString(decl->getCanonicalDecl());
 }
 
-std::string InstantiateTemplate(Converter &converter, const clang::Expr *expr,
-                                unsigned n) {
-  auto [rule, subs] = RuleRegistry::Search(converter.GetASTContext(), expr);
-  if (!rule) {
-    return std::format("T{}", n);
-  }
-  return Matcher::MapBinding(converter, subs, n - 1);
-}
-
 std::string Map(clang::ASTContext &ctx, clang::QualType qual_type) {
   auto rule = RuleRegistry::Search(ctx, qual_type).first;
   return rule ? rule->type_info.type : std::string();
@@ -71,7 +62,8 @@ std::string MapInitializer(Converter &converter, clang::QualType qual_type) {
   auto [rule, subs] =
       RuleRegistry::Search(converter.GetASTContext(), qual_type);
   if (rule && !rule->initializer.empty()) {
-    return Matcher::InstantiateTgt(converter, subs, rule->initializer);
+    return converter.ConvertIRFragment(rule->initializer, subs, nullptr,
+                                       nullptr, 0, nullptr);
   }
   return {};
 }
diff --git a/cpp2rust/converter/mapper.h b/cpp2rust/converter/mapper.h
index 98612af58c..ed0156b678 100644
--- a/cpp2rust/converter/mapper.h
+++ b/cpp2rust/converter/mapper.h
@@ -25,8 +25,6 @@ std::string Map(Converter &converter, clang::QualType qual_type);
 std::string MapInitializer(Converter &converter, clang::QualType qual_type);
 std::string MapFunctionName(clang::ASTContext &ctx,
                             const clang::FunctionDecl *decl);
-std::string InstantiateTemplate(Converter &converter, const clang::Expr *expr,
-                                unsigned n);
 std::string GetParamType(Converter &converter, const clang::Expr *expr,
                          unsigned index);
 std::string GetReturnType(Converter &converter, const clang::Expr *expr);
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 765e15fc66..3550437fdb 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -239,6 +239,12 @@ ConverterRefCount::GetUnboxedTypeAsString(clang::QualType qual_type) {
   return ToString(qual_type);
 }
 
+std::string
+ConverterRefCount::GetUnboxedDefaultAsString(clang::QualType qual_type) {
+  PushConversionKind push(*this, ConversionKind::Unboxed);
+  return GetDefaultAsString(qual_type);
+}
+
 bool ConverterRefCount::Convert(clang::QualType qual_type) {
   // Catch va_list before desugaring
   if (IsVaListType(qual_type)) {
@@ -2971,11 +2977,13 @@ std::string ConverterRefCount::ConvertTake(clang::Expr *arg) {
 
 std::string ConverterRefCount::ConvertMappedMethodCall(
     clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
-    clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx) {
+    llvm::ArrayRef<clang::TemplateArgument> bindings, clang::Expr **args,
+    unsigned num_args, TempMaterializationCtx *ctx) {
   auto receiver_ph = mc.getReceiverPlaceholder();
   if (!receiver_ph || receiver_ph->access == TranslationRule::Access::kBorrow ||
       receiver_ph->access == TranslationRule::Access::kMove) {
-    return Converter::ConvertMappedMethodCall(expr, mc, args, num_args, ctx);
+    return Converter::ConvertMappedMethodCall(expr, mc, bindings, args,
+                                              num_args, ctx);
   }
 
   auto arg_idx = receiver_ph->n;
@@ -2988,9 +2996,9 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
   auto param_type = Mapper::GetParamType(*this, expr, arg_idx);
 
   if (arg->getType()->isPointerType()) {
-    return std::format("{}.with_mut(|__v: {}| __v{})", ConvertPointer(arg),
-                       param_type,
-                       ConvertIRFragment(mc.body, expr, args, num_args, ctx));
+    return std::format(
+        "{}.with_mut(|__v: {}| __v{})", ConvertPointer(arg), param_type,
+        ConvertIRFragment(mc.body, bindings, expr, args, num_args, ctx));
   }
 
   // A receiver reached through a pointer is modified through it, only for
@@ -2998,14 +3006,16 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
   std::string receiver;
   {
     ScopedValue in_receiver(in_receiver_, true);
-    receiver = ConvertIRFragment(mc.receiver, expr, args, num_args, ctx);
+    receiver =
+        ConvertIRFragment(mc.receiver, bindings, expr, args, num_args, ctx);
   }
   if (pending_deref_.empty()) {
-    return receiver + ConvertIRFragment(mc.body, expr, args, num_args, ctx);
+    return receiver +
+           ConvertIRFragment(mc.body, bindings, expr, args, num_args, ctx);
   }
 
   auto ptr = pending_deref_.take();
-  auto body = ConvertIRFragment(mc.body, expr, args, num_args, ctx);
+  auto body = ConvertIRFragment(mc.body, bindings, expr, args, num_args, ctx);
   MarkFresh();
 
   return std::format("{}.with_mut(|__v: {}| __v{})", ptr, param_type, body);
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index 11a78c735a..a99dd063ca 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -19,6 +19,8 @@ class ConverterRefCount final : public Converter {
 
   std::string GetUnboxedTypeAsString(clang::QualType qual_type) override;
 
+  std::string GetUnboxedDefaultAsString(clang::QualType qual_type) override;
+
   static void EmitMethodsOnPtr(std::string &out);
 
   bool VisitRecordType(clang::RecordType *type) override;
@@ -319,11 +321,10 @@ class ConverterRefCount final : public Converter {
   // converted.
   bool in_receiver_ = false;
 
-  std::string
-  ConvertMappedMethodCall(clang::Expr *expr,
-                          const TranslationRule::MethodCallFragment &mc,
-                          clang::Expr **args, unsigned num_args,
-                          TempMaterializationCtx *ctx) override;
+  std::string ConvertMappedMethodCall(
+      clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
+      llvm::ArrayRef<clang::TemplateArgument> bindings, clang::Expr **args,
+      unsigned num_args, TempMaterializationCtx *ctx) override;
 
 private:
   void SetUFCSReceiver(clang::Expr *base, bool is_arrow,
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index 182cb1c80c..2a4f7ef5c4 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -93,6 +93,10 @@ void collectGenerics(const std::vector<TranslationRule::BodyFragment> &body,
                 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;
       });
 }
diff --git a/cpp2rust/converter/translation_rule.cpp b/cpp2rust/converter/translation_rule.cpp
index ff00cdb465..b8adc57408 100644
--- a/cpp2rust/converter/translation_rule.cpp
+++ b/cpp2rust/converter/translation_rule.cpp
@@ -91,6 +91,8 @@ 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")) {
@@ -232,6 +234,8 @@ void RefExprFragment::dump() const {
 
 void GenericFragment::dump() const { log() << "  generic: " << n << '\n'; }
 
+void DefaultFragment::dump() const { log() << "  default: " << n << '\n'; }
+
 void TypeInfo::dump() const {
   log() << type;
   if (is_refcount_pointer)
@@ -247,7 +251,10 @@ void TypeRule::dump() const {
   type_info.dump();
   log() << '\n';
   if (!initializer.empty()) {
-    log() << "  init: " << initializer << '\n';
+    log() << "  init:\n";
+    for (auto &frag : initializer) {
+      BodyFragmentDump(frag);
+    }
   }
 }
 
@@ -300,8 +307,8 @@ ExprRule ParseExprRuleJSON(const llvm::json::Object &obj) {
 
 TypeRule ParseTypeRuleJSON(const llvm::json::Object &obj) {
   TypeRule rule;
-  if (auto init = obj.getString("init"))
-    rule.initializer = init->str();
+  if (auto *init = obj.getArray("init"))
+    rule.initializer = ParseBodyFragmentsJSON(*init);
   if (auto generic = obj.getInteger("generic"))
     rule.generic = *generic;
   rule.type_info = ParseTypeInfoJSON(obj);
diff --git a/cpp2rust/converter/translation_rule.h b/cpp2rust/converter/translation_rule.h
index 6f404c0060..a923c6868c 100644
--- a/cpp2rust/converter/translation_rule.h
+++ b/cpp2rust/converter/translation_rule.h
@@ -41,6 +41,12 @@ struct GenericFragment {
   void dump() const;
 };
 
+struct DefaultFragment {
+  unsigned n;
+
+  void dump() const;
+};
+
 struct VaArgsFragment {
   void dump() const;
 };
@@ -52,10 +58,11 @@ struct InitFragment {
 struct MethodCallFragment; // forward declaration
 struct RefExprFragment;
 
-using BodyFragment = std::variant<TextFragment, PlaceholderFragment,
-                                  GenericFragment, VaArgsFragment, InitFragment,
-                                  std::unique_ptr<MethodCallFragment>,
-                                  std::unique_ptr<RefExprFragment>>;
+using BodyFragment =
+    std::variant<TextFragment, PlaceholderFragment, GenericFragment,
+                 DefaultFragment, VaArgsFragment, InitFragment,
+                 std::unique_ptr<MethodCallFragment>,
+                 std::unique_ptr<RefExprFragment>>;
 
 struct MethodCallFragment {
   std::vector<BodyFragment> receiver;
@@ -101,7 +108,7 @@ struct ExprRule {
 };
 
 struct TypeRule {
-  std::string initializer; // Rust initializer expression
+  std::vector<BodyFragment> initializer; // Rust initializer expression
   unsigned generic = 0;
   TypeInfo type_info;
 
diff --git a/rule-preprocessor/src/ir.rs b/rule-preprocessor/src/ir.rs
index d8010689d0..a767bf3766 100644
--- a/rule-preprocessor/src/ir.rs
+++ b/rule-preprocessor/src/ir.rs
@@ -142,7 +142,7 @@ impl FnIr {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TypeIr {
-    pub init: String,
+    pub init: Vec<BodyFragment>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub generic: Option<i32>,
     #[serde(flatten)]
@@ -161,6 +161,9 @@ pub enum BodyFragment {
     Generic {
         generic: i32,
     },
+    Default {
+        default: i32,
+    },
     MethodCall {
         method_call: MethodCallInner,
     },
diff --git a/rule-preprocessor/src/syntactic.rs b/rule-preprocessor/src/syntactic.rs
index 608322a310..17fc7b50be 100644
--- a/rule-preprocessor/src/syntactic.rs
+++ b/rule-preprocessor/src/syntactic.rs
@@ -3,7 +3,9 @@
 
 use cfg_expr::Expression;
 use cfg_expr::expr::{Predicate, TargetPredicate};
-use ra_ap_syntax::ast::{HasAttrs, HasGenericArgs, HasGenericParams, HasName, HasTypeBounds};
+use ra_ap_syntax::ast::{
+    HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasName, HasTypeBounds,
+};
 use ra_ap_syntax::{AstNode, SyntaxKind, ast, match_ast};
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
@@ -188,6 +190,14 @@ 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))
+                {
+                    self.flush_text();
+                    self.fragments
+                        .push(BodyFragment::Default { default: generic });
+                    return;
+                }
                 for child in node.children_with_tokens() {
                     self.visit(child);
                 }
@@ -250,6 +260,38 @@ 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() {
+            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 name = match segment.name_ref() {
+            Some(name_ref) => name_ref.text().to_string(),
+            None => segment
+                .syntax()
+                .descendants()
+                .find_map(ast::Type::cast)?
+                .syntax()
+                .text()
+                .to_string(),
+        };
+        if !self.generic_names.contains(&name) {
+            return None;
+        }
+        Some(name[1..].parse().unwrap_or(0))
+    }
+
     fn emit_method_call(&mut self, call: &ast::MethodCallExpr) {
         assert!(
             call.receiver().is_some(),
@@ -634,8 +676,24 @@ impl<'a> TypeIrBuilder<'a> {
             .find(|name| name.text() == ty_text)
             .map(|name| name.text()[1..].parse().expect("generic name is T<n>"));
 
+        let generic_names: Vec<String> = self
+            .fn_item
+            .generic_param_list()
+            .into_iter()
+            .flat_map(|gpl| gpl.generic_params())
+            .filter_map(|param| match param {
+                ast::GenericParam::TypeParam(tp) => tp.name(),
+                ast::GenericParam::ConstParam(cp) => cp.name(),
+                _ => None,
+            })
+            .map(|name| name.text().to_string())
+            .collect();
+        let builder = FnIrBuilder::new(self.fn_item);
+        let mut init_ctx = FragmentCtx::new(&builder, &[], &generic_names);
+        init_ctx.visit(ra_ap_syntax::NodeOrToken::Node(init.syntax().clone()));
+
         TypeIr {
-            init: init.syntax().text().to_string(),
+            init: init_ctx.finish(),
             generic,
             type_info: TypeInfo {
                 ty: ty.syntax().text().to_string(),
diff --git a/tests/ub/out/refcount/ub6.rs b/tests/ub/out/refcount/ub6.rs
index 92075fba4a..67d9e5d7c8 100644
--- a/tests/ub/out/refcount/ub6.rs
+++ b/tests/ub/out/refcount/ub6.rs
@@ -62,7 +62,7 @@ fn main_0() -> i32 {
     let arr: Value<Option<Value<Box<[Ptr<i32>]>>>> =
         Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
             (0..((*n.borrow()) as usize))
-                .map(|_| <Ptr<i32>>::default())
+                .map(|_| Ptr::<i32>::null())
                 .collect::<Box<[_]>>(),
         )))));
     ({ fill_1(arr.as_pointer(), n.as_pointer()) });
diff --git a/tests/ub/out/unsafe/ub6.rs b/tests/ub/out/unsafe/ub6.rs
index ea62e69b66..d7f5209030 100644
--- a/tests/ub/out/unsafe/ub6.rs
+++ b/tests/ub/out/unsafe/ub6.rs
@@ -55,7 +55,7 @@ unsafe fn main_0() -> i32 {
     let mut n: i32 = 2;
     let mut arr: Option<Box<[*mut i32]>> = Some(
         (0..(n as usize))
-            .map(|_| <*mut i32>::default())
+            .map(|_| std::ptr::null_mut())
             .collect::<Box<[_]>>(),
     );
     (unsafe { fill_1(&mut arr, &mut n) });
diff --git a/tests/unit/out/refcount/08_unique_array.rs b/tests/unit/out/refcount/08_unique_array.rs
index 2056473e27..bc5473f383 100644
--- a/tests/unit/out/refcount/08_unique_array.rs
+++ b/tests/unit/out/refcount/08_unique_array.rs
@@ -12,7 +12,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let mut g: Option<Value<Box<[i32]>>> = Some(Rc::new(RefCell::new(
-        (0..2_usize).map(|_| <i32>::default()).collect::<Box<[_]>>(),
+        (0..2_usize).map(|_| 0_i32).collect::<Box<[_]>>(),
     )));
     (g.as_pointer() as Ptr<i32>)
         .offset(0_usize as isize)
diff --git a/tests/unit/out/refcount/12_test.rs b/tests/unit/out/refcount/12_test.rs
index 492fe1f82e..89208c6263 100644
--- a/tests/unit/out/refcount/12_test.rs
+++ b/tests/unit/out/refcount/12_test.rs
@@ -13,9 +13,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let v: Value<Vec<Vec<i32>>> = Rc::new(RefCell::new(Vec::new()));
     {
-        let __a1 = (0..(10_usize) as usize)
-            .map(|_| <i32>::default())
-            .collect::<Vec<_>>();
+        let __a1 = (0..(10_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>();
         (*v.borrow_mut()).push(__a1)
     };
     return 0;
diff --git a/tests/unit/out/refcount/alloc_array.rs b/tests/unit/out/refcount/alloc_array.rs
index 23ccbe4b29..a1c0ca16ec 100644
--- a/tests/unit/out/refcount/alloc_array.rs
+++ b/tests/unit/out/refcount/alloc_array.rs
@@ -8,9 +8,7 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn All_0(arr: Ptr<Option<Value<Box<[i32]>>>>, mut N: i32, mut element: i32) {
     let all: Value<Option<Value<Box<[i32]>>>> = Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
+        (0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>(),
     )))));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
@@ -38,9 +36,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let mut N: i32 = 10;
     let arr: Value<Option<Value<Box<[i32]>>>> = Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
+        (0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>(),
     )))));
     ({ All_0(arr.as_pointer(), N, 1) });
     assert!((({ Consume_1((*arr.borrow_mut()).take(), N,) }) == 10));
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index cd0d775425..ebd577ad16 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -150,9 +150,7 @@ fn main_0() -> i32 {
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         {
-            let __a1 = (0..(10_usize) as usize)
-                .map(|_| <i32>::default())
-                .collect::<Vec<_>>();
+            let __a1 = (0..(10_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>();
             (*m1.borrow_mut()).push(__a1)
         };
         i.prefix_inc();
@@ -231,7 +229,7 @@ fn main_0() -> i32 {
     let pair3: Value<(Value<Vec<i32>>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new(
             (0..(0_usize) as usize)
-                .map(|_| <i32>::default())
+                .map(|_| 0_i32)
                 .collect::<Vec<_>>()
                 .try_into()
                 .expect("failed conversion"),
diff --git a/tests/unit/out/refcount/deref_call_subscript.rs b/tests/unit/out/refcount/deref_call_subscript.rs
index e96a9dc136..f96b558bfd 100644
--- a/tests/unit/out/refcount/deref_call_subscript.rs
+++ b/tests/unit/out/refcount/deref_call_subscript.rs
@@ -8,9 +8,7 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 thread_local!(
     pub static g_0: Value<Vec<u8>> = Rc::new(RefCell::new(
-        (0..(3_usize) as usize)
-            .map(|_| <u8>::default())
-            .collect::<Vec<_>>(),
+        (0..(3_usize) as usize).map(|_| 0_u8).collect::<Vec<_>>(),
     ));
 );
 pub fn get_1() -> Ptr<Vec<u8>> {
@@ -22,12 +20,8 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     index!(({ get_1() }), 1_usize).write(4_u8);
-    let mut v: Option<Value<Vec<u8>>> = Ptr::alloc(
-        (0..(3_usize) as usize)
-            .map(|_| <u8>::default())
-            .collect::<Vec<_>>(),
-    )
-    .to_owned_opt();
+    let mut v: Option<Value<Vec<u8>>> =
+        Ptr::alloc((0..(3_usize) as usize).map(|_| 0_u8).collect::<Vec<_>>()).to_owned_opt();
     elem!((v.as_pointer()).decay(), 2_usize).write(5_u8);
     assert!((((index!(({ get_1() }), 1_usize).read()) as i32) == 4));
     assert!((((elem!((v.as_pointer()).decay(), 2_usize).read()) as i32) == 5));
diff --git a/tests/unit/out/refcount/empty_array_init.rs b/tests/unit/out/refcount/empty_array_init.rs
index b162babcf3..8481daae9c 100644
--- a/tests/unit/out/refcount/empty_array_init.rs
+++ b/tests/unit/out/refcount/empty_array_init.rs
@@ -12,7 +12,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let vec_: Value<Vec<i32>> = Rc::new(RefCell::new(
-        std::array::from_fn::<_, 3_usize, _>(|_| <i32>::default()).to_vec(),
+        std::array::from_fn::<_, 3_usize, _>(|_| 0_i32).to_vec(),
     ));
     return 0;
 }
diff --git a/tests/unit/out/refcount/fft.rs b/tests/unit/out/refcount/fft.rs
index 2a02ae192a..c9cfc623df 100644
--- a/tests/unit/out/refcount/fft.rs
+++ b/tests/unit/out/refcount/fft.rs
@@ -202,14 +202,10 @@ fn main_0() -> i32 {
     }
     let mut b: Option<Value<Box<[Complex]>>> = ({ fft_3(a.as_pointer(), N) });
     let mut reals: Option<Value<Box<[i32]>>> = Some(Rc::new(RefCell::new(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
+        (0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>(),
     )));
     let mut imgs: Option<Value<Box<[i32]>>> = Some(Rc::new(RefCell::new(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
+        (0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>(),
     )));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
diff --git a/tests/unit/out/refcount/huffman.rs b/tests/unit/out/refcount/huffman.rs
index 1de3747be6..f5cc1c9147 100644
--- a/tests/unit/out/refcount/huffman.rs
+++ b/tests/unit/out/refcount/huffman.rs
@@ -79,7 +79,7 @@ pub fn AllocMinHeap_1(mut capacity: i32) -> Option<Value<MinHeap>> {
         capacity: capacity,
         arr: Some(Rc::new(RefCell::new(
             (0..(capacity as usize))
-                .map(|_| <Ptr<MinHeapNode>>::default())
+                .map(|_| Ptr::<MinHeapNode>::null())
                 .collect::<Box<[_]>>(),
         ))),
         next: 0,
@@ -209,14 +209,10 @@ pub fn HuffmanCodes_5(
     });
     let mut root: Ptr<MinHeapNode> = ({ MinHeapImpl::ExtractMin(&(minHeap.as_pointer())) });
     let arr: Value<Option<Value<Box<[i32]>>>> = Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
-        (0..100_usize)
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
+        (0..100_usize).map(|_| 0_i32).collect::<Box<[_]>>(),
     )))));
     let out: Value<Option<Value<Box<[i32]>>>> = Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
-        (0..100_usize)
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
+        (0..100_usize).map(|_| 0_i32).collect::<Box<[_]>>(),
     )))));
     let mut top: i32 = 0;
     let next: Value<i32> = Rc::new(RefCell::new(0));
@@ -247,16 +243,11 @@ fn main_0() -> i32 {
     ];
     let mut arr2: [i32; 6] = [5, 9, 12, 13, 16, 45];
     let data: Value<Option<Value<Box<[i8]>>>> = Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
-        (0..(size as usize))
-            .map(|_| <i8>::default())
-            .collect::<Box<[_]>>(),
+        (0..(size as usize)).map(|_| 0_i8).collect::<Box<[_]>>(),
     )))));
-    let freq: Value<Option<Value<Box<[i32]>>>> =
-        Rc::new(RefCell::new(Some(Rc::new(RefCell::new(
-            (0..(size as usize))
-                .map(|_| <i32>::default())
-                .collect::<Box<[_]>>(),
-        )))));
+    let freq: Value<Option<Value<Box<[i32]>>>> = Rc::new(RefCell::new(Some(Rc::new(
+        RefCell::new((0..(size as usize)).map(|_| 0_i32).collect::<Box<[_]>>()),
+    ))));
     let mut i: i32 = 0;
     'loop_: while (i < size) {
         let __rhs = arr1[(i) as usize];
diff --git a/tests/unit/out/refcount/inline_container_fields.rs b/tests/unit/out/refcount/inline_container_fields.rs
index 8fc6393ef8..7b0f76c350 100644
--- a/tests/unit/out/refcount/inline_container_fields.rs
+++ b/tests/unit/out/refcount/inline_container_fields.rs
@@ -81,7 +81,7 @@ impl Default for State {
                 grid: (0..2)
                     .map(|_| (0..3).map(|_| 0_i32).collect::<Box<[i32]>>())
                     .collect::<Box<[Box<[i32]>]>>(),
-                arr: std::array::from_fn::<_, 3_usize, _>(|_| <i32>::default()).to_vec(),
+                arr: std::array::from_fn::<_, 3_usize, _>(|_| 0_i32).to_vec(),
                 elems: Default::default(),
                 rows: Default::default(),
             }
@@ -242,7 +242,7 @@ fn main_0() -> i32 {
         let __a0 = 2_usize as usize;
         (*elems.borrow_mut())[1_usize]
             .coeffs
-            .resize_with(__a0, || <i16>::default())
+            .resize_with(__a0, || 0_i16)
     };
     vec_elem!(elems.decay().offset(1_usize), coeffs, 1_usize).write(4_i16);
     let __rhs = (((vec_elem!(elems.decay().offset(1_usize), coeffs, 1_usize).read()) as i32) + 1);
diff --git a/tests/unit/out/refcount/iterator_freshness.rs b/tests/unit/out/refcount/iterator_freshness.rs
index 6563d958bc..8c60dedf9b 100644
--- a/tests/unit/out/refcount/iterator_freshness.rs
+++ b/tests/unit/out/refcount/iterator_freshness.rs
@@ -15,9 +15,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let vec_: Value<Vec<i32>> = Rc::new(RefCell::new(
-        (0..(4_usize) as usize)
-            .map(|_| <i32>::default())
-            .collect::<Vec<_>>(),
+        (0..(4_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>(),
     ));
     let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(vec_.decay().begin()));
     ({ foo_0((*it.borrow()).clone()) });
diff --git a/tests/unit/out/refcount/kruskal.rs b/tests/unit/out/refcount/kruskal.rs
index 65ccc3f1a1..2b75044904 100644
--- a/tests/unit/out/refcount/kruskal.rs
+++ b/tests/unit/out/refcount/kruskal.rs
@@ -196,12 +196,12 @@ pub fn MSTKruskal_2(graph: Ptr<Graph>) -> f64 {
     let set: Value<DisjointSet> = Rc::new(RefCell::new(DisjointSet {
         rank: Some(Rc::new(RefCell::new(
             (0..(graph.with(|__s| __s.V) as usize))
-                .map(|_| <i32>::default())
+                .map(|_| 0_i32)
                 .collect::<Box<[_]>>(),
         ))),
         parent: Some(Rc::new(RefCell::new(
             (0..(graph.with(|__s| __s.V) as usize))
-                .map(|_| <i32>::default())
+                .map(|_| 0_i32)
                 .collect::<Box<[_]>>(),
         ))),
         n: graph.with(|__s| __s.V),
diff --git a/tests/unit/out/refcount/libc_struct_without_default.rs b/tests/unit/out/refcount/libc_struct_without_default.rs
index 857e439266..a95057a7f5 100644
--- a/tests/unit/out/refcount/libc_struct_without_default.rs
+++ b/tests/unit/out/refcount/libc_struct_without_default.rs
@@ -28,7 +28,7 @@ impl Default for UserDefined {
     fn default() -> Self {
         {
             UserDefined {
-                a: std::array::from_fn::<_, 1_usize, _>(|_| <i32>::default()).to_vec(),
+                a: std::array::from_fn::<_, 1_usize, _>(|_| 0_i32).to_vec(),
                 v: Default::default(),
             }
         }
diff --git a/tests/unit/out/refcount/matmul.rs b/tests/unit/out/refcount/matmul.rs
index 9d608c98d5..b3158f1695 100644
--- a/tests/unit/out/refcount/matmul.rs
+++ b/tests/unit/out/refcount/matmul.rs
@@ -12,9 +12,7 @@ pub fn matalloc_0(
     mut e: i32,
 ) -> Option<Value<Box<[Option<Value<Box<[i32]>>>]>>> {
     let mut m: Option<Value<Box<[Option<Value<Box<[i32]>>>]>>> = Some(Rc::new(RefCell::new(
-        (0..(n as usize))
-            .map(|_| <Option<Value<Box<[i32]>>>>::default())
-            .collect::<Box<[_]>>(),
+        (0..(n as usize)).map(|_| None).collect::<Box<[_]>>(),
     )));
     let mut i: i32 = 0;
     'loop_: while (i < n) {
@@ -22,9 +20,7 @@ pub fn matalloc_0(
             .offset((i as usize) as isize)
             .write(
                 Some(Rc::new(RefCell::new(
-                    (0..(p as usize))
-                        .map(|_| <i32>::default())
-                        .collect::<Box<[_]>>(),
+                    (0..(p as usize)).map(|_| 0_i32).collect::<Box<[_]>>(),
                 )))
                 .take(),
             );
diff --git a/tests/unit/out/refcount/pair.rs b/tests/unit/out/refcount/pair.rs
index 9c67534e93..4fd402bece 100644
--- a/tests/unit/out/refcount/pair.rs
+++ b/tests/unit/out/refcount/pair.rs
@@ -33,7 +33,12 @@ fn main_0() -> i32 {
     let mut n: u32 = 2_u32;
     let const_ptr_pairs: Value<Vec<(Value<Ptr<i32>>, Value<u64>)>> = Rc::new(RefCell::new(
         (0..(1_usize) as usize)
-            .map(|_| <(Value<Ptr<i32>>, Value<u64>)>::default())
+            .map(|_| {
+                (
+                    Rc::new(RefCell::new(Ptr::<i32>::null())),
+                    Rc::new(RefCell::new(0_u64)),
+                )
+            })
             .collect::<Vec<_>>(),
     ));
     (*const_ptr_pairs.borrow_mut())[0_usize] = (
diff --git a/tests/unit/out/refcount/swap_map_no_copy.rs b/tests/unit/out/refcount/swap_map_no_copy.rs
index c33027dba7..fb0ebe3fde 100644
--- a/tests/unit/out/refcount/swap_map_no_copy.rs
+++ b/tests/unit/out/refcount/swap_map_no_copy.rs
@@ -429,7 +429,7 @@ fn main_0() -> i32 {
     assert!((copies_0.with(|rc| *rc.borrow()) == 0));
     let grid: Value<Vec<Vec<Tracked>>> = Rc::new(RefCell::new(
         (0..(2_usize) as usize)
-            .map(|_| <Vec<Tracked>>::default())
+            .map(|_| Default::default())
             .collect::<Vec<_>>(),
     ));
     {
diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs
index 02202c9cd4..5d772e8fa8 100644
--- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs
+++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs
@@ -36,7 +36,7 @@ pub fn assign_1(mut c: bool, mut v: i32) -> i32 {
 pub fn lehmer_2(mut sigma: Ptr<u32>, mut len: u32, mut code: Ptr<u32>) {
     let items: Value<Vec<u32>> = Rc::new(RefCell::new(
         (0..(len as usize) as usize)
-            .map(|_| <u32>::default())
+            .map(|_| 0_u32)
             .collect::<Vec<_>>(),
     ));
     let mut i: u32 = 0_u32;
diff --git a/tests/unit/out/refcount/unique_ptr.rs b/tests/unit/out/refcount/unique_ptr.rs
index 499870569e..7aec3a283e 100644
--- a/tests/unit/out/refcount/unique_ptr.rs
+++ b/tests/unit/out/refcount/unique_ptr.rs
@@ -168,6 +168,29 @@ pub fn RndStuff_2() {
         i.prefix_inc();
     }
 }
+pub fn unique_ptr_that_wraps_container_3() {
+    let mut v: Option<Value<Box<[Vec<i8>]>>> = Some(Rc::new(RefCell::new(
+        (0..2_usize).map(|_| vec![0]).collect::<Box<[_]>>(),
+    )));
+    assert!(
+        (((*(v.as_pointer() as Ptr<Vec<i8>>)
+            .offset(0_usize as isize)
+            .upgrade()
+            .deref())
+        .len()
+            - 1)
+            == 0_usize)
+    );
+    assert!(
+        (((*(v.as_pointer() as Ptr<Vec<i8>>)
+            .offset(1_usize as isize)
+            .upgrade()
+            .deref())
+        .len()
+            - 1)
+            == 0_usize)
+    );
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -188,6 +211,7 @@ fn main_0() -> i32 {
     assert!((((*p.borrow()).as_pointer().read()) == 2));
     p.as_pointer().write(None);
     assert!((*p.borrow()).is_none());
+    ({ unique_ptr_that_wraps_container_3() });
     return 0;
 }
 pub trait PairImpl {
diff --git a/tests/unit/out/refcount/unique_ptr_vector_data.rs b/tests/unit/out/refcount/unique_ptr_vector_data.rs
index 7730194a98..b0f4540682 100644
--- a/tests/unit/out/refcount/unique_ptr_vector_data.rs
+++ b/tests/unit/out/refcount/unique_ptr_vector_data.rs
@@ -15,12 +15,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let v: Value<Option<Value<Vec<u8>>>> = Rc::new(RefCell::new(
-        Ptr::alloc(
-            (0..(3_usize) as usize)
-                .map(|_| <u8>::default())
-                .collect::<Vec<_>>(),
-        )
-        .to_owned_opt(),
+        Ptr::alloc((0..(3_usize) as usize).map(|_| 0_u8).collect::<Vec<_>>()).to_owned_opt(),
     ));
     let mut p: Ptr<u8> = (*v.borrow()).as_pointer().decay();
     elem!(p, 2).write(1_u8);
diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index c82a611bb8..5b09bb996c 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -31,7 +31,7 @@ fn main_0() -> i32 {
     let mut s1: usize = v1.len();
     {
         let __a0 = 100_usize as usize;
-        v1.resize_with(__a0, || <i32>::default())
+        v1.resize_with(__a0, || 0_i32)
     };
     assert!((v1.len() == 100_usize));
     assert!((v1[99_usize] == 0));
@@ -168,7 +168,7 @@ fn main_0() -> i32 {
     }
     let v4: Value<Vec<Ptr<i32>>> = Rc::new(RefCell::new(
         (0..(100_usize) as usize)
-            .map(|_| <Ptr<i32>>::default())
+            .map(|_| Ptr::<i32>::null())
             .collect::<Vec<_>>(),
     ));
     assert!(((*v4.borrow()).len() == 100_usize));
@@ -179,7 +179,7 @@ fn main_0() -> i32 {
     }
     let v5: Value<Vec<Ptr<i32>>> = Rc::new(RefCell::new(
         (0..(100_usize) as usize)
-            .map(|_| <Ptr<i32>>::default())
+            .map(|_| Ptr::<i32>::null())
             .collect::<Vec<_>>(),
     ));
     assert!(((*v5.borrow()).len() == 100_usize));
@@ -197,7 +197,12 @@ fn main_0() -> i32 {
     }
     let v7: Value<Vec<(Value<Ptr<i32>>, Value<i32>)>> = Rc::new(RefCell::new(
         (0..(200_usize) as usize)
-            .map(|_| <(Value<Ptr<i32>>, Value<i32>)>::default())
+            .map(|_| {
+                (
+                    Rc::new(RefCell::new(Ptr::<i32>::null())),
+                    Rc::new(RefCell::new(0_i32)),
+                )
+            })
             .collect::<Vec<_>>(),
     ));
     assert!(((*v7.borrow()).len() == 200_usize));
diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs
index 55f9fda557..3365aae2ab 100644
--- a/tests/unit/out/refcount/vector3.rs
+++ b/tests/unit/out/refcount/vector3.rs
@@ -14,17 +14,15 @@ fn main_0() -> i32 {
     let v: Value<Vec<Vec<i32>>> = Rc::new(RefCell::new(Vec::new()));
     {
         let __a0 = 2_usize as usize;
-        (*v.borrow_mut()).resize_with(__a0, || <Vec<i32>>::default())
+        (*v.borrow_mut()).resize_with(__a0, || Default::default())
     };
     {
         let __a0 = 2_usize as usize;
-        elem!(v.decay(), 0_usize)
-            .with_mut(|__v: &mut Vec<i32>| __v.resize_with(__a0, || <i32>::default()))
+        elem!(v.decay(), 0_usize).with_mut(|__v: &mut Vec<i32>| __v.resize_with(__a0, || 0_i32))
     };
     {
         let __a0 = 1_usize as usize;
-        elem!(v.decay(), 1_usize)
-            .with_mut(|__v: &mut Vec<i32>| __v.resize_with(__a0, || <i32>::default()))
+        elem!(v.decay(), 1_usize).with_mut(|__v: &mut Vec<i32>| __v.resize_with(__a0, || 0_i32))
     };
     index!(elem!(v.decay(), 0_usize), 0_usize).write(1);
     index!(elem!(v.decay(), 0_usize), 1_usize).write(5);
diff --git a/tests/unit/out/refcount/vector_subscript_borrow.rs b/tests/unit/out/refcount/vector_subscript_borrow.rs
index 47e3e46060..0031180e46 100644
--- a/tests/unit/out/refcount/vector_subscript_borrow.rs
+++ b/tests/unit/out/refcount/vector_subscript_borrow.rs
@@ -22,9 +22,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1; 4_usize as usize]));
-    let mut items: Vec<u32> = (0..(3_usize) as usize)
-        .map(|_| <u32>::default())
-        .collect::<Vec<_>>();
+    let mut items: Vec<u32> = (0..(3_usize) as usize).map(|_| 0_u32).collect::<Vec<_>>();
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < items.len()) {
         let __rhs = (i).wrapping_mul(2_u32);
diff --git a/tests/unit/out/refcount/vector_subscript_direct.rs b/tests/unit/out/refcount/vector_subscript_direct.rs
index dab514af73..01104ce71b 100644
--- a/tests/unit/out/refcount/vector_subscript_direct.rs
+++ b/tests/unit/out/refcount/vector_subscript_direct.rs
@@ -88,9 +88,7 @@ fn main_0() -> i32 {
     let h: Value<Holder> = Rc::new(RefCell::new(<Holder>::default()));
     {
         let __a0 = 2_usize as usize;
-        (*h.borrow_mut())
-            .values
-            .resize_with(__a0, || <i32>::default())
+        (*h.borrow_mut()).values.resize_with(__a0, || 0_i32)
     };
     vec_elem!(h.as_pointer(), values, 1_usize).write(6);
     {
diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs
index 7013328a0b..036cdef71a 100644
--- a/tests/unit/out/refcount/vector_with_allocator.rs
+++ b/tests/unit/out/refcount/vector_with_allocator.rs
@@ -72,7 +72,7 @@ fn main_0() -> i32 {
     let mut s1: usize = v1.len();
     {
         let __a0 = 100_usize as usize;
-        v1.resize_with(__a0, || <i32>::default())
+        v1.resize_with(__a0, || 0_i32)
     };
     assert!((v1.len() == 100_usize));
     assert!((v1[99_usize] == 0));
diff --git a/tests/unit/out/unsafe/08_unique_array.rs b/tests/unit/out/unsafe/08_unique_array.rs
index 37efd04173..a4a0dc146a 100644
--- a/tests/unit/out/unsafe/08_unique_array.rs
+++ b/tests/unit/out/unsafe/08_unique_array.rs
@@ -13,8 +13,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut g: Option<Box<[i32]>> =
-        Some((0..2_usize).map(|_| <i32>::default()).collect::<Box<[_]>>());
+    let mut g: Option<Box<[i32]>> = Some((0..2_usize).map(|_| 0_i32).collect::<Box<[_]>>());
     (*g.as_deref()
         .map_or(::std::ptr::null_mut(), |s| s.as_ptr() as *mut i32)
         .add(0_usize)) = 11;
diff --git a/tests/unit/out/unsafe/12_test.rs b/tests/unit/out/unsafe/12_test.rs
index 9b3a0bebff..8b0a6db1b4 100644
--- a/tests/unit/out/unsafe/12_test.rs
+++ b/tests/unit/out/unsafe/12_test.rs
@@ -15,9 +15,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut v: Vec<Vec<i32>> = Vec::new();
     {
-        let __a1 = (0..(10_usize) as usize)
-            .map(|_| <i32>::default())
-            .collect::<Vec<_>>();
+        let __a1 = (0..(10_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>();
         v.push(__a1)
     };
     return 0;
diff --git a/tests/unit/out/unsafe/alloc_array.rs b/tests/unit/out/unsafe/alloc_array.rs
index 2e969ff6e5..7471dfd2e9 100644
--- a/tests/unit/out/unsafe/alloc_array.rs
+++ b/tests/unit/out/unsafe/alloc_array.rs
@@ -7,11 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn All_0(arr: *mut Option<Box<[i32]>>, mut N: i32, mut element: i32) {
-    let mut all: Option<Box<[i32]>> = Some(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
-    );
+    let mut all: Option<Box<[i32]>> = Some((0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>());
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         (*all
@@ -41,11 +37,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let N: i32 = 10;
-    let mut arr: Option<Box<[i32]>> = Some(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
-    );
+    let mut arr: Option<Box<[i32]>> = Some((0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>());
     (unsafe { All_0(&mut arr, N, 1) });
     assert!(((unsafe { Consume_1(arr.take(), N,) }) == (10)));
     return 0;
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index f3c309c015..0d1cc1429a 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -125,9 +125,7 @@ unsafe fn main_0() -> i32 {
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         {
-            let __a1 = (0..(10_usize) as usize)
-                .map(|_| <i32>::default())
-                .collect::<Vec<_>>();
+            let __a1 = (0..(10_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>();
             m1.push(__a1)
         };
         i.prefix_inc();
@@ -195,7 +193,7 @@ unsafe fn main_0() -> i32 {
     assert!(((pair1.1) == (2)));
     let mut pair3: (Vec<i32>, i32) = (
         (0..(0_usize) as usize)
-            .map(|_| <i32>::default())
+            .map(|_| 0_i32)
             .collect::<Vec<_>>()
             .into(),
         0.into(),
diff --git a/tests/unit/out/unsafe/deref_call_subscript.rs b/tests/unit/out/unsafe/deref_call_subscript.rs
index 97dd8705f8..3cef379d05 100644
--- a/tests/unit/out/unsafe/deref_call_subscript.rs
+++ b/tests/unit/out/unsafe/deref_call_subscript.rs
@@ -7,9 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut g_0: std::cell::LazyCell<Vec<u8>> = std::cell::LazyCell::new(|| unsafe {
-    (0..(3_usize) as usize)
-        .map(|_| <u8>::default())
-        .collect::<Vec<_>>()
+    (0..(3_usize) as usize).map(|_| 0_u8).collect::<Vec<_>>()
 });
 pub unsafe fn get_1() -> *mut Vec<u8> {
     return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut g_0));
@@ -24,9 +22,7 @@ unsafe fn main_0() -> i32 {
     (&mut (*(unsafe { get_1() })))[(1_usize)] = 4_u8;
     let mut v: Option<Box<Vec<u8>>> = Some(Box::from_raw(
         (Box::leak(Box::new(
-            (0..(3_usize) as usize)
-                .map(|_| <u8>::default())
-                .collect::<Vec<_>>(),
+            (0..(3_usize) as usize).map(|_| 0_u8).collect::<Vec<_>>(),
         )) as *mut Vec<u8>),
     ));
     (&mut (*v.as_deref().map_or(::std::ptr::null_mut(), |v| {
diff --git a/tests/unit/out/unsafe/empty_array_init.rs b/tests/unit/out/unsafe/empty_array_init.rs
index 3f484a149f..f136eacfbb 100644
--- a/tests/unit/out/unsafe/empty_array_init.rs
+++ b/tests/unit/out/unsafe/empty_array_init.rs
@@ -13,7 +13,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut vec_: Vec<i32> = std::array::from_fn::<_, 3_usize, _>(|_| <i32>::default()).to_vec();
+    let mut vec_: Vec<i32> = std::array::from_fn::<_, 3_usize, _>(|_| 0_i32).to_vec();
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fft.rs b/tests/unit/out/unsafe/fft.rs
index 6c7b71ce47..ed6152ab29 100644
--- a/tests/unit/out/unsafe/fft.rs
+++ b/tests/unit/out/unsafe/fft.rs
@@ -199,16 +199,9 @@ unsafe fn main_0() -> i32 {
         i.postfix_inc();
     }
     let mut b: Option<Box<[Complex]>> = (unsafe { fft_3(&mut a, N) });
-    let mut reals: Option<Box<[i32]>> = Some(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
-    );
-    let mut imgs: Option<Box<[i32]>> = Some(
-        (0..(N as usize))
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
-    );
+    let mut reals: Option<Box<[i32]>> =
+        Some((0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>());
+    let mut imgs: Option<Box<[i32]>> = Some((0..(N as usize)).map(|_| 0_i32).collect::<Box<[_]>>());
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         (*reals
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index 865734fbc0..cae71fccc7 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -251,7 +251,7 @@ pub unsafe fn AllocMinHeap_1(mut capacity: i32) -> Option<Box<MinHeap>> {
         capacity: capacity,
         arr: Some(
             (0..(capacity as usize))
-                .map(|_| <*mut MinHeapNode>::default())
+                .map(|_| std::ptr::null_mut())
                 .collect::<Box<[_]>>(),
         ),
         next: 0,
@@ -422,16 +422,8 @@ pub unsafe fn HuffmanCodes_5(
             })),
         )
     });
-    let mut arr: Option<Box<[i32]>> = Some(
-        (0..100_usize)
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
-    );
-    let mut out: Option<Box<[i32]>> = Some(
-        (0..100_usize)
-            .map(|_| <i32>::default())
-            .collect::<Box<[_]>>(),
-    );
+    let mut arr: Option<Box<[i32]>> = Some((0..100_usize).map(|_| 0_i32).collect::<Box<[_]>>());
+    let mut out: Option<Box<[i32]>> = Some((0..100_usize).map(|_| 0_i32).collect::<Box<[_]>>());
     let mut top: i32 = 0;
     let mut next: i32 = 0;
     (unsafe { CollectCodes_4(root, &mut arr, top, &mut out, &mut next) });
@@ -456,14 +448,11 @@ unsafe fn main_0() -> i32 {
     let mut arr2: [i32; 6] = [5, 9, 12, 13, 16, 45];
     let mut data: Option<Box<[libc::c_char]>> = Some(
         (0..(size as usize))
-            .map(|_| <libc::c_char>::default())
-            .collect::<Box<[_]>>(),
-    );
-    let mut freq: Option<Box<[i32]>> = Some(
-        (0..(size as usize))
-            .map(|_| <i32>::default())
+            .map(|_| (0 as libc::c_char))
             .collect::<Box<[_]>>(),
     );
+    let mut freq: Option<Box<[i32]>> =
+        Some((0..(size as usize)).map(|_| 0_i32).collect::<Box<[_]>>());
     let mut i: i32 = 0;
     'loop_: while ((i) < (size)) {
         (*data
diff --git a/tests/unit/out/unsafe/inline_container_fields.rs b/tests/unit/out/unsafe/inline_container_fields.rs
index 7df6b7d7f0..afedecc9b6 100644
--- a/tests/unit/out/unsafe/inline_container_fields.rs
+++ b/tests/unit/out/unsafe/inline_container_fields.rs
@@ -84,7 +84,7 @@ impl Default for State {
             State {
                 count: 0_i32,
                 grid: [[0_i32; 3]; 2],
-                arr: std::array::from_fn::<_, 3_usize, _>(|_| <i32>::default()).to_vec(),
+                arr: std::array::from_fn::<_, 3_usize, _>(|_| 0_i32).to_vec(),
                 elems: Default::default(),
                 rows: Default::default(),
             }
@@ -198,9 +198,7 @@ unsafe fn main_0() -> i32 {
     let mut first: *mut Elem = (&mut elems[(0_usize)] as *mut Elem);
     {
         let __a0 = 2_usize as usize;
-        elems[(1_usize)]
-            .coeffs
-            .resize_with(__a0, || <i16>::default())
+        elems[(1_usize)].coeffs.resize_with(__a0, || 0_i16)
     };
     elems[(1_usize)].coeffs[(1_usize)] = 4_i16;
     elems[(1_usize)].hist[(2) as usize] = ((elems[(1_usize)].coeffs[(1_usize)] as i32) + (1));
diff --git a/tests/unit/out/unsafe/iterator_freshness.rs b/tests/unit/out/unsafe/iterator_freshness.rs
index 1c1756e6a0..09d4910845 100644
--- a/tests/unit/out/unsafe/iterator_freshness.rs
+++ b/tests/unit/out/unsafe/iterator_freshness.rs
@@ -14,9 +14,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut vec_: Vec<i32> = (0..(4_usize) as usize)
-        .map(|_| <i32>::default())
-        .collect::<Vec<_>>();
+    let mut vec_: Vec<i32> = (0..(4_usize) as usize).map(|_| 0_i32).collect::<Vec<_>>();
     let mut it: UnsafeRandomAccessIterator<i32> = vec_.begin();
     (unsafe { foo_0((it).clone()) });
     return 0;
diff --git a/tests/unit/out/unsafe/kruskal.rs b/tests/unit/out/unsafe/kruskal.rs
index d8540ca8f9..08fe65ade1 100644
--- a/tests/unit/out/unsafe/kruskal.rs
+++ b/tests/unit/out/unsafe/kruskal.rs
@@ -328,12 +328,12 @@ pub unsafe fn MSTKruskal_2(graph: *mut Graph) -> f64 {
     let mut set: DisjointSet = DisjointSet {
         rank: Some(
             (0..((*graph).V as usize))
-                .map(|_| <i32>::default())
+                .map(|_| 0_i32)
                 .collect::<Box<[_]>>(),
         ),
         parent: Some(
             (0..((*graph).V as usize))
-                .map(|_| <i32>::default())
+                .map(|_| 0_i32)
                 .collect::<Box<[_]>>(),
         ),
         n: (*graph).V,
diff --git a/tests/unit/out/unsafe/libc_struct_without_default.rs b/tests/unit/out/unsafe/libc_struct_without_default.rs
index 2b7633b8e5..4ee4b2894a 100644
--- a/tests/unit/out/unsafe/libc_struct_without_default.rs
+++ b/tests/unit/out/unsafe/libc_struct_without_default.rs
@@ -30,7 +30,7 @@ impl Default for UserDefined {
     fn default() -> Self {
         unsafe {
             UserDefined {
-                a: std::array::from_fn::<_, 1_usize, _>(|_| <i32>::default()).to_vec(),
+                a: std::array::from_fn::<_, 1_usize, _>(|_| 0_i32).to_vec(),
                 v: Default::default(),
             }
         }
diff --git a/tests/unit/out/unsafe/matmul.rs b/tests/unit/out/unsafe/matmul.rs
index c8b1b503f8..dec2df0d85 100644
--- a/tests/unit/out/unsafe/matmul.rs
+++ b/tests/unit/out/unsafe/matmul.rs
@@ -7,23 +7,16 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn matalloc_0(mut n: i32, mut p: i32, mut e: i32) -> Option<Box<[Option<Box<[i32]>>]>> {
-    let mut m: Option<Box<[Option<Box<[i32]>>]>> = Some(
-        (0..(n as usize))
-            .map(|_| <Option<Box<[i32]>>>::default())
-            .collect::<Box<[_]>>(),
-    );
+    let mut m: Option<Box<[Option<Box<[i32]>>]>> =
+        Some((0..(n as usize)).map(|_| None).collect::<Box<[_]>>());
     let mut i: i32 = 0;
     'loop_: while ((i) < (n)) {
         (*m.as_deref()
             .map_or(::std::ptr::null_mut(), |s| {
                 s.as_ptr() as *mut Option<Box<[i32]>>
             })
-            .add((i as usize))) = Some(
-            (0..(p as usize))
-                .map(|_| <i32>::default())
-                .collect::<Box<[_]>>(),
-        )
-        .take();
+            .add((i as usize))) =
+            Some((0..(p as usize)).map(|_| 0_i32).collect::<Box<[_]>>()).take();
         let mut j: i32 = 0;
         'loop_: while ((j) < (p)) {
             (*(*m
diff --git a/tests/unit/out/unsafe/swap_map_no_copy.rs b/tests/unit/out/unsafe/swap_map_no_copy.rs
index 09761b411c..4f975df24f 100644
--- a/tests/unit/out/unsafe/swap_map_no_copy.rs
+++ b/tests/unit/out/unsafe/swap_map_no_copy.rs
@@ -439,7 +439,7 @@ unsafe fn main_0() -> i32 {
     assert!(((arrays.a[(0) as usize].v) == (0)) && ((arrays.a[(1) as usize].v) == (2)));
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (0)));
     let mut grid: Vec<Vec<Tracked>> = (0..(2_usize) as usize)
-        .map(|_| <Vec<Tracked>>::default())
+        .map(|_| Default::default())
         .collect::<Vec<_>>();
     {
         let __init = Tracked::new_2({ 1 });
diff --git a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
index 57f78effc5..2f23d54494 100644
--- a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
+++ b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
@@ -34,7 +34,7 @@ pub unsafe fn assign_1(mut c: bool, mut v: i32) -> i32 {
 }
 pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32) {
     let mut items: Vec<u32> = (0..(len as usize) as usize)
-        .map(|_| <u32>::default())
+        .map(|_| 0_u32)
         .collect::<Vec<_>>();
     let mut i: u32 = 0_u32;
     'loop_: while ((i) < (len)) {
diff --git a/tests/unit/out/unsafe/unique_ptr.rs b/tests/unit/out/unsafe/unique_ptr.rs
index ba1ad8165e..ecf05f2740 100644
--- a/tests/unit/out/unsafe/unique_ptr.rs
+++ b/tests/unit/out/unsafe/unique_ptr.rs
@@ -234,6 +234,30 @@ pub unsafe fn RndStuff_2() {
         i.prefix_inc();
     }
 }
+pub unsafe fn unique_ptr_that_wraps_container_3() {
+    let mut v: Option<Box<[Vec<libc::c_char>]>> =
+        Some((0..2_usize).map(|_| vec![0]).collect::<Box<[_]>>());
+    assert!(
+        (((*v
+            .as_deref()
+            .map_or(::std::ptr::null_mut(), |s| s.as_ptr()
+                as *mut Vec<libc::c_char>)
+            .add(0_usize))
+        .len()
+            - 1)
+            == (0_usize))
+    );
+    assert!(
+        (((*v
+            .as_deref()
+            .map_or(::std::ptr::null_mut(), |s| s.as_ptr()
+                as *mut Vec<libc::c_char>)
+            .add(1_usize))
+        .len()
+            - 1)
+            == (0_usize))
+    );
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -261,6 +285,7 @@ unsafe fn main_0() -> i32 {
     );
     p = None;
     assert!(p.is_none());
+    (unsafe { unique_ptr_that_wraps_container_3() });
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_vector_data.rs b/tests/unit/out/unsafe/unique_ptr_vector_data.rs
index 9857992279..bcfc1ac509 100644
--- a/tests/unit/out/unsafe/unique_ptr_vector_data.rs
+++ b/tests/unit/out/unsafe/unique_ptr_vector_data.rs
@@ -21,9 +21,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut v: Option<Box<Vec<u8>>> = Some(Box::from_raw(
         (Box::leak(Box::new(
-            (0..(3_usize) as usize)
-                .map(|_| <u8>::default())
-                .collect::<Vec<_>>(),
+            (0..(3_usize) as usize).map(|_| 0_u8).collect::<Vec<_>>(),
         )) as *mut Vec<u8>),
     ));
     let mut p: *mut u8 = (*v.as_deref().map_or(::std::ptr::null_mut(), |v| {
diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs
index 1d83cd95ec..dda5d6abd5 100644
--- a/tests/unit/out/unsafe/vector.rs
+++ b/tests/unit/out/unsafe/vector.rs
@@ -32,7 +32,7 @@ unsafe fn main_0() -> i32 {
     let mut s1: usize = v1.len();
     {
         let __a0 = 100_usize as usize;
-        v1.resize_with(__a0, || <i32>::default())
+        v1.resize_with(__a0, || 0_i32)
     };
     assert!(((v1.len()) == (100_usize)));
     assert!(((v1[(99_usize)]) == (0)));
@@ -166,7 +166,7 @@ unsafe fn main_0() -> i32 {
         i.prefix_inc();
     }
     let mut v4: Vec<*mut i32> = (0..(100_usize) as usize)
-        .map(|_| <*mut i32>::default())
+        .map(|_| std::ptr::null_mut())
         .collect::<Vec<_>>();
     assert!(((v4.len()) == (100_usize)));
     let mut i: u32 = 0_u32;
@@ -175,7 +175,7 @@ unsafe fn main_0() -> i32 {
         i.prefix_inc();
     }
     let mut v5: Vec<*const i32> = (0..(100_usize) as usize)
-        .map(|_| <*const i32>::default())
+        .map(|_| std::ptr::null())
         .collect::<Vec<_>>();
     assert!(((v5.len()) == (100_usize)));
     let mut i: u32 = 0_u32;
diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs
index 4b58764140..269f0addf5 100644
--- a/tests/unit/out/unsafe/vector3.rs
+++ b/tests/unit/out/unsafe/vector3.rs
@@ -16,15 +16,15 @@ unsafe fn main_0() -> i32 {
     let mut v: Vec<Vec<i32>> = Vec::new();
     {
         let __a0 = 2_usize as usize;
-        v.resize_with(__a0, || <Vec<i32>>::default())
+        v.resize_with(__a0, || Default::default())
     };
     {
         let __a0 = 2_usize as usize;
-        v[(0_usize)].resize_with(__a0, || <i32>::default())
+        v[(0_usize)].resize_with(__a0, || 0_i32)
     };
     {
         let __a0 = 1_usize as usize;
-        v[(1_usize)].resize_with(__a0, || <i32>::default())
+        v[(1_usize)].resize_with(__a0, || 0_i32)
     };
     v[(0_usize)][(0_usize)] = 1;
     v[(0_usize)][(1_usize)] = 5;
diff --git a/tests/unit/out/unsafe/vector_subscript_borrow.rs b/tests/unit/out/unsafe/vector_subscript_borrow.rs
index c5c8f26258..91edc48d08 100644
--- a/tests/unit/out/unsafe/vector_subscript_borrow.rs
+++ b/tests/unit/out/unsafe/vector_subscript_borrow.rs
@@ -19,9 +19,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1; 4_usize as usize];
-    let mut items: Vec<u32> = (0..(3_usize) as usize)
-        .map(|_| <u32>::default())
-        .collect::<Vec<_>>();
+    let mut items: Vec<u32> = (0..(3_usize) as usize).map(|_| 0_u32).collect::<Vec<_>>();
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (items.len())) {
         items[(i as usize)] = (i).wrapping_mul(2_u32);
diff --git a/tests/unit/out/unsafe/vector_subscript_direct.rs b/tests/unit/out/unsafe/vector_subscript_direct.rs
index bb46b0205b..4cee7f1fdf 100644
--- a/tests/unit/out/unsafe/vector_subscript_direct.rs
+++ b/tests/unit/out/unsafe/vector_subscript_direct.rs
@@ -96,7 +96,7 @@ unsafe fn main_0() -> i32 {
     let mut h: Holder = <Holder>::default();
     {
         let __a0 = 2_usize as usize;
-        h.values.resize_with(__a0, || <i32>::default())
+        h.values.resize_with(__a0, || 0_i32)
     };
     h.values[(1_usize)] = 6;
     {
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index 85b2f967b8..ce6fdf1c3e 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -107,7 +107,7 @@ unsafe fn main_0() -> i32 {
     let mut s1: usize = v1.len();
     {
         let __a0 = 100_usize as usize;
-        v1.resize_with(__a0, || <i32>::default())
+        v1.resize_with(__a0, || 0_i32)
     };
     assert!(((v1.len()) == (100_usize)));
     assert!(((v1[(99_usize)]) == (0)));
diff --git a/tests/unit/unique_ptr.cpp b/tests/unit/unique_ptr.cpp
index 92c15cad51..e62aec2ccc 100644
--- a/tests/unit/unique_ptr.cpp
+++ b/tests/unit/unique_ptr.cpp
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <memory>
+#include <string>
 
 struct SafePointer {
   std::unique_ptr<int> ptr;
@@ -79,6 +80,12 @@ void RndStuff() {
   }
 }
 
+void unique_ptr_that_wraps_container() {
+  auto v = std::make_unique<std::string[]>(2);
+  assert(v[0].size() == 0);
+  assert(v[1].size() == 0);
+}
+
 int main() {
   std::unique_ptr<int> x = std::make_unique<int>(0);
   std::unique_ptr<SafePointer> safe_ptr =
@@ -91,5 +98,8 @@ int main() {
   assert(*p == 2);
   p.reset();
   assert(p == nullptr);
+
+  unique_ptr_that_wraps_container();
+
   return 0;
 }