diff --git a/toolchain/check/context.h b/toolchain/check/context.h
index 73902694293a..248736e36a93 100644
--- a/toolchain/check/context.h
+++ b/toolchain/check/context.h
@@ -320,10 +320,10 @@ class Context {
   // TODO: consider moving this out of Context.
   struct FormExpr {
     static const FormExpr Error;
+    static const FormExpr None;
 
-    // The inst ID of the form expression itself. This is always a form inst,
-    // such as InitForm or RefForm.
-    // TODO: Consider creating an AnyForm inst category to refer to those insts.
+    // The inst ID of the form expression itself. This is always an inst in the
+    // AnyPrimitiveForm category.
     SemIR::InstId form_inst_id;
     // The inst ID of the form expression's type component.
     SemIR::TypeInstId type_component_inst_id;
@@ -630,6 +630,11 @@ inline constexpr Context::FormExpr Context::FormExpr::Error = {
     .type_component_inst_id = SemIR::ErrorInst::TypeInstId,
     .type_component_id = SemIR::ErrorInst::TypeId};
 
+inline constexpr Context::FormExpr Context::FormExpr::None = {
+    .form_inst_id = SemIR::InstId::None,
+    .type_component_inst_id = SemIR::TypeInstId::None,
+    .type_component_id = SemIR::TypeId::None};
+
 }  // namespace Carbon::Check
 
 #endif  // CARBON_TOOLCHAIN_CHECK_CONTEXT_H_
diff --git a/toolchain/check/cpp/export.cpp b/toolchain/check/cpp/export.cpp
index cffce8ade0ad..5bc9a68b901a 100644
--- a/toolchain/check/cpp/export.cpp
+++ b/toolchain/check/cpp/export.cpp
@@ -1294,6 +1294,8 @@ static auto BuildCarbonToCarbonThunk(Context& context, SemIR::LocId loc_id,
                 thunk_param_type_ids.end());
   }
 
+  llvm::SmallVector<ParamPatternKind> thunk_param_kinds(
+      thunk_param_type_ids.size(), ParamPatternKind::Ref);
   auto carbon_thunk_function_id =
       MakeGeneratedFunctionDecl(
           context, loc_id,
@@ -1301,7 +1303,7 @@ static auto BuildCarbonToCarbonThunk(Context& context, SemIR::LocId loc_id,
            .name_id = thunk_name_id,
            .self_type_id = target.GetSelfTypeId(),
            .param_type_ids = thunk_param_type_ids,
-           .param_kind = ParamPatternKind::Ref})
+           .param_kinds = thunk_param_kinds})
           .second;
 
   BuildThunkDefinitionForExport(
diff --git a/toolchain/check/cpp/operators.cpp b/toolchain/check/cpp/operators.cpp
index d2ed90610de1..7cf2eabf5269 100644
--- a/toolchain/check/cpp/operators.cpp
+++ b/toolchain/check/cpp/operators.cpp
@@ -271,8 +271,9 @@ static auto MakeCppStdInitializerListMake(Context& context, SemIR::LocId loc_id,
                                 {.parent_scope_id = init_list_class.scope_id,
                                  .name_id = init_list_class.name_id,
                                  .param_type_ids = {array_type_id},
-                                 .param_kind = ParamPatternKind::Value,
-                                 .return_type_id = init_list_type_id});
+                                 .param_kinds = {ParamPatternKind::Value},
+                                 .return_form = ReturnExprAsForm(
+                                     context, loc_id, init_list_type_inst_id)});
 
   auto& function = context.functions().Get(function_id);
   CARBON_CHECK(IsValidBuiltinDeclaration(
diff --git a/toolchain/check/custom_witness.cpp b/toolchain/check/custom_witness.cpp
index 6066c51a1da1..07fee6a37af3 100644
--- a/toolchain/check/custom_witness.cpp
+++ b/toolchain/check/custom_witness.cpp
@@ -6,6 +6,7 @@
 
 #include "llvm/ADT/APFloat.h"
 #include "toolchain/base/kind_switch.h"
+#include "toolchain/check/convert.h"
 #include "toolchain/check/eval.h"
 #include "toolchain/check/facet_type.h"
 #include "toolchain/check/function.h"
@@ -56,15 +57,19 @@ auto MakeBuiltinOperatorFunction(Context& context,
   auto self_type_id = param_types.front();
   auto name_id = context.core_identifiers().AddNameId(op_name);
 
-  auto [decl_id, function_id] =
-      MakeGeneratedFunctionDecl(context, SemIR::LocId::None,
-                                {.parent_scope_id = parent_scope_id,
-                                 .name_id = name_id,
-                                 .self_type_id = self_type_id,
-                                 .self_kind = ParamPatternKind::Value,
-                                 .param_type_ids = param_types.drop_front(),
-                                 .param_kind = ParamPatternKind::Value,
-                                 .return_type_id = return_type_id});
+  llvm::SmallVector<ParamPatternKind> param_kinds(param_types.size() - 1,
+                                                  ParamPatternKind::Value);
+  auto [decl_id, function_id] = MakeGeneratedFunctionDecl(
+      context, SemIR::LocId::None,
+      {.parent_scope_id = parent_scope_id,
+       .name_id = name_id,
+       .self_type_id = self_type_id,
+       .self_kind = ParamPatternKind::Value,
+       .param_type_ids = param_types.drop_front(),
+       .param_kinds = param_kinds,
+       .return_form =
+           ReturnExprAsForm(context, SemIR::LocId::None,
+                            context.types().GetTypeInstId(return_type_id))});
 
   auto& function = context.functions().Get(function_id);
   function.SetCoreWitness(builtin_kind);
diff --git a/toolchain/check/function.cpp b/toolchain/check/function.cpp
index e5cd6438206e..84ce627f00e6 100644
--- a/toolchain/check/function.cpp
+++ b/toolchain/check/function.cpp
@@ -126,24 +126,23 @@ static auto MakeFunctionSignature(Context& context, SemIR::LocId loc_id,
           args.self_type_id, args.self_kind);
       param_patterns.push_back(insts.self_param_id);
     }
-    for (auto param_type_id : args.param_type_ids) {
+    for (auto [param_type_id, param_kind] :
+         llvm::zip_equal(args.param_type_ids, args.param_kinds)) {
       auto param_type_region_id = MakeEmptyRegion(
           context, context.types().GetTypeInstId(param_type_id));
-      param_patterns.push_back(AddParamPattern(
-          context, loc_id, SemIR::NameId::Underscore, param_type_region_id,
-          param_type_id, args.param_kind));
+      param_patterns.push_back(
+          AddParamPattern(context, loc_id, SemIR::NameId::Underscore,
+                          param_type_region_id, param_type_id, param_kind));
     }
     insts.param_patterns_id = context.inst_blocks().Add(param_patterns);
   }
   context.full_pattern_stack().EndExplicitParamList();
 
-  // Build and add the return type. We always use an initializing form for now.
-  if (args.return_type_id.has_value()) {
-    auto return_form = ReturnExprAsForm(
-        context, loc_id, context.types().GetTypeInstId(args.return_type_id));
-    insts.return_type_inst_id = return_form.type_component_inst_id;
-    insts.return_form_inst_id = return_form.form_inst_id;
-    insts.return_pattern_id = AddReturnPattern(context, loc_id, return_form);
+  if (args.return_form.form_inst_id.has_value()) {
+    insts.return_type_inst_id = args.return_form.type_component_inst_id;
+    insts.return_form_inst_id = args.return_form.form_inst_id;
+    insts.return_pattern_id =
+        AddReturnPattern(context, loc_id, args.return_form);
   }
 
   auto match_results =
diff --git a/toolchain/check/function.h b/toolchain/check/function.h
index 7e8385c560eb..080c012a34a3 100644
--- a/toolchain/check/function.h
+++ b/toolchain/check/function.h
@@ -44,10 +44,10 @@ struct FunctionDeclArgs {
   ParamPatternKind self_kind = ParamPatternKind::Ref;
   // The types of the explicit parameters.
   llvm::ArrayRef<SemIR::TypeId> param_type_ids = {};
-  // The kind of the parameters described by `param_type_ids`.
-  ParamPatternKind param_kind = ParamPatternKind::Value;
-  // The return type, or `None` if the function doesn't declare a return type.
-  SemIR::TypeId return_type_id = SemIR::TypeId::None;
+  // The kinds of the parameters described by `param_type_ids`.
+  llvm::ArrayRef<ParamPatternKind> param_kinds = {};
+  // The return form, or `None` if the function doesn't declare a return form.
+  Context::FormExpr return_form = Context::FormExpr::None;
 };
 
 // Generates and returns a function declaration. The caller should update the
diff --git a/toolchain/check/testdata/interop/cpp/enum/copy.carbon b/toolchain/check/testdata/interop/cpp/enum/copy.carbon
index 44e3ed4abf94..475e033dc5a6 100644
--- a/toolchain/check/testdata/interop/cpp/enum/copy.carbon
+++ b/toolchain/check/testdata/interop/cpp/enum/copy.carbon
@@ -73,6 +73,7 @@ fn F() {
 // CHECK:STDOUT:   %Cpp.ref.loc8_21: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
 // CHECK:STDOUT:   %Enum.ref.loc8_24: type = name_ref Enum, imports.%Enum.decl [concrete = constants.%Enum]
 // CHECK:STDOUT:   %a.ref.loc8: %Enum = name_ref a, imports.%int_0 [concrete = constants.%int_0]
+// CHECK:STDOUT:   <elided>
 // CHECK:STDOUT:   %impl.elem0.loc8: %.1e6 = impl_witness_access constants.%custom_witness.d0d, element0 [concrete = constants.%Enum.Op]
 // CHECK:STDOUT:   %bound_method.loc8: <bound method> = bound_method %a.ref.loc8, %impl.elem0.loc8 [concrete = constants.%Enum.Op.bound.ff6]
 // CHECK:STDOUT:   %Enum.Op.call.loc8: init %Enum = call %bound_method.loc8(%a.ref.loc8) [concrete = constants.%int_0]
diff --git a/toolchain/check/testdata/interop/cpp/stdlib/initializer_list.carbon b/toolchain/check/testdata/interop/cpp/stdlib/initializer_list.carbon
index c662a55db9f1..d158c8018c0c 100644
--- a/toolchain/check/testdata/interop/cpp/stdlib/initializer_list.carbon
+++ b/toolchain/check/testdata/interop/cpp/stdlib/initializer_list.carbon
@@ -70,10 +70,10 @@ fn F() {
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (Core.IntLiteral, Core.IntLiteral, Core.IntLiteral) [concrete]
 // CHECK:STDOUT:   %tuple: %tuple.type = tuple_value (%int_1.5b8, %int_2.ecc, %int_3.1ba) [concrete]
 // CHECK:STDOUT:   %array_type: type = array_type %int_3.1ba, %i32 [concrete]
+// CHECK:STDOUT:   %.0ee: Core.Form = init_form %initializer_list [concrete]
 // CHECK:STDOUT:   %pattern_type.771: type = pattern_type %array_type [concrete]
 // CHECK:STDOUT:   %_.param_patt: %pattern_type.771 = value_param_pattern [concrete]
 // CHECK:STDOUT:   %_.patt.03c: %pattern_type.771 = wrapper_binding_pattern _, %_.param_patt [concrete]
-// CHECK:STDOUT:   %.0ee: Core.Form = init_form %initializer_list [concrete]
 // CHECK:STDOUT:   %return.param_patt.199: %pattern_type.7fc = out_param_pattern [concrete]
 // CHECK:STDOUT:   %return.patt.07e: %pattern_type.7fc = return_slot_pattern %return.param_patt.199, %initializer_list [concrete]
 // CHECK:STDOUT:   %initializer_list.initializer_list.type.0fbcd7.1: type = fn_type @initializer_list.initializer_list.loc8 [concrete]
@@ -137,6 +137,7 @@ fn F() {
 // CHECK:STDOUT:     import Cpp//...
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %initializer_list.template: %initializer_list.type = struct_value () [concrete = constants.%initializer_list.template]
+// CHECK:STDOUT:   %initializer_list.decl: type = class_decl @initializer_list [concrete = constants.%initializer_list] {} {}
 // CHECK:STDOUT:   %Core.import_ref.edf: @Core.IntLiteral.as.ImplicitAs.impl.0e9.%Core.IntLiteral.as.ImplicitAs.impl.Convert.type (%Core.IntLiteral.as.ImplicitAs.impl.Convert.type.e74) = import_ref Core//prelude/types/int, loc{{\d+_\d+}}, loaded [symbolic = @Core.IntLiteral.as.ImplicitAs.impl.0e9.%Core.IntLiteral.as.ImplicitAs.impl.Convert (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.845)]
 // CHECK:STDOUT:   %ImplicitAs.impl_witness_table.1aa = impl_witness_table (%Core.import_ref.edf), @Core.IntLiteral.as.ImplicitAs.impl.0e9 [concrete]
 // CHECK:STDOUT:   %Consume.cpp_overload_set.value: %Consume.cpp_overload_set.type = cpp_overload_set_value @Consume.cpp_overload_set [concrete = constants.%Consume.cpp_overload_set.value]
@@ -158,9 +159,8 @@ fn F() {
 // CHECK:STDOUT:     %_.param_patt: %pattern_type.771 = value_param_pattern [concrete = constants.%_.param_patt]
 // CHECK:STDOUT:     %_.patt: %pattern_type.771 = wrapper_binding_pattern _, %_.param_patt [concrete = constants.%_.patt.03c]
 // CHECK:STDOUT:     %return.param_patt: %pattern_type.7fc = out_param_pattern [concrete = constants.%return.param_patt.199]
-// CHECK:STDOUT:     %return.patt: %pattern_type.7fc = return_slot_pattern %return.param_patt, constants.%initializer_list [concrete = constants.%return.patt.07e]
+// CHECK:STDOUT:     %return.patt: %pattern_type.7fc = return_slot_pattern %return.param_patt, imports.%initializer_list.decl [concrete = constants.%return.patt.07e]
 // CHECK:STDOUT:   } {
-// CHECK:STDOUT:     %.loc8: Core.Form = init_form constants.%initializer_list [concrete = constants.%.0ee]
 // CHECK:STDOUT:     %_.param: %array_type = value_param call_param0
 // CHECK:STDOUT:     %_: %array_type = wrapper_binding _, %_.param
 // CHECK:STDOUT:     %return.param: ref %initializer_list = out_param call_param1
@@ -170,9 +170,8 @@ fn F() {
 // CHECK:STDOUT:     %_.param_patt: %pattern_type.771 = value_param_pattern [concrete = constants.%_.param_patt]
 // CHECK:STDOUT:     %_.patt: %pattern_type.771 = wrapper_binding_pattern _, %_.param_patt [concrete = constants.%_.patt.03c]
 // CHECK:STDOUT:     %return.param_patt: %pattern_type.7fc = out_param_pattern [concrete = constants.%return.param_patt.199]
-// CHECK:STDOUT:     %return.patt: %pattern_type.7fc = return_slot_pattern %return.param_patt, constants.%initializer_list [concrete = constants.%return.patt.07e]
+// CHECK:STDOUT:     %return.patt: %pattern_type.7fc = return_slot_pattern %return.param_patt, imports.%initializer_list.decl [concrete = constants.%return.patt.07e]
 // CHECK:STDOUT:   } {
-// CHECK:STDOUT:     %.loc10: Core.Form = init_form constants.%initializer_list [concrete = constants.%.0ee]
 // CHECK:STDOUT:     %_.param: %array_type = value_param call_param0
 // CHECK:STDOUT:     %_: %array_type = wrapper_binding _, %_.param
 // CHECK:STDOUT:     %return.param: ref %initializer_list = out_param call_param1
@@ -182,9 +181,8 @@ fn F() {
 // CHECK:STDOUT:     %_.param_patt: %pattern_type.771 = value_param_pattern [concrete = constants.%_.param_patt]
 // CHECK:STDOUT:     %_.patt: %pattern_type.771 = wrapper_binding_pattern _, %_.param_patt [concrete = constants.%_.patt.03c]
 // CHECK:STDOUT:     %return.param_patt: %pattern_type.7fc = out_param_pattern [concrete = constants.%return.param_patt.199]
-// CHECK:STDOUT:     %return.patt: %pattern_type.7fc = return_slot_pattern %return.param_patt, constants.%initializer_list [concrete = constants.%return.patt.07e]
+// CHECK:STDOUT:     %return.patt: %pattern_type.7fc = return_slot_pattern %return.param_patt, imports.%initializer_list.decl [concrete = constants.%return.patt.07e]
 // CHECK:STDOUT:   } {
-// CHECK:STDOUT:     %.loc12: Core.Form = init_form constants.%initializer_list [concrete = constants.%.0ee]
 // CHECK:STDOUT:     %_.param: %array_type = value_param call_param0
 // CHECK:STDOUT:     %_: %array_type = wrapper_binding _, %_.param
 // CHECK:STDOUT:     %return.param: ref %initializer_list = out_param call_param1
@@ -205,45 +203,46 @@ fn F() {
 // CHECK:STDOUT:   <elided>
 // CHECK:STDOUT:   %int_3.loc8_50: Core.IntLiteral = int_value 3 [concrete = constants.%int_3.1ba]
 // CHECK:STDOUT:   %array_type.loc8: type = array_type %int_3.loc8_50, %i32.2 [concrete = constants.%array_type]
-// CHECK:STDOUT:   %.loc8_50.2: ref %initializer_list = temporary_storage
+// CHECK:STDOUT:   %.loc8_50.2: Core.Form = init_form imports.%initializer_list.decl [concrete = constants.%.0ee]
+// CHECK:STDOUT:   %.loc8_50.3: ref %initializer_list = temporary_storage
 // CHECK:STDOUT:   %impl.elem0.loc8_50.1: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc8_50.1: <bound method> = bound_method %int_1.loc8_43, %impl.elem0.loc8_50.1 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.094]
 // CHECK:STDOUT:   %specific_fn.loc8_50.1: <specific function> = specific_function %impl.elem0.loc8_50.1, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc8_50.2: <bound method> = bound_method %int_1.loc8_43, %specific_fn.loc8_50.1 [concrete = constants.%bound_method.953]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.1: init %i32 = call %bound_method.loc8_50.2(%int_1.loc8_43) [concrete = constants.%int_1.0c6]
-// CHECK:STDOUT:   %.loc8_50.3: init %i32 = converted %int_1.loc8_43, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.1 [concrete = constants.%int_1.0c6]
-// CHECK:STDOUT:   %.loc8_50.4: ref %array_type = temporary_storage
+// CHECK:STDOUT:   %.loc8_50.4: init %i32 = converted %int_1.loc8_43, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.1 [concrete = constants.%int_1.0c6]
+// CHECK:STDOUT:   %.loc8_50.5: ref %array_type = temporary_storage
 // CHECK:STDOUT:   %int_0.loc8: Core.IntLiteral = int_value 0 [concrete = constants.%int_0]
-// CHECK:STDOUT:   %.loc8_50.5: ref %i32 = array_index %.loc8_50.4, %int_0.loc8
-// CHECK:STDOUT:   %.loc8_50.6: init %i32 to %.loc8_50.5 = in_place_init %.loc8_50.3 [concrete = constants.%int_1.0c6]
+// CHECK:STDOUT:   %.loc8_50.6: ref %i32 = array_index %.loc8_50.5, %int_0.loc8
+// CHECK:STDOUT:   %.loc8_50.7: init %i32 to %.loc8_50.6 = in_place_init %.loc8_50.4 [concrete = constants.%int_1.0c6]
 // CHECK:STDOUT:   %impl.elem0.loc8_50.2: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc8_50.3: <bound method> = bound_method %int_2.loc8_46, %impl.elem0.loc8_50.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.9f3]
 // CHECK:STDOUT:   %specific_fn.loc8_50.2: <specific function> = specific_function %impl.elem0.loc8_50.2, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc8_50.4: <bound method> = bound_method %int_2.loc8_46, %specific_fn.loc8_50.2 [concrete = constants.%bound_method.3cb]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.2: init %i32 = call %bound_method.loc8_50.4(%int_2.loc8_46) [concrete = constants.%int_2.295]
-// CHECK:STDOUT:   %.loc8_50.7: init %i32 = converted %int_2.loc8_46, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.2 [concrete = constants.%int_2.295]
+// CHECK:STDOUT:   %.loc8_50.8: init %i32 = converted %int_2.loc8_46, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.2 [concrete = constants.%int_2.295]
 // CHECK:STDOUT:   %int_1.loc8_50: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8]
-// CHECK:STDOUT:   %.loc8_50.8: ref %i32 = array_index %.loc8_50.4, %int_1.loc8_50
-// CHECK:STDOUT:   %.loc8_50.9: init %i32 to %.loc8_50.8 = in_place_init %.loc8_50.7 [concrete = constants.%int_2.295]
+// CHECK:STDOUT:   %.loc8_50.9: ref %i32 = array_index %.loc8_50.5, %int_1.loc8_50
+// CHECK:STDOUT:   %.loc8_50.10: init %i32 to %.loc8_50.9 = in_place_init %.loc8_50.8 [concrete = constants.%int_2.295]
 // CHECK:STDOUT:   %impl.elem0.loc8_50.3: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc8_50.5: <bound method> = bound_method %int_3.loc8_49, %impl.elem0.loc8_50.3 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.485]
 // CHECK:STDOUT:   %specific_fn.loc8_50.3: <specific function> = specific_function %impl.elem0.loc8_50.3, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc8_50.6: <bound method> = bound_method %int_3.loc8_49, %specific_fn.loc8_50.3 [concrete = constants.%bound_method.763]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.3: init %i32 = call %bound_method.loc8_50.6(%int_3.loc8_49) [concrete = constants.%int_3.410]
-// CHECK:STDOUT:   %.loc8_50.10: init %i32 = converted %int_3.loc8_49, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.3 [concrete = constants.%int_3.410]
+// CHECK:STDOUT:   %.loc8_50.11: init %i32 = converted %int_3.loc8_49, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc8_50.3 [concrete = constants.%int_3.410]
 // CHECK:STDOUT:   %int_2.loc8_50: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc]
-// CHECK:STDOUT:   %.loc8_50.11: ref %i32 = array_index %.loc8_50.4, %int_2.loc8_50
-// CHECK:STDOUT:   %.loc8_50.12: init %i32 to %.loc8_50.11 = in_place_init %.loc8_50.10 [concrete = constants.%int_3.410]
-// CHECK:STDOUT:   %.loc8_50.13: init %array_type to %.loc8_50.4 = array_init (%.loc8_50.6, %.loc8_50.9, %.loc8_50.12) [concrete = constants.%array]
-// CHECK:STDOUT:   %.loc8_50.14: init %array_type = converted %.loc8_50.1, %.loc8_50.13 [concrete = constants.%array]
-// CHECK:STDOUT:   %.loc8_50.15: ref %array_type = temporary %.loc8_50.4, %.loc8_50.14 [concrete = constants.%.981]
-// CHECK:STDOUT:   %.loc8_50.16: %array_type = acquire_value %.loc8_50.15 [concrete = constants.%array]
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.loc8: init %initializer_list to %.loc8_50.2 = call generated.%initializer_list.initializer_list.decl.f8e97d.1(%.loc8_50.16)
-// CHECK:STDOUT:   %.loc8_50.17: init %initializer_list = converted %.loc8_50.1, %initializer_list.initializer_list.call.loc8
-// CHECK:STDOUT:   %.loc8_50.18: ref %initializer_list = temporary %.loc8_50.2, %.loc8_50.17
-// CHECK:STDOUT:   %.loc8_50.19: %initializer_list = acquire_value %.loc8_50.18
+// CHECK:STDOUT:   %.loc8_50.12: ref %i32 = array_index %.loc8_50.5, %int_2.loc8_50
+// CHECK:STDOUT:   %.loc8_50.13: init %i32 to %.loc8_50.12 = in_place_init %.loc8_50.11 [concrete = constants.%int_3.410]
+// CHECK:STDOUT:   %.loc8_50.14: init %array_type to %.loc8_50.5 = array_init (%.loc8_50.7, %.loc8_50.10, %.loc8_50.13) [concrete = constants.%array]
+// CHECK:STDOUT:   %.loc8_50.15: init %array_type = converted %.loc8_50.1, %.loc8_50.14 [concrete = constants.%array]
+// CHECK:STDOUT:   %.loc8_50.16: ref %array_type = temporary %.loc8_50.5, %.loc8_50.15 [concrete = constants.%.981]
+// CHECK:STDOUT:   %.loc8_50.17: %array_type = acquire_value %.loc8_50.16 [concrete = constants.%array]
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.loc8: init %initializer_list to %.loc8_50.3 = call generated.%initializer_list.initializer_list.decl.f8e97d.1(%.loc8_50.17)
+// CHECK:STDOUT:   %.loc8_50.18: init %initializer_list = converted %.loc8_50.1, %initializer_list.initializer_list.call.loc8
+// CHECK:STDOUT:   %.loc8_50.19: ref %initializer_list = temporary %.loc8_50.3, %.loc8_50.18
+// CHECK:STDOUT:   %.loc8_50.20: %initializer_list = acquire_value %.loc8_50.19
 // CHECK:STDOUT:   <elided>
-// CHECK:STDOUT:   %_.loc8: %initializer_list = wrapper_binding _, %.loc8_50.19
+// CHECK:STDOUT:   %_.loc8: %initializer_list = wrapper_binding _, %.loc8_50.20
 // CHECK:STDOUT:   name_binding_decl {
 // CHECK:STDOUT:     %_.patt.loc8: %pattern_type.7fc = value_binding_pattern _ [concrete = constants.%_.patt.abb]
 // CHECK:STDOUT:   }
@@ -256,48 +255,49 @@ fn F() {
 // CHECK:STDOUT:   <elided>
 // CHECK:STDOUT:   %int_3.loc10_23: Core.IntLiteral = int_value 3 [concrete = constants.%int_3.1ba]
 // CHECK:STDOUT:   %array_type.loc10: type = array_type %int_3.loc10_23, %i32.4 [concrete = constants.%array_type]
-// CHECK:STDOUT:   %.loc10_23.2: ref %initializer_list = temporary_storage
+// CHECK:STDOUT:   %.loc10_23.2: Core.Form = init_form imports.%initializer_list.decl [concrete = constants.%.0ee]
+// CHECK:STDOUT:   %.loc10_23.3: ref %initializer_list = temporary_storage
 // CHECK:STDOUT:   %impl.elem0.loc10_23.1: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc10_23.1: <bound method> = bound_method %int_1.loc10_16, %impl.elem0.loc10_23.1 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.094]
 // CHECK:STDOUT:   %specific_fn.loc10_23.1: <specific function> = specific_function %impl.elem0.loc10_23.1, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc10_23.2: <bound method> = bound_method %int_1.loc10_16, %specific_fn.loc10_23.1 [concrete = constants.%bound_method.953]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.1: init %i32 = call %bound_method.loc10_23.2(%int_1.loc10_16) [concrete = constants.%int_1.0c6]
-// CHECK:STDOUT:   %.loc10_23.3: init %i32 = converted %int_1.loc10_16, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.1 [concrete = constants.%int_1.0c6]
-// CHECK:STDOUT:   %.loc10_23.4: ref %array_type = temporary_storage
+// CHECK:STDOUT:   %.loc10_23.4: init %i32 = converted %int_1.loc10_16, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.1 [concrete = constants.%int_1.0c6]
+// CHECK:STDOUT:   %.loc10_23.5: ref %array_type = temporary_storage
 // CHECK:STDOUT:   %int_0.loc10: Core.IntLiteral = int_value 0 [concrete = constants.%int_0]
-// CHECK:STDOUT:   %.loc10_23.5: ref %i32 = array_index %.loc10_23.4, %int_0.loc10
-// CHECK:STDOUT:   %.loc10_23.6: init %i32 to %.loc10_23.5 = in_place_init %.loc10_23.3 [concrete = constants.%int_1.0c6]
+// CHECK:STDOUT:   %.loc10_23.6: ref %i32 = array_index %.loc10_23.5, %int_0.loc10
+// CHECK:STDOUT:   %.loc10_23.7: init %i32 to %.loc10_23.6 = in_place_init %.loc10_23.4 [concrete = constants.%int_1.0c6]
 // CHECK:STDOUT:   %impl.elem0.loc10_23.2: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc10_23.3: <bound method> = bound_method %int_2.loc10_19, %impl.elem0.loc10_23.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.9f3]
 // CHECK:STDOUT:   %specific_fn.loc10_23.2: <specific function> = specific_function %impl.elem0.loc10_23.2, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc10_23.4: <bound method> = bound_method %int_2.loc10_19, %specific_fn.loc10_23.2 [concrete = constants.%bound_method.3cb]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.2: init %i32 = call %bound_method.loc10_23.4(%int_2.loc10_19) [concrete = constants.%int_2.295]
-// CHECK:STDOUT:   %.loc10_23.7: init %i32 = converted %int_2.loc10_19, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.2 [concrete = constants.%int_2.295]
+// CHECK:STDOUT:   %.loc10_23.8: init %i32 = converted %int_2.loc10_19, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.2 [concrete = constants.%int_2.295]
 // CHECK:STDOUT:   %int_1.loc10_23: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8]
-// CHECK:STDOUT:   %.loc10_23.8: ref %i32 = array_index %.loc10_23.4, %int_1.loc10_23
-// CHECK:STDOUT:   %.loc10_23.9: init %i32 to %.loc10_23.8 = in_place_init %.loc10_23.7 [concrete = constants.%int_2.295]
+// CHECK:STDOUT:   %.loc10_23.9: ref %i32 = array_index %.loc10_23.5, %int_1.loc10_23
+// CHECK:STDOUT:   %.loc10_23.10: init %i32 to %.loc10_23.9 = in_place_init %.loc10_23.8 [concrete = constants.%int_2.295]
 // CHECK:STDOUT:   %impl.elem0.loc10_23.3: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc10_23.5: <bound method> = bound_method %int_3.loc10_22, %impl.elem0.loc10_23.3 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.485]
 // CHECK:STDOUT:   %specific_fn.loc10_23.3: <specific function> = specific_function %impl.elem0.loc10_23.3, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc10_23.6: <bound method> = bound_method %int_3.loc10_22, %specific_fn.loc10_23.3 [concrete = constants.%bound_method.763]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.3: init %i32 = call %bound_method.loc10_23.6(%int_3.loc10_22) [concrete = constants.%int_3.410]
-// CHECK:STDOUT:   %.loc10_23.10: init %i32 = converted %int_3.loc10_22, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.3 [concrete = constants.%int_3.410]
+// CHECK:STDOUT:   %.loc10_23.11: init %i32 = converted %int_3.loc10_22, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_23.3 [concrete = constants.%int_3.410]
 // CHECK:STDOUT:   %int_2.loc10_23: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc]
-// CHECK:STDOUT:   %.loc10_23.11: ref %i32 = array_index %.loc10_23.4, %int_2.loc10_23
-// CHECK:STDOUT:   %.loc10_23.12: init %i32 to %.loc10_23.11 = in_place_init %.loc10_23.10 [concrete = constants.%int_3.410]
-// CHECK:STDOUT:   %.loc10_23.13: init %array_type to %.loc10_23.4 = array_init (%.loc10_23.6, %.loc10_23.9, %.loc10_23.12) [concrete = constants.%array]
-// CHECK:STDOUT:   %.loc10_23.14: init %array_type = converted %.loc10_23.1, %.loc10_23.13 [concrete = constants.%array]
-// CHECK:STDOUT:   %.loc10_23.15: ref %array_type = temporary %.loc10_23.4, %.loc10_23.14 [concrete = constants.%.981]
-// CHECK:STDOUT:   %.loc10_23.16: %array_type = acquire_value %.loc10_23.15 [concrete = constants.%array]
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.loc10: init %initializer_list to %.loc10_23.2 = call generated.%initializer_list.initializer_list.decl.f8e97d.2(%.loc10_23.16)
-// CHECK:STDOUT:   %.loc10_23.17: init %initializer_list = converted %.loc10_23.1, %initializer_list.initializer_list.call.loc10
-// CHECK:STDOUT:   %.loc10_23.18: ref %initializer_list = temporary %.loc10_23.2, %.loc10_23.17
-// CHECK:STDOUT:   %.loc10_23.19: %initializer_list = acquire_value %.loc10_23.18
-// CHECK:STDOUT:   %.loc10_23.20: ref %initializer_list = value_as_ref %.loc10_23.19
-// CHECK:STDOUT:   %addr.loc10: %ptr.fac = addr_of %.loc10_23.20
+// CHECK:STDOUT:   %.loc10_23.12: ref %i32 = array_index %.loc10_23.5, %int_2.loc10_23
+// CHECK:STDOUT:   %.loc10_23.13: init %i32 to %.loc10_23.12 = in_place_init %.loc10_23.11 [concrete = constants.%int_3.410]
+// CHECK:STDOUT:   %.loc10_23.14: init %array_type to %.loc10_23.5 = array_init (%.loc10_23.7, %.loc10_23.10, %.loc10_23.13) [concrete = constants.%array]
+// CHECK:STDOUT:   %.loc10_23.15: init %array_type = converted %.loc10_23.1, %.loc10_23.14 [concrete = constants.%array]
+// CHECK:STDOUT:   %.loc10_23.16: ref %array_type = temporary %.loc10_23.5, %.loc10_23.15 [concrete = constants.%.981]
+// CHECK:STDOUT:   %.loc10_23.17: %array_type = acquire_value %.loc10_23.16 [concrete = constants.%array]
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.loc10: init %initializer_list to %.loc10_23.3 = call generated.%initializer_list.initializer_list.decl.f8e97d.2(%.loc10_23.17)
+// CHECK:STDOUT:   %.loc10_23.18: init %initializer_list = converted %.loc10_23.1, %initializer_list.initializer_list.call.loc10
+// CHECK:STDOUT:   %.loc10_23.19: ref %initializer_list = temporary %.loc10_23.3, %.loc10_23.18
+// CHECK:STDOUT:   %.loc10_23.20: %initializer_list = acquire_value %.loc10_23.19
+// CHECK:STDOUT:   %.loc10_23.21: ref %initializer_list = value_as_ref %.loc10_23.20
+// CHECK:STDOUT:   %addr.loc10: %ptr.fac = addr_of %.loc10_23.21
 // CHECK:STDOUT:   %Consume__carbon_thunk.call: init %empty_tuple.type = call imports.%Consume__carbon_thunk.decl(%addr.loc10)
-// CHECK:STDOUT:   %initializer_list.cpp_destructor.bound.loc10: <bound method> = bound_method %.loc10_23.18, constants.%initializer_list.cpp_destructor
-// CHECK:STDOUT:   %initializer_list.cpp_destructor.call.loc10: init %empty_tuple.type = call %initializer_list.cpp_destructor.bound.loc10(%.loc10_23.18)
+// CHECK:STDOUT:   %initializer_list.cpp_destructor.bound.loc10: <bound method> = bound_method %.loc10_23.19, constants.%initializer_list.cpp_destructor
+// CHECK:STDOUT:   %initializer_list.cpp_destructor.call.loc10: init %empty_tuple.type = call %initializer_list.cpp_destructor.bound.loc10(%.loc10_23.19)
 // CHECK:STDOUT:   %Destroy.Op.call.loc10: init %empty_tuple.type = call constants.%Destroy.Op.bound(constants.%.981)
 // CHECK:STDOUT:   %int_1.loc12_37: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8]
 // CHECK:STDOUT:   %int_2.loc12_40: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc]
@@ -307,66 +307,67 @@ fn F() {
 // CHECK:STDOUT:   <elided>
 // CHECK:STDOUT:   %int_3.loc12_44: Core.IntLiteral = int_value 3 [concrete = constants.%int_3.1ba]
 // CHECK:STDOUT:   %array_type.loc12: type = array_type %int_3.loc12_44, %i32.6 [concrete = constants.%array_type]
-// CHECK:STDOUT:   %.loc12_44.3: ref %initializer_list = temporary_storage
+// CHECK:STDOUT:   %.loc12_44.3: Core.Form = init_form imports.%initializer_list.decl [concrete = constants.%.0ee]
+// CHECK:STDOUT:   %.loc12_44.4: ref %initializer_list = temporary_storage
 // CHECK:STDOUT:   %impl.elem0.loc12_44.1: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc12_44.1: <bound method> = bound_method %int_1.loc12_37, %impl.elem0.loc12_44.1 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.094]
 // CHECK:STDOUT:   %specific_fn.loc12_44.1: <specific function> = specific_function %impl.elem0.loc12_44.1, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc12_44.2: <bound method> = bound_method %int_1.loc12_37, %specific_fn.loc12_44.1 [concrete = constants.%bound_method.953]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.1: init %i32 = call %bound_method.loc12_44.2(%int_1.loc12_37) [concrete = constants.%int_1.0c6]
-// CHECK:STDOUT:   %.loc12_44.4: init %i32 = converted %int_1.loc12_37, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.1 [concrete = constants.%int_1.0c6]
-// CHECK:STDOUT:   %.loc12_44.5: ref %array_type = temporary_storage
+// CHECK:STDOUT:   %.loc12_44.5: init %i32 = converted %int_1.loc12_37, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.1 [concrete = constants.%int_1.0c6]
+// CHECK:STDOUT:   %.loc12_44.6: ref %array_type = temporary_storage
 // CHECK:STDOUT:   %int_0.loc12: Core.IntLiteral = int_value 0 [concrete = constants.%int_0]
-// CHECK:STDOUT:   %.loc12_44.6: ref %i32 = array_index %.loc12_44.5, %int_0.loc12
-// CHECK:STDOUT:   %.loc12_44.7: init %i32 to %.loc12_44.6 = in_place_init %.loc12_44.4 [concrete = constants.%int_1.0c6]
+// CHECK:STDOUT:   %.loc12_44.7: ref %i32 = array_index %.loc12_44.6, %int_0.loc12
+// CHECK:STDOUT:   %.loc12_44.8: init %i32 to %.loc12_44.7 = in_place_init %.loc12_44.5 [concrete = constants.%int_1.0c6]
 // CHECK:STDOUT:   %impl.elem0.loc12_44.2: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc12_44.3: <bound method> = bound_method %int_2.loc12_40, %impl.elem0.loc12_44.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.9f3]
 // CHECK:STDOUT:   %specific_fn.loc12_44.2: <specific function> = specific_function %impl.elem0.loc12_44.2, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc12_44.4: <bound method> = bound_method %int_2.loc12_40, %specific_fn.loc12_44.2 [concrete = constants.%bound_method.3cb]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.2: init %i32 = call %bound_method.loc12_44.4(%int_2.loc12_40) [concrete = constants.%int_2.295]
-// CHECK:STDOUT:   %.loc12_44.8: init %i32 = converted %int_2.loc12_40, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.2 [concrete = constants.%int_2.295]
+// CHECK:STDOUT:   %.loc12_44.9: init %i32 = converted %int_2.loc12_40, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.2 [concrete = constants.%int_2.295]
 // CHECK:STDOUT:   %int_1.loc12_44: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8]
-// CHECK:STDOUT:   %.loc12_44.9: ref %i32 = array_index %.loc12_44.5, %int_1.loc12_44
-// CHECK:STDOUT:   %.loc12_44.10: init %i32 to %.loc12_44.9 = in_place_init %.loc12_44.8 [concrete = constants.%int_2.295]
+// CHECK:STDOUT:   %.loc12_44.10: ref %i32 = array_index %.loc12_44.6, %int_1.loc12_44
+// CHECK:STDOUT:   %.loc12_44.11: init %i32 to %.loc12_44.10 = in_place_init %.loc12_44.9 [concrete = constants.%int_2.295]
 // CHECK:STDOUT:   %impl.elem0.loc12_44.3: %.b7a = impl_witness_access constants.%ImplicitAs.impl_witness.a2a, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e39]
 // CHECK:STDOUT:   %bound_method.loc12_44.5: <bound method> = bound_method %int_3.loc12_43, %impl.elem0.loc12_44.3 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.485]
 // CHECK:STDOUT:   %specific_fn.loc12_44.3: <specific function> = specific_function %impl.elem0.loc12_44.3, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
 // CHECK:STDOUT:   %bound_method.loc12_44.6: <bound method> = bound_method %int_3.loc12_43, %specific_fn.loc12_44.3 [concrete = constants.%bound_method.763]
 // CHECK:STDOUT:   %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.3: init %i32 = call %bound_method.loc12_44.6(%int_3.loc12_43) [concrete = constants.%int_3.410]
-// CHECK:STDOUT:   %.loc12_44.11: init %i32 = converted %int_3.loc12_43, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.3 [concrete = constants.%int_3.410]
+// CHECK:STDOUT:   %.loc12_44.12: init %i32 = converted %int_3.loc12_43, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc12_44.3 [concrete = constants.%int_3.410]
 // CHECK:STDOUT:   %int_2.loc12_44: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc]
-// CHECK:STDOUT:   %.loc12_44.12: ref %i32 = array_index %.loc12_44.5, %int_2.loc12_44
-// CHECK:STDOUT:   %.loc12_44.13: init %i32 to %.loc12_44.12 = in_place_init %.loc12_44.11 [concrete = constants.%int_3.410]
-// CHECK:STDOUT:   %.loc12_44.14: init %array_type to %.loc12_44.5 = array_init (%.loc12_44.7, %.loc12_44.10, %.loc12_44.13) [concrete = constants.%array]
-// CHECK:STDOUT:   %.loc12_44.15: init %array_type = converted %.loc12_44.1, %.loc12_44.14 [concrete = constants.%array]
-// CHECK:STDOUT:   %.loc12_44.16: ref %array_type = temporary %.loc12_44.5, %.loc12_44.15 [concrete = constants.%.981]
-// CHECK:STDOUT:   %.loc12_44.17: %array_type = acquire_value %.loc12_44.16 [concrete = constants.%array]
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.loc12: init %initializer_list to %.loc12_44.3 = call generated.%initializer_list.initializer_list.decl.f8e97d.3(%.loc12_44.17)
-// CHECK:STDOUT:   %.loc12_44.18: init %initializer_list = converted %.loc12_44.1, %initializer_list.initializer_list.call.loc12
-// CHECK:STDOUT:   %.loc12_44.19: ref %initializer_list = temporary %.loc12_44.3, %.loc12_44.18
-// CHECK:STDOUT:   %.loc12_44.20: %initializer_list = acquire_value %.loc12_44.19
-// CHECK:STDOUT:   %.loc12_44.21: ref %initializer_list = value_as_ref %.loc12_44.20
-// CHECK:STDOUT:   %addr.loc12_44.1: %ptr.fac = addr_of %.loc12_44.21
+// CHECK:STDOUT:   %.loc12_44.13: ref %i32 = array_index %.loc12_44.6, %int_2.loc12_44
+// CHECK:STDOUT:   %.loc12_44.14: init %i32 to %.loc12_44.13 = in_place_init %.loc12_44.12 [concrete = constants.%int_3.410]
+// CHECK:STDOUT:   %.loc12_44.15: init %array_type to %.loc12_44.6 = array_init (%.loc12_44.8, %.loc12_44.11, %.loc12_44.14) [concrete = constants.%array]
+// CHECK:STDOUT:   %.loc12_44.16: init %array_type = converted %.loc12_44.1, %.loc12_44.15 [concrete = constants.%array]
+// CHECK:STDOUT:   %.loc12_44.17: ref %array_type = temporary %.loc12_44.6, %.loc12_44.16 [concrete = constants.%.981]
+// CHECK:STDOUT:   %.loc12_44.18: %array_type = acquire_value %.loc12_44.17 [concrete = constants.%array]
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.loc12: init %initializer_list to %.loc12_44.4 = call generated.%initializer_list.initializer_list.decl.f8e97d.3(%.loc12_44.18)
+// CHECK:STDOUT:   %.loc12_44.19: init %initializer_list = converted %.loc12_44.1, %initializer_list.initializer_list.call.loc12
+// CHECK:STDOUT:   %.loc12_44.20: ref %initializer_list = temporary %.loc12_44.4, %.loc12_44.19
+// CHECK:STDOUT:   %.loc12_44.21: %initializer_list = acquire_value %.loc12_44.20
+// CHECK:STDOUT:   %.loc12_44.22: ref %initializer_list = value_as_ref %.loc12_44.21
+// CHECK:STDOUT:   %addr.loc12_44.1: %ptr.fac = addr_of %.loc12_44.22
 // CHECK:STDOUT:   %addr.loc12_44.2: %ptr.cbb = addr_of %.loc12_44.2
 // CHECK:STDOUT:   %InitListConstructor__carbon_thunk.call: init %empty_tuple.type = call imports.%InitListConstructor__carbon_thunk.decl(%addr.loc12_44.1, %addr.loc12_44.2)
-// CHECK:STDOUT:   %.loc12_44.22: init %InitListConstructor to %.loc12_44.2 = mark_in_place_init %InitListConstructor__carbon_thunk.call
-// CHECK:STDOUT:   %.loc12_44.23: init %InitListConstructor = converted %.loc12_44.1, %.loc12_44.22
-// CHECK:STDOUT:   %.loc12_44.24: ref %InitListConstructor = temporary %.loc12_44.2, %.loc12_44.23
-// CHECK:STDOUT:   %.loc12_44.25: %InitListConstructor = acquire_value %.loc12_44.24
+// CHECK:STDOUT:   %.loc12_44.23: init %InitListConstructor to %.loc12_44.2 = mark_in_place_init %InitListConstructor__carbon_thunk.call
+// CHECK:STDOUT:   %.loc12_44.24: init %InitListConstructor = converted %.loc12_44.1, %.loc12_44.23
+// CHECK:STDOUT:   %.loc12_44.25: ref %InitListConstructor = temporary %.loc12_44.2, %.loc12_44.24
+// CHECK:STDOUT:   %.loc12_44.26: %InitListConstructor = acquire_value %.loc12_44.25
 // CHECK:STDOUT:   %.loc12_13: type = splice_block %InitListConstructor.ref [concrete = constants.%InitListConstructor] {
 // CHECK:STDOUT:     %Cpp.ref.loc12: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
 // CHECK:STDOUT:     %InitListConstructor.ref: type = name_ref InitListConstructor, imports.%InitListConstructor.decl [concrete = constants.%InitListConstructor]
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %_.loc12: %InitListConstructor = wrapper_binding _, %.loc12_44.25
+// CHECK:STDOUT:   %_.loc12: %InitListConstructor = wrapper_binding _, %.loc12_44.26
 // CHECK:STDOUT:   name_binding_decl {
 // CHECK:STDOUT:     %_.patt.loc12: %pattern_type.ed6 = value_binding_pattern _ [concrete = constants.%_.patt.100]
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %InitListConstructor.cpp_destructor.bound: <bound method> = bound_method %.loc12_44.24, constants.%InitListConstructor.cpp_destructor
-// CHECK:STDOUT:   %InitListConstructor.cpp_destructor.call: init %empty_tuple.type = call %InitListConstructor.cpp_destructor.bound(%.loc12_44.24)
-// CHECK:STDOUT:   %initializer_list.cpp_destructor.bound.loc12: <bound method> = bound_method %.loc12_44.19, constants.%initializer_list.cpp_destructor
-// CHECK:STDOUT:   %initializer_list.cpp_destructor.call.loc12: init %empty_tuple.type = call %initializer_list.cpp_destructor.bound.loc12(%.loc12_44.19)
+// CHECK:STDOUT:   %InitListConstructor.cpp_destructor.bound: <bound method> = bound_method %.loc12_44.25, constants.%InitListConstructor.cpp_destructor
+// CHECK:STDOUT:   %InitListConstructor.cpp_destructor.call: init %empty_tuple.type = call %InitListConstructor.cpp_destructor.bound(%.loc12_44.25)
+// CHECK:STDOUT:   %initializer_list.cpp_destructor.bound.loc12: <bound method> = bound_method %.loc12_44.20, constants.%initializer_list.cpp_destructor
+// CHECK:STDOUT:   %initializer_list.cpp_destructor.call.loc12: init %empty_tuple.type = call %initializer_list.cpp_destructor.bound.loc12(%.loc12_44.20)
 // CHECK:STDOUT:   %Destroy.Op.call.loc12: init %empty_tuple.type = call constants.%Destroy.Op.bound(constants.%.981)
-// CHECK:STDOUT:   %initializer_list.cpp_destructor.bound.loc8: <bound method> = bound_method %.loc8_50.18, constants.%initializer_list.cpp_destructor
-// CHECK:STDOUT:   %initializer_list.cpp_destructor.call.loc8: init %empty_tuple.type = call %initializer_list.cpp_destructor.bound.loc8(%.loc8_50.18)
+// CHECK:STDOUT:   %initializer_list.cpp_destructor.bound.loc8: <bound method> = bound_method %.loc8_50.19, constants.%initializer_list.cpp_destructor
+// CHECK:STDOUT:   %initializer_list.cpp_destructor.call.loc8: init %empty_tuple.type = call %initializer_list.cpp_destructor.bound.loc8(%.loc8_50.19)
 // CHECK:STDOUT:   %Destroy.Op.call.loc8: init %empty_tuple.type = call constants.%Destroy.Op.bound(constants.%.981)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
diff --git a/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_pointer.carbon b/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_pointer.carbon
index 94e58d632995..8a6b8fe14eb5 100644
--- a/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_pointer.carbon
+++ b/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_pointer.carbon
@@ -120,19 +120,19 @@ fn InitNontrivialDtor() {
 // CHECK:STDOUT: define void @_CInitVectorLike.Main() #0 !dbg !33 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %_.var = alloca [1 x i8], align 1, !dbg !34
-// CHECK:STDOUT:   %.loc18_36.2.temp = alloca [16 x i8], align 8, !dbg !35
-// CHECK:STDOUT:   %.loc18_36.4.temp = alloca [3 x i32], align 4, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.3.temp = alloca [16 x i8], align 8, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.5.temp = alloca [3 x i32], align 4, !dbg !35
 // CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %_.var), !dbg !34
-// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.2.temp), !dbg !35
-// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.4.temp), !dbg !35
-// CHECK:STDOUT:   %.loc18_36.5.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.4.temp, i32 0, i64 0, !dbg !35
-// CHECK:STDOUT:   %.loc18_36.8.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.4.temp, i32 0, i64 1, !dbg !35
-// CHECK:STDOUT:   %.loc18_36.11.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.4.temp, i32 0, i64 2, !dbg !35
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.begin = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.2.temp, i32 0, i32 0, !dbg !35
+// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.3.temp), !dbg !35
+// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.5.temp), !dbg !35
+// CHECK:STDOUT:   %.loc18_36.6.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.5.temp, i32 0, i64 0, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.9.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.5.temp, i32 0, i64 1, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.12.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.5.temp, i32 0, i64 2, !dbg !35
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.begin = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.3.temp, i32 0, i32 0, !dbg !35
 // CHECK:STDOUT:   store ptr @array.loc13_50.15, ptr %initializer_list.initializer_list.call.init_list.begin, align 8, !dbg !35
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.end = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.2.temp, i32 0, i32 8, !dbg !35
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.end = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.3.temp, i32 0, i32 8, !dbg !35
 // CHECK:STDOUT:   store ptr getelementptr inbounds ([3 x i32], ptr @array.loc13_50.15, i32 1), ptr %initializer_list.initializer_list.call.init_list.end, align 8, !dbg !35
-// CHECK:STDOUT:   call void @_ZN11vector_likeC1ESt16initializer_listIiE.carbon_thunk._(ptr %.loc18_36.2.temp, ptr %_.var), !dbg !34
+// CHECK:STDOUT:   call void @_ZN11vector_likeC1ESt16initializer_listIiE.carbon_thunk._(ptr %.loc18_36.3.temp, ptr %_.var), !dbg !34
 // CHECK:STDOUT:   call void @_CWithinLifetime.Main(), !dbg !36
 // CHECK:STDOUT:   call void @"_COp.3bc428c96004ce87:core.Destroy.Core"(ptr @array), !dbg !35
 // CHECK:STDOUT:   call void @_ZN11vector_likeD2Ev(ptr %_.var), !dbg !34
diff --git a/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_size.carbon b/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_size.carbon
index 3c77f60467b6..4b6d88a091b0 100644
--- a/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_size.carbon
+++ b/toolchain/lower/testdata/interop/cpp/std_initializer_list_pointer_size.carbon
@@ -120,19 +120,19 @@ fn InitNontrivialDtor() {
 // CHECK:STDOUT: define void @_CInitVectorLike.Main() #0 !dbg !33 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %_.var = alloca [1 x i8], align 1, !dbg !34
-// CHECK:STDOUT:   %.loc18_36.2.temp = alloca [16 x i8], align 8, !dbg !35
-// CHECK:STDOUT:   %.loc18_36.4.temp = alloca [3 x i32], align 4, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.3.temp = alloca [16 x i8], align 8, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.5.temp = alloca [3 x i32], align 4, !dbg !35
 // CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %_.var), !dbg !34
-// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.2.temp), !dbg !35
-// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.4.temp), !dbg !35
-// CHECK:STDOUT:   %.loc18_36.5.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.4.temp, i32 0, i64 0, !dbg !35
-// CHECK:STDOUT:   %.loc18_36.8.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.4.temp, i32 0, i64 1, !dbg !35
-// CHECK:STDOUT:   %.loc18_36.11.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.4.temp, i32 0, i64 2, !dbg !35
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.begin = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.2.temp, i32 0, i32 0, !dbg !35
+// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.3.temp), !dbg !35
+// CHECK:STDOUT:   call void @llvm.lifetime.start.p0(ptr %.loc18_36.5.temp), !dbg !35
+// CHECK:STDOUT:   %.loc18_36.6.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.5.temp, i32 0, i64 0, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.9.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.5.temp, i32 0, i64 1, !dbg !35
+// CHECK:STDOUT:   %.loc18_36.12.array.index = getelementptr inbounds [3 x i32], ptr %.loc18_36.5.temp, i32 0, i64 2, !dbg !35
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.begin = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.3.temp, i32 0, i32 0, !dbg !35
 // CHECK:STDOUT:   store ptr @array.loc13_50.15, ptr %initializer_list.initializer_list.call.init_list.begin, align 8, !dbg !35
-// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.size = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.2.temp, i32 0, i32 8, !dbg !35
+// CHECK:STDOUT:   %initializer_list.initializer_list.call.init_list.size = getelementptr inbounds nuw [16 x i8], ptr %.loc18_36.3.temp, i32 0, i32 8, !dbg !35
 // CHECK:STDOUT:   store i64 3, ptr %initializer_list.initializer_list.call.init_list.size, align 8, !dbg !35
-// CHECK:STDOUT:   call void @_ZN11vector_likeC1ESt16initializer_listIiE.carbon_thunk._(ptr %.loc18_36.2.temp, ptr %_.var), !dbg !34
+// CHECK:STDOUT:   call void @_ZN11vector_likeC1ESt16initializer_listIiE.carbon_thunk._(ptr %.loc18_36.3.temp, ptr %_.var), !dbg !34
 // CHECK:STDOUT:   call void @_CWithinLifetime.Main(), !dbg !36
 // CHECK:STDOUT:   call void @"_COp.3bc428c96004ce87:core.Destroy.Core"(ptr @array), !dbg !35
 // CHECK:STDOUT:   call void @_ZN11vector_likeD2Ev(ptr %_.var), !dbg !34