Add a `FacetValue` instruction (#4545)

The new `FacetValue` instruction represents `C as I` for some type `C`
and facet type `I`. It is named `FacetValue` instead of just `Facet` to
parallel the `FacetType` instruction.

This PR uses this instruction represent the facet value `Self` in an
`impl` declaration. This instruction will be used in the future to also
support things like:

* `C as I` where `C` is a class; and
* forming a specific for a generic with a `T:! I` parameter where `T` is
being given a concrete value.

(Here `I` is an interface or other non-`type` facet type.)

Also do some renaming and add some comments to make things a bit more
clear.

* `FacetTypeAccess` -> `FacetAccessType` to clarify this is not access
of a facet type, but access of the type of a facet
* `.facet_id` -> `.facet_value_inst_id` to parallel the `FacetValue`
instruction

`FacetAccessWitness` will be in a future PR.

---------

Co-authored-by: Josh L <josh11b@users.noreply.github.com>
Co-authored-by: Richard Smith <richard@metafoo.co.uk>

toolchain/check/context.cpp

@@ -1134,9 +1134,10 @@ class TypeCompleter {
 
   template <typename InstT>
     requires(InstT::Kind.template IsAnyOf<
-             SemIR::AssociatedEntityType, SemIR::FacetType, SemIR::FunctionType,
-             SemIR::GenericClassType, SemIR::GenericInterfaceType,
-             SemIR::UnboundElementType, SemIR::WhereExpr>())
+             SemIR::AssociatedEntityType, SemIR::FacetAccessType,
+             SemIR::FacetType, SemIR::FunctionType, SemIR::GenericClassType,
+             SemIR::GenericInterfaceType, SemIR::UnboundElementType,
+             SemIR::WhereExpr>())
   auto BuildValueReprForInst(SemIR::TypeId /*type_id*/, InstT /*inst*/) const
       -> SemIR::ValueRepr {
     // These types have no runtime operations, so we use an empty value

toolchain/check/convert.cpp

@@ -891,12 +891,12 @@ static auto PerformBuiltinConversion(Context& context, SemIR::LocId loc_id,
     // converted to facet type F2 if T satisfies the requirements of F2.
     //
     // TODO: Support this conversion in general. For now we only support it in
-    // the case where F1 is an interface type and F2 is `type`.
+    // the case where F1 is a facet type and F2 is `type`.
     // TODO: Support converting tuple and struct values to facet types,
     // combining the above conversions and this one in a single conversion.
     if (sem_ir.types().Is<SemIR::FacetType>(value_type_id)) {
-      return context.AddInst<SemIR::FacetTypeAccess>(
-          loc_id, {.type_id = target.type_id, .facet_id = value_id});
+      return context.AddInst<SemIR::FacetAccessType>(
+          loc_id, {.type_id = target.type_id, .facet_value_inst_id = value_id});
     }
   }
 

toolchain/check/eval.cpp

@@ -1330,6 +1330,11 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
     case SemIR::CompleteTypeWitness::Kind:
       return RebuildIfFieldsAreConstant(
           eval_context, inst, &SemIR::CompleteTypeWitness::object_repr_id);
+    case SemIR::FacetValue::Kind:
+      return RebuildIfFieldsAreConstant(eval_context, inst,
+                                        &SemIR::FacetValue::type_id,
+                                        &SemIR::FacetValue::type_inst_id,
+                                        &SemIR::FacetValue::witness_inst_id);
     case SemIR::FunctionType::Kind:
       return RebuildIfFieldsAreConstant(eval_context, inst,
                                         &SemIR::FunctionType::specific_id);
@@ -1608,11 +1613,21 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
     case CARBON_KIND(SemIR::ValueOfInitializer typed_inst): {
       return eval_context.GetConstantValue(typed_inst.init_id);
     }
-    case CARBON_KIND(SemIR::FacetTypeAccess typed_inst): {
-      // TODO: Once we start tracking the witness in the facet value, remove it
-      // here. For now, we model a facet value as just a type.
-      return eval_context.GetConstantValue(typed_inst.facet_id);
+    case CARBON_KIND(SemIR::FacetAccessType typed_inst): {
+      Phase phase = Phase::Template;
+      if (ReplaceFieldWithConstantValue(
+              eval_context, &typed_inst,
+              &SemIR::FacetAccessType::facet_value_inst_id, &phase)) {
+        if (auto facet_value = eval_context.insts().TryGetAs<SemIR::FacetValue>(
+                typed_inst.facet_value_inst_id)) {
+          return eval_context.constant_values().Get(facet_value->type_inst_id);
+        }
+        return MakeConstantResult(eval_context.context(), typed_inst, phase);
+      } else {
+        return MakeNonConstantResult(phase);
+      }
     }
+
     case CARBON_KIND(SemIR::WhereExpr typed_inst): {
       Phase phase = Phase::Template;
       SemIR::TypeId base_facet_type_id =

toolchain/check/impl.cpp

@@ -6,6 +6,7 @@
 
 #include "toolchain/base/kind_switch.h"
 #include "toolchain/check/context.h"
+#include "toolchain/check/eval.h"
 #include "toolchain/check/function.h"
 #include "toolchain/check/generic.h"
 #include "toolchain/check/import_ref.h"
@@ -51,16 +52,27 @@ static auto GetSelfSpecificForInterfaceMemberWithSelfType(
                    enclosing_specific_args.end());
   }
 
-  // Add the `Self` argument.
+  // Add the `Self` argument. First find the `Self` binding.
+  auto self_binding =
+      context.insts().GetAs<SemIR::BindSymbolicName>(bindings[arg_ids.size()]);
   CARBON_CHECK(
-      context.entity_names()
-              .Get(context.insts()
-                       .GetAs<SemIR::BindSymbolicName>(bindings[arg_ids.size()])
-                       .entity_name_id)
-              .name_id == SemIR::NameId::SelfType,
-      "Expected a Self binding, found {0}",
-      context.insts().Get(bindings[arg_ids.size()]));
-  arg_ids.push_back(context.types().GetInstId(self_type_id));
+      context.entity_names().Get(self_binding.entity_name_id).name_id ==
+          SemIR::NameId::SelfType,
+      "Expected a Self binding, found {0}", self_binding);
+  // Create a facet value to be the value of `Self` in the interface.
+  // This facet value consists of the type `self_type_id` and a witness that the
+  // type implements `self_binding.type_id`. The witness needs to be symbolic
+  // since we haven't finished defining the implementation here.
+  auto type_inst_id = context.types().GetInstId(self_type_id);
+  // TODO: Make a symbolic interface witness here. For the moment, the witness
+  // is never used.
+  auto witness_inst_id = type_inst_id;
+  auto facet_value_const_id =
+      TryEvalInst(context, SemIR::InstId::Invalid,
+                  SemIR::FacetValue{.type_id = self_binding.type_id,
+                                    .type_inst_id = type_inst_id,
+                                    .witness_inst_id = witness_inst_id});
+  arg_ids.push_back(context.constant_values().GetInstId(facet_value_const_id));
 
   // Take any trailing argument values from the self specific.
   // TODO: If these refer to outer arguments, for example in their types, we may

toolchain/check/import_ref.cpp

@@ -1197,9 +1197,15 @@ class ImportRefResolver {
       case CARBON_KIND(SemIR::ExportDecl inst): {
         return TryResolveTypedInst(inst);
       }
+      case CARBON_KIND(SemIR::FacetAccessType inst): {
+        return TryResolveTypedInst(inst);
+      }
       case CARBON_KIND(SemIR::FacetType inst): {
         return TryResolveTypedInst(inst);
       }
+      case CARBON_KIND(SemIR::FacetValue inst): {
+        return TryResolveTypedInst(inst);
+      }
       case CARBON_KIND(SemIR::FieldDecl inst): {
         return TryResolveTypedInst(inst, inst_id);
       }
@@ -2072,6 +2078,17 @@ class ImportRefResolver {
     return ResolveAsConstant(interface_const_id);
   }
 
+  auto TryResolveTypedInst(SemIR::FacetAccessType inst) -> ResolveResult {
+    auto facet_value_inst_id = GetLocalConstantInstId(inst.facet_value_inst_id);
+    if (HasNewWork()) {
+      return Retry();
+    }
+
+    return ResolveAs<SemIR::FacetAccessType>(
+        {.type_id = SemIR::TypeId::TypeType,
+         .facet_value_inst_id = facet_value_inst_id});
+  }
+
   auto TryResolveTypedInst(SemIR::FacetType inst) -> ResolveResult {
     CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType);
 
@@ -2124,6 +2141,20 @@ class ImportRefResolver {
         {.type_id = SemIR::TypeId::TypeType, .facet_type_id = facet_type_id});
   }
 
+  auto TryResolveTypedInst(SemIR::FacetValue inst) -> ResolveResult {
+    auto type_id = GetLocalConstantId(inst.type_id);
+    auto type_inst_id = GetLocalConstantInstId(inst.type_inst_id);
+    auto witness_inst_id = GetLocalConstantInstId(inst.witness_inst_id);
+    if (HasNewWork()) {
+      return Retry();
+    }
+
+    return ResolveAs<SemIR::FacetValue>(
+        {.type_id = context_.GetTypeIdForTypeConstant(type_id),
+         .type_inst_id = type_inst_id,
+         .witness_inst_id = witness_inst_id});
+  }
+
   auto TryResolveTypedInst(SemIR::InterfaceWitness inst) -> ResolveResult {
     auto elements = GetLocalInstBlockContents(inst.elements_id);
     if (HasNewWork()) {

toolchain/check/merge.cpp

@@ -203,6 +203,10 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
   // TODO: Consider differentiating between type and name mistakes. For now,
   // taking the simpler approach because I also think we may want to refactor
   // params.
+  CARBON_DIAGNOSTIC(
+      RedeclParamPrevious, Note,
+      "previous declaration's corresponding {0:implicit |}parameter here",
+      BoolAsSelect);
   auto emit_diagnostic = [&]() {
     if (!diagnose) {
       return;
@@ -210,10 +214,6 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
     CARBON_DIAGNOSTIC(RedeclParamDiffers, Error,
                       "redeclaration differs at {0:implicit |}parameter {1}",
                       BoolAsSelect, int32_t);
-    CARBON_DIAGNOSTIC(
-        RedeclParamPrevious, Note,
-        "previous declaration's corresponding {0:implicit |}parameter here",
-        BoolAsSelect);
     context.emitter()
         .Build(new_param_pattern_id, RedeclParamDiffers, is_implicit_param,
                param_index + 1)
@@ -223,15 +223,30 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
 
   auto new_param_pattern = context.insts().Get(new_param_pattern_id);
   auto prev_param_pattern = context.insts().Get(prev_param_pattern_id);
-  if (new_param_pattern.kind() != prev_param_pattern.kind() ||
-      !context.types().AreEqualAcrossDeclarations(
-          new_param_pattern.type_id(),
-          SemIR::GetTypeInSpecific(context.sem_ir(), prev_specific_id,
-                                   prev_param_pattern.type_id()))) {
+  if (new_param_pattern.kind() != prev_param_pattern.kind()) {
     emit_diagnostic();
     return false;
   }
 
+  auto prev_param_type_id = SemIR::GetTypeInSpecific(
+      context.sem_ir(), prev_specific_id, prev_param_pattern.type_id());
+  if (!context.types().AreEqualAcrossDeclarations(new_param_pattern.type_id(),
+                                                  prev_param_type_id)) {
+    if (!diagnose) {
+      return false;
+    }
+    CARBON_DIAGNOSTIC(RedeclParamDiffersType, Error,
+                      "type {3} of {0:implicit |}parameter {1} in "
+                      "redeclaration differs from previous parameter type {2}",
+                      BoolAsSelect, int32_t, SemIR::TypeId, SemIR::TypeId);
+    context.emitter()
+        .Build(new_param_pattern_id, RedeclParamDiffersType, is_implicit_param,
+               param_index + 1, prev_param_type_id, new_param_pattern.type_id())
+        .Note(prev_param_pattern_id, RedeclParamPrevious, is_implicit_param)
+        .Emit();
+    return false;
+  }
+
   if (new_param_pattern.Is<SemIR::AddrPattern>()) {
     new_param_pattern = context.insts().Get(
         new_param_pattern.As<SemIR::AddrPattern>().inner_id);

toolchain/check/testdata/array/array_vs_tuple.carbon

@@ -32,20 +32,20 @@ fn G() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %array: %.3 = tuple_value (%.30, %.33, %.36) [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %array: %.3 = tuple_value (%.34, %.37, %.40) [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (type, type, type) [template]
 // CHECK:STDOUT:   %tuple.type.3: type = tuple_type (%i32, %i32, %i32) [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.3 = tuple_value (%.30, %.33, %.36) [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.3 = tuple_value (%.34, %.37, %.40) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -80,30 +80,30 @@ fn G() {
 // CHECK:STDOUT:   %.loc13_25: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc13_28: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc13_29.1: %tuple.type.1 = tuple_literal (%.loc13_22, %.loc13_25, %.loc13_28)
-// CHECK:STDOUT:   %.loc13_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_29.3: <bound method> = bound_method %.loc13_22, %.loc13_29.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc13_29.4: <specific function> = specific_function %.loc13_29.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc13_29.1: init %i32 = call %.loc13_29.4(%.loc13_22) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_29.5: init %i32 = converted %.loc13_22, %int.convert_checked.loc13_29.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_29.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_29.3: <bound method> = bound_method %.loc13_22, %.loc13_29.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc13_29.4: <specific function> = specific_function %.loc13_29.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc13_29.1: init %i32 = call %.loc13_29.4(%.loc13_22) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_29.5: init %i32 = converted %.loc13_22, %int.convert_checked.loc13_29.1 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_29.6: Core.IntLiteral = int_value 0 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc13_29.7: ref %i32 = array_index %a.var, %.loc13_29.6
-// CHECK:STDOUT:   %.loc13_29.8: init %i32 = initialize_from %.loc13_29.5 to %.loc13_29.7 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_29.9: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_29.10: <bound method> = bound_method %.loc13_25, %.loc13_29.9 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc13_29.11: <specific function> = specific_function %.loc13_29.10, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc13_29.2: init %i32 = call %.loc13_29.11(%.loc13_25) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_29.12: init %i32 = converted %.loc13_25, %int.convert_checked.loc13_29.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_29.8: init %i32 = initialize_from %.loc13_29.5 to %.loc13_29.7 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_29.9: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_29.10: <bound method> = bound_method %.loc13_25, %.loc13_29.9 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_29.11: <specific function> = specific_function %.loc13_29.10, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc13_29.2: init %i32 = call %.loc13_29.11(%.loc13_25) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_29.12: init %i32 = converted %.loc13_25, %int.convert_checked.loc13_29.2 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc13_29.13: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc13_29.14: ref %i32 = array_index %a.var, %.loc13_29.13
-// CHECK:STDOUT:   %.loc13_29.15: init %i32 = initialize_from %.loc13_29.12 to %.loc13_29.14 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_29.16: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_29.17: <bound method> = bound_method %.loc13_28, %.loc13_29.16 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_29.18: <specific function> = specific_function %.loc13_29.17, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc13_29.3: init %i32 = call %.loc13_29.18(%.loc13_28) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc13_29.19: init %i32 = converted %.loc13_28, %int.convert_checked.loc13_29.3 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_29.15: init %i32 = initialize_from %.loc13_29.12 to %.loc13_29.14 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_29.16: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_29.17: <bound method> = bound_method %.loc13_28, %.loc13_29.16 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_29.18: <specific function> = specific_function %.loc13_29.17, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc13_29.3: init %i32 = call %.loc13_29.18(%.loc13_28) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc13_29.19: init %i32 = converted %.loc13_28, %int.convert_checked.loc13_29.3 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc13_29.20: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc13_29.21: ref %i32 = array_index %a.var, %.loc13_29.20
-// CHECK:STDOUT:   %.loc13_29.22: init %i32 = initialize_from %.loc13_29.19 to %.loc13_29.21 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_29.22: init %i32 = initialize_from %.loc13_29.19 to %.loc13_29.21 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc13_29.23: init %.3 = array_init (%.loc13_29.8, %.loc13_29.15, %.loc13_29.22) to %a.var [template = constants.%array]
 // CHECK:STDOUT:   %.loc13_30: init %.3 = converted %.loc13_29.1, %.loc13_29.23 [template = constants.%array]
 // CHECK:STDOUT:   assign %a.var, %.loc13_30
@@ -127,27 +127,27 @@ fn G() {
 // CHECK:STDOUT:   %.loc14_32: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc14_35: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_36.1: %tuple.type.1 = tuple_literal (%.loc14_29, %.loc14_32, %.loc14_35)
-// CHECK:STDOUT:   %.loc14_36.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_36.3: <bound method> = bound_method %.loc14_29, %.loc14_36.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc14_36.4: <specific function> = specific_function %.loc14_36.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc14_36.1: init %i32 = call %.loc14_36.4(%.loc14_29) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_36.5: init %i32 = converted %.loc14_29, %int.convert_checked.loc14_36.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_36.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_36.3: <bound method> = bound_method %.loc14_29, %.loc14_36.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc14_36.4: <specific function> = specific_function %.loc14_36.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc14_36.1: init %i32 = call %.loc14_36.4(%.loc14_29) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_36.5: init %i32 = converted %.loc14_29, %int.convert_checked.loc14_36.1 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc14_36.6: ref %i32 = tuple_access %b.var, element0
-// CHECK:STDOUT:   %.loc14_36.7: init %i32 = initialize_from %.loc14_36.5 to %.loc14_36.6 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_36.8: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_36.9: <bound method> = bound_method %.loc14_32, %.loc14_36.8 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc14_36.10: <specific function> = specific_function %.loc14_36.9, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc14_36.2: init %i32 = call %.loc14_36.10(%.loc14_32) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc14_36.11: init %i32 = converted %.loc14_32, %int.convert_checked.loc14_36.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_36.7: init %i32 = initialize_from %.loc14_36.5 to %.loc14_36.6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_36.8: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_36.9: <bound method> = bound_method %.loc14_32, %.loc14_36.8 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc14_36.10: <specific function> = specific_function %.loc14_36.9, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc14_36.2: init %i32 = call %.loc14_36.10(%.loc14_32) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc14_36.11: init %i32 = converted %.loc14_32, %int.convert_checked.loc14_36.2 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc14_36.12: ref %i32 = tuple_access %b.var, element1
-// CHECK:STDOUT:   %.loc14_36.13: init %i32 = initialize_from %.loc14_36.11 to %.loc14_36.12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc14_36.14: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_36.15: <bound method> = bound_method %.loc14_35, %.loc14_36.14 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc14_36.16: <specific function> = specific_function %.loc14_36.15, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc14_36.3: init %i32 = call %.loc14_36.16(%.loc14_35) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc14_36.17: init %i32 = converted %.loc14_35, %int.convert_checked.loc14_36.3 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc14_36.13: init %i32 = initialize_from %.loc14_36.11 to %.loc14_36.12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc14_36.14: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_36.15: <bound method> = bound_method %.loc14_35, %.loc14_36.14 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc14_36.16: <specific function> = specific_function %.loc14_36.15, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc14_36.3: init %i32 = call %.loc14_36.16(%.loc14_35) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc14_36.17: init %i32 = converted %.loc14_35, %int.convert_checked.loc14_36.3 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc14_36.18: ref %i32 = tuple_access %b.var, element2
-// CHECK:STDOUT:   %.loc14_36.19: init %i32 = initialize_from %.loc14_36.17 to %.loc14_36.18 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc14_36.19: init %i32 = initialize_from %.loc14_36.17 to %.loc14_36.18 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc14_36.20: init %tuple.type.3 = tuple_init (%.loc14_36.7, %.loc14_36.13, %.loc14_36.19) to %b.var [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc14_37: init %tuple.type.3 = converted %.loc14_36.1, %.loc14_36.20 [template = constants.%tuple]
 // CHECK:STDOUT:   assign %b.var, %.loc14_37

toolchain/check/testdata/array/assign_return_value.carbon

@@ -30,15 +30,15 @@ fn Run() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.25) [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.29) [template]
 // CHECK:STDOUT:   %Run.type: type = fn_type @Run [template]
 // CHECK:STDOUT:   %Run: %Run.type = struct_value () [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.27: type = array_type %.26, %i32 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.31: type = array_type %.30, %i32 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -77,12 +77,12 @@ fn Run() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_28: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_30.1: %tuple.type.3 = tuple_literal (%.loc11_28)
-// CHECK:STDOUT:   %.loc11_30.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_30.3: <bound method> = bound_method %.loc11_28, %.loc11_30.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc11_30.4: <specific function> = specific_function %.loc11_30.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_30.4(%.loc11_28) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_30.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_30.6: %i32 = converted %.loc11_28, %.loc11_30.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc11_30.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_30.3: <bound method> = bound_method %.loc11_28, %.loc11_30.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11_30.4: <specific function> = specific_function %.loc11_30.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_30.4(%.loc11_28) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_30.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_30.6: %i32 = converted %.loc11_28, %.loc11_30.5 [template = constants.%.29]
 // CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.loc11_30.6) [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc11_31: %tuple.type.2 = converted %.loc11_30.1, %tuple [template = constants.%tuple]
 // CHECK:STDOUT:   return %.loc11_31
@@ -92,12 +92,12 @@ fn Run() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc14_11.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed: init type = call constants.%Int(%.loc14_11.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc14_16: Core.IntLiteral = int_value 1 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc14_16: Core.IntLiteral = int_value 1 [template = constants.%.30]
 // CHECK:STDOUT:   %.loc14_11.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:   %.loc14_11.3: type = converted %int.make_type_signed, %.loc14_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc14_17: type = array_type %.loc14_16, %i32 [template = constants.%.27]
-// CHECK:STDOUT:   %t.var: ref %.27 = var t
-// CHECK:STDOUT:   %t: ref %.27 = bind_name t, %t.var
+// CHECK:STDOUT:   %.loc14_17: type = array_type %.loc14_16, %i32 [template = constants.%.31]
+// CHECK:STDOUT:   %t.var: ref %.31 = var t
+// CHECK:STDOUT:   %t: ref %.31 = bind_name t, %t.var
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
 // CHECK:STDOUT:   %F.call: init %tuple.type.2 = call %F.ref()
 // CHECK:STDOUT:   %.loc14_22.1: ref %tuple.type.2 = temporary_storage
@@ -107,8 +107,8 @@ fn Run() {
 // CHECK:STDOUT:   %.loc14_22.5: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_22.6: ref %i32 = array_index %t.var, %.loc14_22.5
 // CHECK:STDOUT:   %.loc14_22.7: init %i32 = initialize_from %.loc14_22.4 to %.loc14_22.6
-// CHECK:STDOUT:   %.loc14_22.8: init %.27 = array_init (%.loc14_22.7) to %t.var
-// CHECK:STDOUT:   %.loc14_24: init %.27 = converted %F.call, %.loc14_22.8
+// CHECK:STDOUT:   %.loc14_22.8: init %.31 = array_init (%.loc14_22.7) to %t.var
+// CHECK:STDOUT:   %.loc14_24: init %.31 = converted %F.call, %.loc14_22.8
 // CHECK:STDOUT:   assign %t.var, %.loc14_24
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/array/assign_var.carbon

@@ -27,19 +27,19 @@ var b: [i32; 3] = a;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.4, %Convert.14 [template]
-// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.28, %.31, %.34) [template]
-// CHECK:STDOUT:   %.35: type = array_type %.5, %i32 [template]
-// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.33: <bound method> = bound_method %.4, %Convert.14 [template]
+// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.32, %.35, %.38) [template]
+// CHECK:STDOUT:   %.39: type = array_type %.5, %i32 [template]
+// CHECK:STDOUT:   %.41: Core.IntLiteral = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -79,9 +79,9 @@ var b: [i32; 3] = a;
 // CHECK:STDOUT:   %.loc12_14: Core.IntLiteral = int_value 3 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc12_9.2: type = value_of_initializer %int.make_type_signed.loc12 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc12_9.3: type = converted %int.make_type_signed.loc12, %.loc12_9.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc12_15: type = array_type %.loc12_14, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %b.var: ref %.35 = var b
-// CHECK:STDOUT:   %b: ref %.35 = bind_name b, %b.var
+// CHECK:STDOUT:   %.loc12_15: type = array_type %.loc12_14, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %b.var: ref %.39 = var b
+// CHECK:STDOUT:   %b: ref %.39 = bind_name b, %b.var
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
@@ -90,34 +90,34 @@ var b: [i32; 3] = a;
 // CHECK:STDOUT:   %.loc11_30: Core.IntLiteral = int_value 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc11_33: Core.IntLiteral = int_value 3 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc11_34.1: %tuple.type.3 = tuple_literal (%.loc11_27, %.loc11_30, %.loc11_33)
-// CHECK:STDOUT:   %.loc11_34.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_34.3: <bound method> = bound_method %.loc11_27, %.loc11_34.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_34.4: <specific function> = specific_function %.loc11_34.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc11_34.1: init %i32 = call %.loc11_34.4(%.loc11_27) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_34.5: init %i32 = converted %.loc11_27, %int.convert_checked.loc11_34.1 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc11_34.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_34.3: <bound method> = bound_method %.loc11_27, %.loc11_34.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_34.4: <specific function> = specific_function %.loc11_34.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc11_34.1: init %i32 = call %.loc11_34.4(%.loc11_27) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_34.5: init %i32 = converted %.loc11_27, %int.convert_checked.loc11_34.1 [template = constants.%.32]
 // CHECK:STDOUT:   %.loc11_34.6: ref %i32 = tuple_access file.%a.var, element0
-// CHECK:STDOUT:   %.loc11_34.7: init %i32 = initialize_from %.loc11_34.5 to %.loc11_34.6 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_34.8: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_34.9: <bound method> = bound_method %.loc11_30, %.loc11_34.8 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_34.10: <specific function> = specific_function %.loc11_34.9, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc11_34.2: init %i32 = call %.loc11_34.10(%.loc11_30) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_34.11: init %i32 = converted %.loc11_30, %int.convert_checked.loc11_34.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_34.7: init %i32 = initialize_from %.loc11_34.5 to %.loc11_34.6 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_34.8: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_34.9: <bound method> = bound_method %.loc11_30, %.loc11_34.8 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_34.10: <specific function> = specific_function %.loc11_34.9, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc11_34.2: init %i32 = call %.loc11_34.10(%.loc11_30) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_34.11: init %i32 = converted %.loc11_30, %int.convert_checked.loc11_34.2 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc11_34.12: ref %i32 = tuple_access file.%a.var, element1
-// CHECK:STDOUT:   %.loc11_34.13: init %i32 = initialize_from %.loc11_34.11 to %.loc11_34.12 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_34.14: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_34.15: <bound method> = bound_method %.loc11_33, %.loc11_34.14 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc11_34.16: <specific function> = specific_function %.loc11_34.15, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc11_34.3: init %i32 = call %.loc11_34.16(%.loc11_33) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_34.17: init %i32 = converted %.loc11_33, %int.convert_checked.loc11_34.3 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_34.13: init %i32 = initialize_from %.loc11_34.11 to %.loc11_34.12 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_34.14: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_34.15: <bound method> = bound_method %.loc11_33, %.loc11_34.14 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc11_34.16: <specific function> = specific_function %.loc11_34.15, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc11_34.3: init %i32 = call %.loc11_34.16(%.loc11_33) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_34.17: init %i32 = converted %.loc11_33, %int.convert_checked.loc11_34.3 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc11_34.18: ref %i32 = tuple_access file.%a.var, element2
-// CHECK:STDOUT:   %.loc11_34.19: init %i32 = initialize_from %.loc11_34.17 to %.loc11_34.18 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_34.19: init %i32 = initialize_from %.loc11_34.17 to %.loc11_34.18 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc11_34.20: init %tuple.type.2 = tuple_init (%.loc11_34.7, %.loc11_34.13, %.loc11_34.19) to file.%a.var [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc11_35: init %tuple.type.2 = converted %.loc11_34.1, %.loc11_34.20 [template = constants.%tuple]
 // CHECK:STDOUT:   assign file.%a.var, %.loc11_35
 // CHECK:STDOUT:   %a.ref: ref %tuple.type.2 = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc12_19.1: ref %i32 = tuple_access %a.ref, element0
 // CHECK:STDOUT:   %.loc12_19.2: %i32 = bind_value %.loc12_19.1
-// CHECK:STDOUT:   %.loc12_19.3: Core.IntLiteral = int_value 0 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_19.3: Core.IntLiteral = int_value 0 [template = constants.%.41]
 // CHECK:STDOUT:   %.loc12_19.4: ref %i32 = array_index file.%b.var, %.loc12_19.3
 // CHECK:STDOUT:   %.loc12_19.5: init %i32 = initialize_from %.loc12_19.2 to %.loc12_19.4
 // CHECK:STDOUT:   %.loc12_19.6: ref %i32 = tuple_access %a.ref, element1
@@ -130,8 +130,8 @@ var b: [i32; 3] = a;
 // CHECK:STDOUT:   %.loc12_19.13: Core.IntLiteral = int_value 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc12_19.14: ref %i32 = array_index file.%b.var, %.loc12_19.13
 // CHECK:STDOUT:   %.loc12_19.15: init %i32 = initialize_from %.loc12_19.12 to %.loc12_19.14
-// CHECK:STDOUT:   %.loc12_19.16: init %.35 = array_init (%.loc12_19.5, %.loc12_19.10, %.loc12_19.15) to file.%b.var
-// CHECK:STDOUT:   %.loc12_20: init %.35 = converted %a.ref, %.loc12_19.16
+// CHECK:STDOUT:   %.loc12_19.16: init %.39 = array_init (%.loc12_19.5, %.loc12_19.10, %.loc12_19.15) to file.%b.var
+// CHECK:STDOUT:   %.loc12_20: init %.39 = converted %a.ref, %.loc12_19.16
 // CHECK:STDOUT:   assign file.%b.var, %.loc12_20
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/array/base.carbon

@@ -27,27 +27,27 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %array.1: %.3 = tuple_value (%.28) [template]
-// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 64 [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %array.1: %.3 = tuple_value (%.32) [template]
+// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 64 [template]
 // CHECK:STDOUT:   %Float.type: type = fn_type @Float [template]
 // CHECK:STDOUT:   %Float: %Float.type = struct_value () [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.31: type = array_type %.30, f64 [template]
-// CHECK:STDOUT:   %.33: f64 = float_literal 11.100000000000001 [template]
-// CHECK:STDOUT:   %.34: f64 = float_literal 2.2000000000000002 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.35: type = array_type %.34, f64 [template]
+// CHECK:STDOUT:   %.37: f64 = float_literal 11.100000000000001 [template]
+// CHECK:STDOUT:   %.38: f64 = float_literal 2.2000000000000002 [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (f64, f64) [template]
-// CHECK:STDOUT:   %array.2: %.31 = tuple_value (%.33, %.34) [template]
-// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 5 [template]
-// CHECK:STDOUT:   %.36: type = array_type %.35, %empty_tuple.type [template]
+// CHECK:STDOUT:   %array.2: %.35 = tuple_value (%.37, %.38) [template]
+// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 5 [template]
+// CHECK:STDOUT:   %.40: type = array_type %.39, %empty_tuple.type [template]
 // CHECK:STDOUT:   %tuple.type.3: type = tuple_type (%empty_tuple.type, %empty_tuple.type, %empty_tuple.type, %empty_tuple.type, %empty_tuple.type) [template]
 // CHECK:STDOUT:   %empty_tuple: %empty_tuple.type = tuple_value () [template]
-// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 4 [template]
-// CHECK:STDOUT:   %array.3: %.36 = tuple_value (%empty_tuple, %empty_tuple, %empty_tuple, %empty_tuple, %empty_tuple) [template]
+// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.43: Core.IntLiteral = int_value 4 [template]
+// CHECK:STDOUT:   %array.3: %.40 = tuple_value (%empty_tuple, %empty_tuple, %empty_tuple, %empty_tuple, %empty_tuple) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -76,48 +76,48 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %.loc11_15: type = array_type %.loc11_14, %i32 [template = constants.%.3]
 // CHECK:STDOUT:   %a.var: ref %.3 = var a
 // CHECK:STDOUT:   %a: ref %.3 = bind_name a, %a.var
-// CHECK:STDOUT:   %.loc12_9.1: Core.IntLiteral = int_value 64 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_9.1: Core.IntLiteral = int_value 64 [template = constants.%.33]
 // CHECK:STDOUT:   %float.make_type: init type = call constants.%Float(%.loc12_9.1) [template = f64]
-// CHECK:STDOUT:   %.loc12_14: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_14: Core.IntLiteral = int_value 2 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc12_9.2: type = value_of_initializer %float.make_type [template = f64]
 // CHECK:STDOUT:   %.loc12_9.3: type = converted %float.make_type, %.loc12_9.2 [template = f64]
-// CHECK:STDOUT:   %.loc12_15: type = array_type %.loc12_14, f64 [template = constants.%.31]
-// CHECK:STDOUT:   %b.var: ref %.31 = var b
-// CHECK:STDOUT:   %b: ref %.31 = bind_name b, %b.var
+// CHECK:STDOUT:   %.loc12_15: type = array_type %.loc12_14, f64 [template = constants.%.35]
+// CHECK:STDOUT:   %b.var: ref %.35 = var b
+// CHECK:STDOUT:   %b: ref %.35 = bind_name b, %b.var
 // CHECK:STDOUT:   %.loc13_10.1: %empty_tuple.type = tuple_literal ()
-// CHECK:STDOUT:   %.loc13_13: Core.IntLiteral = int_value 5 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_13: Core.IntLiteral = int_value 5 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_10.2: type = converted %.loc13_10.1, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
-// CHECK:STDOUT:   %.loc13_14: type = array_type %.loc13_13, %empty_tuple.type [template = constants.%.36]
-// CHECK:STDOUT:   %c.var: ref %.36 = var c
-// CHECK:STDOUT:   %c: ref %.36 = bind_name c, %c.var
+// CHECK:STDOUT:   %.loc13_14: type = array_type %.loc13_13, %empty_tuple.type [template = constants.%.40]
+// CHECK:STDOUT:   %c.var: ref %.40 = var c
+// CHECK:STDOUT:   %c: ref %.40 = bind_name c, %c.var
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_20: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_22.1: %tuple.type.1 = tuple_literal (%.loc11_20)
-// CHECK:STDOUT:   %.loc11_22.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_22.3: <bound method> = bound_method %.loc11_20, %.loc11_22.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_22.4: <specific function> = specific_function %.loc11_22.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_22.4(%.loc11_20) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_22.5: init %i32 = converted %.loc11_20, %int.convert_checked [template = constants.%.28]
+// CHECK:STDOUT:   %.loc11_22.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_22.3: <bound method> = bound_method %.loc11_20, %.loc11_22.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_22.4: <specific function> = specific_function %.loc11_22.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_22.4(%.loc11_20) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_22.5: init %i32 = converted %.loc11_20, %int.convert_checked [template = constants.%.32]
 // CHECK:STDOUT:   %.loc11_22.6: Core.IntLiteral = int_value 0 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc11_22.7: ref %i32 = array_index file.%a.var, %.loc11_22.6
-// CHECK:STDOUT:   %.loc11_22.8: init %i32 = initialize_from %.loc11_22.5 to %.loc11_22.7 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc11_22.8: init %i32 = initialize_from %.loc11_22.5 to %.loc11_22.7 [template = constants.%.32]
 // CHECK:STDOUT:   %.loc11_22.9: init %.3 = array_init (%.loc11_22.8) to file.%a.var [template = constants.%array.1]
 // CHECK:STDOUT:   %.loc11_23: init %.3 = converted %.loc11_22.1, %.loc11_22.9 [template = constants.%array.1]
 // CHECK:STDOUT:   assign file.%a.var, %.loc11_23
-// CHECK:STDOUT:   %.loc12_20: f64 = float_literal 11.100000000000001 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_26: f64 = float_literal 2.2000000000000002 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_20: f64 = float_literal 11.100000000000001 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_26: f64 = float_literal 2.2000000000000002 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc12_30.1: %tuple.type.2 = tuple_literal (%.loc12_20, %.loc12_26)
 // CHECK:STDOUT:   %.loc12_30.2: Core.IntLiteral = int_value 0 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc12_30.3: ref f64 = array_index file.%b.var, %.loc12_30.2
-// CHECK:STDOUT:   %.loc12_30.4: init f64 = initialize_from %.loc12_20 to %.loc12_30.3 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_30.4: init f64 = initialize_from %.loc12_20 to %.loc12_30.3 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc12_30.5: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc12_30.6: ref f64 = array_index file.%b.var, %.loc12_30.5
-// CHECK:STDOUT:   %.loc12_30.7: init f64 = initialize_from %.loc12_26 to %.loc12_30.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc12_30.8: init %.31 = array_init (%.loc12_30.4, %.loc12_30.7) to file.%b.var [template = constants.%array.2]
-// CHECK:STDOUT:   %.loc12_31: init %.31 = converted %.loc12_30.1, %.loc12_30.8 [template = constants.%array.2]
+// CHECK:STDOUT:   %.loc12_30.7: init f64 = initialize_from %.loc12_26 to %.loc12_30.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc12_30.8: init %.35 = array_init (%.loc12_30.4, %.loc12_30.7) to file.%b.var [template = constants.%array.2]
+// CHECK:STDOUT:   %.loc12_31: init %.35 = converted %.loc12_30.1, %.loc12_30.8 [template = constants.%array.2]
 // CHECK:STDOUT:   assign file.%b.var, %.loc12_31
 // CHECK:STDOUT:   %.loc13_20.1: %empty_tuple.type = tuple_literal ()
 // CHECK:STDOUT:   %.loc13_24.1: %empty_tuple.type = tuple_literal ()
@@ -133,20 +133,20 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %.loc13_38.6: ref %empty_tuple.type = array_index file.%c.var, %.loc13_38.5
 // CHECK:STDOUT:   %.loc13_24.2: init %empty_tuple.type = tuple_init () to %.loc13_38.6 [template = constants.%empty_tuple]
 // CHECK:STDOUT:   %.loc13_38.7: init %empty_tuple.type = converted %.loc13_24.1, %.loc13_24.2 [template = constants.%empty_tuple]
-// CHECK:STDOUT:   %.loc13_38.8: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_38.8: Core.IntLiteral = int_value 2 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_38.9: ref %empty_tuple.type = array_index file.%c.var, %.loc13_38.8
 // CHECK:STDOUT:   %.loc13_28.2: init %empty_tuple.type = tuple_init () to %.loc13_38.9 [template = constants.%empty_tuple]
 // CHECK:STDOUT:   %.loc13_38.10: init %empty_tuple.type = converted %.loc13_28.1, %.loc13_28.2 [template = constants.%empty_tuple]
-// CHECK:STDOUT:   %.loc13_38.11: Core.IntLiteral = int_value 3 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_38.11: Core.IntLiteral = int_value 3 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc13_38.12: ref %empty_tuple.type = array_index file.%c.var, %.loc13_38.11
 // CHECK:STDOUT:   %.loc13_32.2: init %empty_tuple.type = tuple_init () to %.loc13_38.12 [template = constants.%empty_tuple]
 // CHECK:STDOUT:   %.loc13_38.13: init %empty_tuple.type = converted %.loc13_32.1, %.loc13_32.2 [template = constants.%empty_tuple]
-// CHECK:STDOUT:   %.loc13_38.14: Core.IntLiteral = int_value 4 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_38.14: Core.IntLiteral = int_value 4 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc13_38.15: ref %empty_tuple.type = array_index file.%c.var, %.loc13_38.14
 // CHECK:STDOUT:   %.loc13_36.2: init %empty_tuple.type = tuple_init () to %.loc13_38.15 [template = constants.%empty_tuple]
 // CHECK:STDOUT:   %.loc13_38.16: init %empty_tuple.type = converted %.loc13_36.1, %.loc13_36.2 [template = constants.%empty_tuple]
-// CHECK:STDOUT:   %.loc13_38.17: init %.36 = array_init (%.loc13_38.4, %.loc13_38.7, %.loc13_38.10, %.loc13_38.13, %.loc13_38.16) to file.%c.var [template = constants.%array.3]
-// CHECK:STDOUT:   %.loc13_39: init %.36 = converted %.loc13_38.1, %.loc13_38.17 [template = constants.%array.3]
+// CHECK:STDOUT:   %.loc13_38.17: init %.40 = array_init (%.loc13_38.4, %.loc13_38.7, %.loc13_38.10, %.loc13_38.13, %.loc13_38.16) to file.%c.var [template = constants.%array.3]
+// CHECK:STDOUT:   %.loc13_39: init %.40 = converted %.loc13_38.1, %.loc13_38.17 [template = constants.%array.3]
 // CHECK:STDOUT:   assign file.%c.var, %.loc13_39
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/array/canonicalize_index.carbon

@@ -35,33 +35,33 @@ let c: [i32; ConvertToU32(3)]* = &a;
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 3 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (Core.IntLiteral, Core.IntLiteral, Core.IntLiteral) [template]
-// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.38: <bound method> = bound_method %.34, %Convert.14 [template]
-// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %array: %.35 = tuple_value (%.26, %.29, %.30) [template]
-// CHECK:STDOUT:   %.40: %u32 = int_value 3 [template]
+// CHECK:STDOUT:   %.41: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.42: <bound method> = bound_method %.38, %Convert.14 [template]
+// CHECK:STDOUT:   %.43: <specific function> = specific_function %.42, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %array: %.39 = tuple_value (%.30, %.33, %.34) [template]
+// CHECK:STDOUT:   %.44: %u32 = int_value 3 [template]
 // CHECK:STDOUT:   %Convert.type.16: type = fn_type @Convert.5, @impl.4(%.1) [template]
 // CHECK:STDOUT:   %Convert.16: %Convert.type.16 = struct_value () [template]
-// CHECK:STDOUT:   %.41: <witness> = interface_witness (%Convert.16) [template]
-// CHECK:STDOUT:   %.42: <bound method> = bound_method %.40, %Convert.16 [template]
-// CHECK:STDOUT:   %.43: <specific function> = specific_function %.42, @Convert.5(%.1) [template]
+// CHECK:STDOUT:   %.45: <witness> = interface_witness (%Convert.16) [template]
+// CHECK:STDOUT:   %.46: <bound method> = bound_method %.44, %Convert.16 [template]
+// CHECK:STDOUT:   %.47: <specific function> = specific_function %.46, @Convert.5(%.1) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -135,62 +135,62 @@ let c: [i32; ConvertToU32(3)]* = &a;
 // CHECK:STDOUT:   %Add.ref: %Add.type = name_ref Add, %Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc14_18.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_21.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc14_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_18.3: <bound method> = bound_method %.loc14_18.1, %.loc14_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc14_18.4: <specific function> = specific_function %.loc14_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc14_18: init %i32 = call %.loc14_18.4(%.loc14_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_18.5: %i32 = value_of_initializer %int.convert_checked.loc14_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_18.6: %i32 = converted %.loc14_18.1, %.loc14_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_21.3: <bound method> = bound_method %.loc14_21.1, %.loc14_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc14_21.4: <specific function> = specific_function %.loc14_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc14_21: init %i32 = call %.loc14_21.4(%.loc14_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_21.5: %i32 = value_of_initializer %int.convert_checked.loc14_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_21.6: %i32 = converted %.loc14_21.1, %.loc14_21.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.sadd: init %i32 = call %Add.ref(%.loc14_18.6, %.loc14_21.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_18.3: <bound method> = bound_method %.loc14_18.1, %.loc14_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc14_18.4: <specific function> = specific_function %.loc14_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc14_18: init %i32 = call %.loc14_18.4(%.loc14_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_18.5: %i32 = value_of_initializer %int.convert_checked.loc14_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_18.6: %i32 = converted %.loc14_18.1, %.loc14_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_21.3: <bound method> = bound_method %.loc14_21.1, %.loc14_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc14_21.4: <specific function> = specific_function %.loc14_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc14_21: init %i32 = call %.loc14_21.4(%.loc14_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_21.5: %i32 = value_of_initializer %int.convert_checked.loc14_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_21.6: %i32 = converted %.loc14_21.1, %.loc14_21.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.sadd: init %i32 = call %Add.ref(%.loc14_18.6, %.loc14_21.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc14_9.2: type = value_of_initializer %int.make_type_signed.loc14 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc14_9.3: type = converted %int.make_type_signed.loc14, %.loc14_9.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc14_17.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc14_17.2: <bound method> = bound_method %int.sadd, %.loc14_17.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc14_17.3: <specific function> = specific_function %.loc14_17.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc14_17.4: %i32 = value_of_initializer %int.sadd [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_17.5: %i32 = converted %int.sadd, %.loc14_17.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc14_17: init Core.IntLiteral = call %.loc14_17.3(%.loc14_17.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc14_17.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_17 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc14_17.7: Core.IntLiteral = converted %int.sadd, %.loc14_17.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc14_23: type = array_type %.loc14_17.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %a.var: ref %.35 = var a
-// CHECK:STDOUT:   %a: ref %.35 = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc14_17.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc14_17.2: <bound method> = bound_method %int.sadd, %.loc14_17.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc14_17.3: <specific function> = specific_function %.loc14_17.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc14_17.4: %i32 = value_of_initializer %int.sadd [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_17.5: %i32 = converted %int.sadd, %.loc14_17.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc14_17: init Core.IntLiteral = call %.loc14_17.3(%.loc14_17.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc14_17.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_17 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc14_17.7: Core.IntLiteral = converted %int.sadd, %.loc14_17.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc14_23: type = array_type %.loc14_17.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %a.var: ref %.39 = var a
+// CHECK:STDOUT:   %a: ref %.39 = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc15_9.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc15: init type = call constants.%Int(%.loc15_9.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_14: Core.IntLiteral = int_value 3 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_14: Core.IntLiteral = int_value 3 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc15_9.2: type = value_of_initializer %int.make_type_signed.loc15 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc15_9.3: type = converted %int.make_type_signed.loc15, %.loc15_9.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_15: type = array_type %.loc15_14, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc15_16: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_15: type = array_type %.loc15_14, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc15_16: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc16_9.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc16: init type = call constants.%Int(%.loc16_9.1) [template = constants.%i32]
 // CHECK:STDOUT:   %ConvertToU32.ref: %ConvertToU32.type = name_ref ConvertToU32, %ConvertToU32.decl [template = constants.%ConvertToU32]
-// CHECK:STDOUT:   %.loc16_27.1: Core.IntLiteral = int_value 3 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_27.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_27.3: <bound method> = bound_method %.loc16_27.1, %.loc16_27.2 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc16_27.4: <specific function> = specific_function %.loc16_27.3, @Convert.2(constants.%.1) [template = constants.%.39]
-// CHECK:STDOUT:   %int.convert_checked.loc16_27: init %i32 = call %.loc16_27.4(%.loc16_27.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_27.5: %i32 = value_of_initializer %int.convert_checked.loc16_27 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_27.6: %i32 = converted %.loc16_27.1, %.loc16_27.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc16_26.1: init %u32 = call %ConvertToU32.ref(%.loc16_27.6) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc16_27.1: Core.IntLiteral = int_value 3 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_27.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_27.3: <bound method> = bound_method %.loc16_27.1, %.loc16_27.2 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc16_27.4: <specific function> = specific_function %.loc16_27.3, @Convert.2(constants.%.1) [template = constants.%.43]
+// CHECK:STDOUT:   %int.convert_checked.loc16_27: init %i32 = call %.loc16_27.4(%.loc16_27.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_27.5: %i32 = value_of_initializer %int.convert_checked.loc16_27 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_27.6: %i32 = converted %.loc16_27.1, %.loc16_27.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc16_26.1: init %u32 = call %ConvertToU32.ref(%.loc16_27.6) [template = constants.%.44]
 // CHECK:STDOUT:   %.loc16_9.2: type = value_of_initializer %int.make_type_signed.loc16 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc16_9.3: type = converted %int.make_type_signed.loc16, %.loc16_9.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc16_26.1: %Convert.type.6 = interface_witness_access constants.%.41, element0 [template = constants.%Convert.16]
-// CHECK:STDOUT:   %.loc16_26.2: <bound method> = bound_method %int.convert_checked.loc16_26.1, %.loc16_26.1 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc16_26.3: <specific function> = specific_function %.loc16_26.2, @Convert.5(constants.%.1) [template = constants.%.43]
-// CHECK:STDOUT:   %.loc16_26.4: %u32 = value_of_initializer %int.convert_checked.loc16_26.1 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc16_26.5: %u32 = converted %int.convert_checked.loc16_26.1, %.loc16_26.4 [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc16_26.2: init Core.IntLiteral = call %.loc16_26.3(%.loc16_26.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_26.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc16_26.2 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_26.7: Core.IntLiteral = converted %int.convert_checked.loc16_26.1, %.loc16_26.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_29: type = array_type %.loc16_26.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc16_30: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc16_26.1: %Convert.type.6 = interface_witness_access constants.%.45, element0 [template = constants.%Convert.16]
+// CHECK:STDOUT:   %.loc16_26.2: <bound method> = bound_method %int.convert_checked.loc16_26.1, %.loc16_26.1 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc16_26.3: <specific function> = specific_function %.loc16_26.2, @Convert.5(constants.%.1) [template = constants.%.47]
+// CHECK:STDOUT:   %.loc16_26.4: %u32 = value_of_initializer %int.convert_checked.loc16_26.1 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc16_26.5: %u32 = converted %int.convert_checked.loc16_26.1, %.loc16_26.4 [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc16_26.2: init Core.IntLiteral = call %.loc16_26.3(%.loc16_26.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_26.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc16_26.2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_26.7: Core.IntLiteral = converted %int.convert_checked.loc16_26.1, %.loc16_26.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_29: type = array_type %.loc16_26.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc16_30: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Add(%a.param_patt: %i32, %b.param_patt: %i32) -> %i32 = "int.sadd";
@@ -201,41 +201,41 @@ let c: [i32; ConvertToU32(3)]* = &a;
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc14_28: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_31: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc14_34: Core.IntLiteral = int_value 3 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_34: Core.IntLiteral = int_value 3 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc14_35.1: %tuple.type = tuple_literal (%.loc14_28, %.loc14_31, %.loc14_34)
-// CHECK:STDOUT:   %.loc14_35.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_35.3: <bound method> = bound_method %.loc14_28, %.loc14_35.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc14_35.4: <specific function> = specific_function %.loc14_35.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc14_35.1: init %i32 = call %.loc14_35.4(%.loc14_28) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_35.5: init %i32 = converted %.loc14_28, %int.convert_checked.loc14_35.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_35.6: Core.IntLiteral = int_value 0 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc14_35.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_35.3: <bound method> = bound_method %.loc14_28, %.loc14_35.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc14_35.4: <specific function> = specific_function %.loc14_35.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc14_35.1: init %i32 = call %.loc14_35.4(%.loc14_28) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_35.5: init %i32 = converted %.loc14_28, %int.convert_checked.loc14_35.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_35.6: Core.IntLiteral = int_value 0 [template = constants.%.41]
 // CHECK:STDOUT:   %.loc14_35.7: ref %i32 = array_index file.%a.var, %.loc14_35.6
-// CHECK:STDOUT:   %.loc14_35.8: init %i32 = initialize_from %.loc14_35.5 to %.loc14_35.7 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_35.9: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_35.10: <bound method> = bound_method %.loc14_31, %.loc14_35.9 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc14_35.11: <specific function> = specific_function %.loc14_35.10, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc14_35.2: init %i32 = call %.loc14_35.11(%.loc14_31) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_35.12: init %i32 = converted %.loc14_31, %int.convert_checked.loc14_35.2 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_35.8: init %i32 = initialize_from %.loc14_35.5 to %.loc14_35.7 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_35.9: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_35.10: <bound method> = bound_method %.loc14_31, %.loc14_35.9 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc14_35.11: <specific function> = specific_function %.loc14_35.10, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc14_35.2: init %i32 = call %.loc14_35.11(%.loc14_31) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_35.12: init %i32 = converted %.loc14_31, %int.convert_checked.loc14_35.2 [template = constants.%.33]
 // CHECK:STDOUT:   %.loc14_35.13: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_35.14: ref %i32 = array_index file.%a.var, %.loc14_35.13
-// CHECK:STDOUT:   %.loc14_35.15: init %i32 = initialize_from %.loc14_35.12 to %.loc14_35.14 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_35.16: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_35.17: <bound method> = bound_method %.loc14_34, %.loc14_35.16 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc14_35.18: <specific function> = specific_function %.loc14_35.17, @Convert.2(constants.%.1) [template = constants.%.39]
-// CHECK:STDOUT:   %int.convert_checked.loc14_35.3: init %i32 = call %.loc14_35.18(%.loc14_34) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_35.19: init %i32 = converted %.loc14_34, %int.convert_checked.loc14_35.3 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_35.15: init %i32 = initialize_from %.loc14_35.12 to %.loc14_35.14 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_35.16: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_35.17: <bound method> = bound_method %.loc14_34, %.loc14_35.16 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc14_35.18: <specific function> = specific_function %.loc14_35.17, @Convert.2(constants.%.1) [template = constants.%.43]
+// CHECK:STDOUT:   %int.convert_checked.loc14_35.3: init %i32 = call %.loc14_35.18(%.loc14_34) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_35.19: init %i32 = converted %.loc14_34, %int.convert_checked.loc14_35.3 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc14_35.20: Core.IntLiteral = int_value 2 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc14_35.21: ref %i32 = array_index file.%a.var, %.loc14_35.20
-// CHECK:STDOUT:   %.loc14_35.22: init %i32 = initialize_from %.loc14_35.19 to %.loc14_35.21 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_35.23: init %.35 = array_init (%.loc14_35.8, %.loc14_35.15, %.loc14_35.22) to file.%a.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc14_36: init %.35 = converted %.loc14_35.1, %.loc14_35.23 [template = constants.%array]
+// CHECK:STDOUT:   %.loc14_35.22: init %i32 = initialize_from %.loc14_35.19 to %.loc14_35.21 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_35.23: init %.39 = array_init (%.loc14_35.8, %.loc14_35.15, %.loc14_35.22) to file.%a.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc14_36: init %.39 = converted %.loc14_35.1, %.loc14_35.23 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%a.var, %.loc14_36
-// CHECK:STDOUT:   %a.ref.loc15: ref %.35 = name_ref a, file.%a
-// CHECK:STDOUT:   %.loc15: %.36 = addr_of %a.ref.loc15
-// CHECK:STDOUT:   %b: %.36 = bind_name b, %.loc15
-// CHECK:STDOUT:   %a.ref.loc16: ref %.35 = name_ref a, file.%a
-// CHECK:STDOUT:   %.loc16: %.36 = addr_of %a.ref.loc16
-// CHECK:STDOUT:   %c: %.36 = bind_name c, %.loc16
+// CHECK:STDOUT:   %a.ref.loc15: ref %.39 = name_ref a, file.%a
+// CHECK:STDOUT:   %.loc15: %.40 = addr_of %a.ref.loc15
+// CHECK:STDOUT:   %b: %.40 = bind_name b, %.loc15
+// CHECK:STDOUT:   %a.ref.loc16: ref %.39 = name_ref a, file.%a
+// CHECK:STDOUT:   %.loc16: %.40 = addr_of %a.ref.loc16
+// CHECK:STDOUT:   %c: %.40 = bind_name c, %.loc16
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/array/fail_bound_negative.carbon

@@ -29,17 +29,17 @@ var a: [i32; Negate(1)];
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.26, %Convert.15 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value -1 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value -1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -81,23 +81,23 @@ var a: [i32; Negate(1)];
 // CHECK:STDOUT:   %int.make_type_signed: init type = call constants.%Int(%.loc16_9.1) [template = constants.%i32]
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc16_21.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc16_21.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_21.3: <bound method> = bound_method %.loc16_21.1, %.loc16_21.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc16_21.4: <specific function> = specific_function %.loc16_21.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc16_21: init %i32 = call %.loc16_21.4(%.loc16_21.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc16_21.5: %i32 = value_of_initializer %int.convert_checked.loc16_21 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc16_21.6: %i32 = converted %.loc16_21.1, %.loc16_21.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc16_21.6) [template = constants.%.26]
+// CHECK:STDOUT:   %.loc16_21.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_21.3: <bound method> = bound_method %.loc16_21.1, %.loc16_21.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc16_21.4: <specific function> = specific_function %.loc16_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc16_21: init %i32 = call %.loc16_21.4(%.loc16_21.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc16_21.5: %i32 = value_of_initializer %int.convert_checked.loc16_21 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc16_21.6: %i32 = converted %.loc16_21.1, %.loc16_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc16_21.6) [template = constants.%.30]
 // CHECK:STDOUT:   %.loc16_9.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:   %.loc16_9.3: type = converted %int.make_type_signed, %.loc16_9.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc16_20.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc16_20.2: <bound method> = bound_method %int.snegate, %.loc16_20.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc16_20.3: <specific function> = specific_function %.loc16_20.2, @Convert.4(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc16_20.4: %i32 = value_of_initializer %int.snegate [template = constants.%.26]
-// CHECK:STDOUT:   %.loc16_20.5: %i32 = converted %int.snegate, %.loc16_20.4 [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked.loc16_20: init Core.IntLiteral = call %.loc16_20.3(%.loc16_20.5) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_20.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc16_20 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_20.7: Core.IntLiteral = converted %int.snegate, %.loc16_20.6 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc16_20.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc16_20.2: <bound method> = bound_method %int.snegate, %.loc16_20.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc16_20.3: <specific function> = specific_function %.loc16_20.2, @Convert.4(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc16_20.4: %i32 = value_of_initializer %int.snegate [template = constants.%.30]
+// CHECK:STDOUT:   %.loc16_20.5: %i32 = converted %int.snegate, %.loc16_20.4 [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked.loc16_20: init Core.IntLiteral = call %.loc16_20.3(%.loc16_20.5) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_20.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc16_20 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_20.7: Core.IntLiteral = converted %int.snegate, %.loc16_20.6 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc16_23: type = array_type %.loc16_20.7, %i32 [template = <error>]
 // CHECK:STDOUT:   %a.var: ref <error> = var a
 // CHECK:STDOUT:   %a: ref <error> = bind_name a, %a.var

toolchain/check/testdata/array/fail_out_of_bound_non_literal.carbon

@@ -30,19 +30,19 @@ var b: i32 = a[{.index = 3}.index];
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %array: %.3 = tuple_value (%.30, %.33, %.36) [template]
-// CHECK:STDOUT:   %.37: type = struct_type {.index: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %struct: %.37 = struct_value (%.2) [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %array: %.3 = tuple_value (%.34, %.37, %.40) [template]
+// CHECK:STDOUT:   %.41: type = struct_type {.index: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %struct: %.41 = struct_value (%.2) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -83,45 +83,45 @@ var b: i32 = a[{.index = 3}.index];
 // CHECK:STDOUT:   %.loc11_23: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc11_26: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_27.1: %tuple.type = tuple_literal (%.loc11_20, %.loc11_23, %.loc11_26)
-// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_20, %.loc11_27.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27.1: init %i32 = call %.loc11_27.4(%.loc11_20) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_27.5: init %i32 = converted %.loc11_20, %int.convert_checked.loc11_27.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_20, %.loc11_27.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27.1: init %i32 = call %.loc11_27.4(%.loc11_20) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_27.5: init %i32 = converted %.loc11_20, %int.convert_checked.loc11_27.1 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc11_27.6: Core.IntLiteral = int_value 0 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_27.7: ref %i32 = array_index file.%a.var, %.loc11_27.6
-// CHECK:STDOUT:   %.loc11_27.8: init %i32 = initialize_from %.loc11_27.5 to %.loc11_27.7 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_27.9: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.10: <bound method> = bound_method %.loc11_23, %.loc11_27.9 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_27.11: <specific function> = specific_function %.loc11_27.10, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27.2: init %i32 = call %.loc11_27.11(%.loc11_23) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc11_27.12: init %i32 = converted %.loc11_23, %int.convert_checked.loc11_27.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_27.8: init %i32 = initialize_from %.loc11_27.5 to %.loc11_27.7 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_27.9: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.10: <bound method> = bound_method %.loc11_23, %.loc11_27.9 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_27.11: <specific function> = specific_function %.loc11_27.10, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27.2: init %i32 = call %.loc11_27.11(%.loc11_23) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc11_27.12: init %i32 = converted %.loc11_23, %int.convert_checked.loc11_27.2 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc11_27.13: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc11_27.14: ref %i32 = array_index file.%a.var, %.loc11_27.13
-// CHECK:STDOUT:   %.loc11_27.15: init %i32 = initialize_from %.loc11_27.12 to %.loc11_27.14 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc11_27.16: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.17: <bound method> = bound_method %.loc11_26, %.loc11_27.16 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_27.18: <specific function> = specific_function %.loc11_27.17, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27.3: init %i32 = call %.loc11_27.18(%.loc11_26) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_27.19: init %i32 = converted %.loc11_26, %int.convert_checked.loc11_27.3 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc11_27.15: init %i32 = initialize_from %.loc11_27.12 to %.loc11_27.14 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc11_27.16: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.17: <bound method> = bound_method %.loc11_26, %.loc11_27.16 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_27.18: <specific function> = specific_function %.loc11_27.17, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27.3: init %i32 = call %.loc11_27.18(%.loc11_26) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_27.19: init %i32 = converted %.loc11_26, %int.convert_checked.loc11_27.3 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc11_27.20: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc11_27.21: ref %i32 = array_index file.%a.var, %.loc11_27.20
-// CHECK:STDOUT:   %.loc11_27.22: init %i32 = initialize_from %.loc11_27.19 to %.loc11_27.21 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc11_27.22: init %i32 = initialize_from %.loc11_27.19 to %.loc11_27.21 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc11_27.23: init %.3 = array_init (%.loc11_27.8, %.loc11_27.15, %.loc11_27.22) to file.%a.var [template = constants.%array]
 // CHECK:STDOUT:   %.loc11_28: init %.3 = converted %.loc11_27.1, %.loc11_27.23 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%a.var, %.loc11_28
 // CHECK:STDOUT:   %a.ref: ref %.3 = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc15_26: Core.IntLiteral = int_value 3 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc15_27.1: %.37 = struct_literal (%.loc15_26)
-// CHECK:STDOUT:   %struct: %.37 = struct_value (%.loc15_26) [template = constants.%struct]
-// CHECK:STDOUT:   %.loc15_27.2: %.37 = converted %.loc15_27.1, %struct [template = constants.%struct]
+// CHECK:STDOUT:   %.loc15_27.1: %.41 = struct_literal (%.loc15_26)
+// CHECK:STDOUT:   %struct: %.41 = struct_value (%.loc15_26) [template = constants.%struct]
+// CHECK:STDOUT:   %.loc15_27.2: %.41 = converted %.loc15_27.1, %struct [template = constants.%struct]
 // CHECK:STDOUT:   %.loc15_28.1: Core.IntLiteral = struct_access %.loc15_27.2, element0 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc15_28.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_28.3: <bound method> = bound_method %.loc15_28.1, %.loc15_28.2 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc15_28.4: <specific function> = specific_function %.loc15_28.3, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_28.4(%.loc15_28.1) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc15_28.5: %i32 = value_of_initializer %int.convert_checked.loc15 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc15_28.6: %i32 = converted %.loc15_28.1, %.loc15_28.5 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_28.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_28.3: <bound method> = bound_method %.loc15_28.1, %.loc15_28.2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc15_28.4: <specific function> = specific_function %.loc15_28.3, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_28.4(%.loc15_28.1) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc15_28.5: %i32 = value_of_initializer %int.convert_checked.loc15 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc15_28.6: %i32 = converted %.loc15_28.1, %.loc15_28.5 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc15_34.1: ref %i32 = array_index %a.ref, %.loc15_28.6 [template = <error>]
 // CHECK:STDOUT:   %.loc15_34.2: %i32 = bind_value %.loc15_34.1
 // CHECK:STDOUT:   assign file.%b.var, %.loc15_34.2

toolchain/check/testdata/array/fail_type_mismatch.carbon

@@ -56,13 +56,13 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (type, type, type) [template]
 // CHECK:STDOUT:   %tuple.type.3: type = tuple_type (%i32, String, String) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 2 [template]
 // CHECK:STDOUT:   %tuple.type.5: type = tuple_type (Core.IntLiteral, Core.IntLiteral) [template]
 // CHECK:STDOUT:   %tuple.type.6: type = tuple_type (type, type) [template]
 // CHECK:STDOUT:   %tuple.type.7: type = tuple_type (%i32, %i32) [template]
@@ -148,14 +148,14 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc18_23: String = string_literal "Hello" [template = constants.%.7]
 // CHECK:STDOUT:   %.loc18_32: String = string_literal "World" [template = constants.%.8]
 // CHECK:STDOUT:   %.loc18_39.1: %tuple.type.1 = tuple_literal (%.loc18_20, %.loc18_23, %.loc18_32)
-// CHECK:STDOUT:   %.loc18_39.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_39.3: <bound method> = bound_method %.loc18_20, %.loc18_39.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc18_39.4: <specific function> = specific_function %.loc18_39.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc18_39.4(%.loc18_20) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc18_39.5: init %i32 = converted %.loc18_20, %int.convert_checked [template = constants.%.32]
+// CHECK:STDOUT:   %.loc18_39.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_39.3: <bound method> = bound_method %.loc18_20, %.loc18_39.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc18_39.4: <specific function> = specific_function %.loc18_39.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc18_39.4(%.loc18_20) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc18_39.5: init %i32 = converted %.loc18_20, %int.convert_checked [template = constants.%.36]
 // CHECK:STDOUT:   %.loc18_39.6: Core.IntLiteral = int_value 0 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc18_39.7: ref %i32 = array_index file.%a.var, %.loc18_39.6
-// CHECK:STDOUT:   %.loc18_39.8: init %i32 = initialize_from %.loc18_39.5 to %.loc18_39.7 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc18_39.8: init %i32 = initialize_from %.loc18_39.5 to %.loc18_39.7 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc18_39.9: %i32 = converted %.loc18_23, <error> [template = <error>]
 // CHECK:STDOUT:   assign file.%a.var, <error>
 // CHECK:STDOUT:   %t1.ref: ref %tuple.type.3 = name_ref t1, file.%t1
@@ -168,7 +168,7 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc28_19.7: %i32 = converted %.loc28_19.6, <error> [template = <error>]
 // CHECK:STDOUT:   assign file.%b.var, <error>
 // CHECK:STDOUT:   %.loc34_20: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc34_23: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc34_23: Core.IntLiteral = int_value 2 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc34_24: %tuple.type.5 = tuple_literal (%.loc34_20, %.loc34_23)
 // CHECK:STDOUT:   assign file.%c.var, <error>
 // CHECK:STDOUT:   %t2.ref: ref %tuple.type.7 = name_ref t2, file.%t2

toolchain/check/testdata/array/function_param.carbon

@@ -36,17 +36,17 @@ fn G() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %array: %.3 = tuple_value (%.30, %.33, %.36) [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %array: %.3 = tuple_value (%.34, %.37, %.40) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -125,41 +125,41 @@ fn G() -> i32 {
 // CHECK:STDOUT:   %.loc16_19: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc16_20.1: %tuple.type = tuple_literal (%.loc16_13, %.loc16_16, %.loc16_19)
 // CHECK:STDOUT:   %.loc16_23.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc16_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_20.3: <bound method> = bound_method %.loc16_13, %.loc16_20.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc16_20.4: <specific function> = specific_function %.loc16_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc16_20.1: init %i32 = call %.loc16_20.4(%.loc16_13) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_20.5: init %i32 = converted %.loc16_13, %int.convert_checked.loc16_20.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc16_20.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_20.3: <bound method> = bound_method %.loc16_13, %.loc16_20.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc16_20.4: <specific function> = specific_function %.loc16_20.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc16_20.1: init %i32 = call %.loc16_20.4(%.loc16_13) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_20.5: init %i32 = converted %.loc16_13, %int.convert_checked.loc16_20.1 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc16_20.6: ref %.3 = temporary_storage
 // CHECK:STDOUT:   %.loc16_20.7: Core.IntLiteral = int_value 0 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc16_20.8: ref %i32 = array_index %.loc16_20.6, %.loc16_20.7
-// CHECK:STDOUT:   %.loc16_20.9: init %i32 = initialize_from %.loc16_20.5 to %.loc16_20.8 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_20.10: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_20.11: <bound method> = bound_method %.loc16_16, %.loc16_20.10 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc16_20.12: <specific function> = specific_function %.loc16_20.11, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc16_20.2: init %i32 = call %.loc16_20.12(%.loc16_16) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc16_20.13: init %i32 = converted %.loc16_16, %int.convert_checked.loc16_20.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc16_20.9: init %i32 = initialize_from %.loc16_20.5 to %.loc16_20.8 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_20.10: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_20.11: <bound method> = bound_method %.loc16_16, %.loc16_20.10 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc16_20.12: <specific function> = specific_function %.loc16_20.11, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc16_20.2: init %i32 = call %.loc16_20.12(%.loc16_16) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc16_20.13: init %i32 = converted %.loc16_16, %int.convert_checked.loc16_20.2 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc16_20.14: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc16_20.15: ref %i32 = array_index %.loc16_20.6, %.loc16_20.14
-// CHECK:STDOUT:   %.loc16_20.16: init %i32 = initialize_from %.loc16_20.13 to %.loc16_20.15 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc16_20.17: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_20.18: <bound method> = bound_method %.loc16_19, %.loc16_20.17 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_20.19: <specific function> = specific_function %.loc16_20.18, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc16_20.3: init %i32 = call %.loc16_20.19(%.loc16_19) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc16_20.20: init %i32 = converted %.loc16_19, %int.convert_checked.loc16_20.3 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc16_20.16: init %i32 = initialize_from %.loc16_20.13 to %.loc16_20.15 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc16_20.17: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_20.18: <bound method> = bound_method %.loc16_19, %.loc16_20.17 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_20.19: <specific function> = specific_function %.loc16_20.18, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc16_20.3: init %i32 = call %.loc16_20.19(%.loc16_19) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc16_20.20: init %i32 = converted %.loc16_19, %int.convert_checked.loc16_20.3 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc16_20.21: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc16_20.22: ref %i32 = array_index %.loc16_20.6, %.loc16_20.21
-// CHECK:STDOUT:   %.loc16_20.23: init %i32 = initialize_from %.loc16_20.20 to %.loc16_20.22 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc16_20.23: init %i32 = initialize_from %.loc16_20.20 to %.loc16_20.22 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc16_20.24: init %.3 = array_init (%.loc16_20.9, %.loc16_20.16, %.loc16_20.23) to %.loc16_20.6 [template = constants.%array]
 // CHECK:STDOUT:   %.loc16_20.25: init %.3 = converted %.loc16_20.1, %.loc16_20.24 [template = constants.%array]
 // CHECK:STDOUT:   %.loc16_20.26: ref %.3 = temporary %.loc16_20.6, %.loc16_20.25
 // CHECK:STDOUT:   %.loc16_20.27: %.3 = bind_value %.loc16_20.26
-// CHECK:STDOUT:   %.loc16_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_23.3: <bound method> = bound_method %.loc16_23.1, %.loc16_23.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc16_23.4: <specific function> = specific_function %.loc16_23.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc16_23: init %i32 = call %.loc16_23.4(%.loc16_23.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_23.5: %i32 = value_of_initializer %int.convert_checked.loc16_23 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_23.6: %i32 = converted %.loc16_23.1, %.loc16_23.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc16_23.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_23.3: <bound method> = bound_method %.loc16_23.1, %.loc16_23.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc16_23.4: <specific function> = specific_function %.loc16_23.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc16_23: init %i32 = call %.loc16_23.4(%.loc16_23.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_23.5: %i32 = value_of_initializer %int.convert_checked.loc16_23 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_23.6: %i32 = converted %.loc16_23.1, %.loc16_23.5 [template = constants.%.34]
 // CHECK:STDOUT:   %F.call: init %i32 = call %F.ref(%.loc16_20.27, %.loc16_23.6)
 // CHECK:STDOUT:   %.loc16_25.1: %i32 = value_of_initializer %F.call
 // CHECK:STDOUT:   %.loc16_25.2: %i32 = converted %F.call, %.loc16_25.1

toolchain/check/testdata/array/index_not_literal.carbon

@@ -27,19 +27,19 @@ var b: i32 = a[{.index = 2}.index];
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %array: %.3 = tuple_value (%.30, %.33, %.36) [template]
-// CHECK:STDOUT:   %.37: type = struct_type {.index: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %struct: %.37 = struct_value (%.6) [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %array: %.3 = tuple_value (%.34, %.37, %.40) [template]
+// CHECK:STDOUT:   %.41: type = struct_type {.index: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %struct: %.41 = struct_value (%.6) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -80,45 +80,45 @@ var b: i32 = a[{.index = 2}.index];
 // CHECK:STDOUT:   %.loc11_23: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc11_26: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_27.1: %tuple.type = tuple_literal (%.loc11_20, %.loc11_23, %.loc11_26)
-// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_20, %.loc11_27.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27.1: init %i32 = call %.loc11_27.4(%.loc11_20) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_27.5: init %i32 = converted %.loc11_20, %int.convert_checked.loc11_27.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_20, %.loc11_27.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27.1: init %i32 = call %.loc11_27.4(%.loc11_20) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_27.5: init %i32 = converted %.loc11_20, %int.convert_checked.loc11_27.1 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc11_27.6: Core.IntLiteral = int_value 0 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_27.7: ref %i32 = array_index file.%a.var, %.loc11_27.6
-// CHECK:STDOUT:   %.loc11_27.8: init %i32 = initialize_from %.loc11_27.5 to %.loc11_27.7 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_27.9: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.10: <bound method> = bound_method %.loc11_23, %.loc11_27.9 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_27.11: <specific function> = specific_function %.loc11_27.10, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27.2: init %i32 = call %.loc11_27.11(%.loc11_23) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc11_27.12: init %i32 = converted %.loc11_23, %int.convert_checked.loc11_27.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_27.8: init %i32 = initialize_from %.loc11_27.5 to %.loc11_27.7 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_27.9: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.10: <bound method> = bound_method %.loc11_23, %.loc11_27.9 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_27.11: <specific function> = specific_function %.loc11_27.10, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27.2: init %i32 = call %.loc11_27.11(%.loc11_23) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc11_27.12: init %i32 = converted %.loc11_23, %int.convert_checked.loc11_27.2 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc11_27.13: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc11_27.14: ref %i32 = array_index file.%a.var, %.loc11_27.13
-// CHECK:STDOUT:   %.loc11_27.15: init %i32 = initialize_from %.loc11_27.12 to %.loc11_27.14 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc11_27.16: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.17: <bound method> = bound_method %.loc11_26, %.loc11_27.16 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_27.18: <specific function> = specific_function %.loc11_27.17, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27.3: init %i32 = call %.loc11_27.18(%.loc11_26) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_27.19: init %i32 = converted %.loc11_26, %int.convert_checked.loc11_27.3 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc11_27.15: init %i32 = initialize_from %.loc11_27.12 to %.loc11_27.14 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc11_27.16: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.17: <bound method> = bound_method %.loc11_26, %.loc11_27.16 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_27.18: <specific function> = specific_function %.loc11_27.17, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27.3: init %i32 = call %.loc11_27.18(%.loc11_26) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_27.19: init %i32 = converted %.loc11_26, %int.convert_checked.loc11_27.3 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc11_27.20: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc11_27.21: ref %i32 = array_index file.%a.var, %.loc11_27.20
-// CHECK:STDOUT:   %.loc11_27.22: init %i32 = initialize_from %.loc11_27.19 to %.loc11_27.21 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc11_27.22: init %i32 = initialize_from %.loc11_27.19 to %.loc11_27.21 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc11_27.23: init %.3 = array_init (%.loc11_27.8, %.loc11_27.15, %.loc11_27.22) to file.%a.var [template = constants.%array]
 // CHECK:STDOUT:   %.loc11_28: init %.3 = converted %.loc11_27.1, %.loc11_27.23 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%a.var, %.loc11_28
 // CHECK:STDOUT:   %a.ref: ref %.3 = name_ref a, file.%a
 // CHECK:STDOUT:   %.loc12_26: Core.IntLiteral = int_value 2 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc12_27.1: %.37 = struct_literal (%.loc12_26)
-// CHECK:STDOUT:   %struct: %.37 = struct_value (%.loc12_26) [template = constants.%struct]
-// CHECK:STDOUT:   %.loc12_27.2: %.37 = converted %.loc12_27.1, %struct [template = constants.%struct]
+// CHECK:STDOUT:   %.loc12_27.1: %.41 = struct_literal (%.loc12_26)
+// CHECK:STDOUT:   %struct: %.41 = struct_value (%.loc12_26) [template = constants.%struct]
+// CHECK:STDOUT:   %.loc12_27.2: %.41 = converted %.loc12_27.1, %struct [template = constants.%struct]
 // CHECK:STDOUT:   %.loc12_28.1: Core.IntLiteral = struct_access %.loc12_27.2, element0 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc12_28.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_28.3: <bound method> = bound_method %.loc12_28.1, %.loc12_28.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc12_28.4: <specific function> = specific_function %.loc12_28.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc12: init %i32 = call %.loc12_28.4(%.loc12_28.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_28.5: %i32 = value_of_initializer %int.convert_checked.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_28.6: %i32 = converted %.loc12_28.1, %.loc12_28.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_28.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_28.3: <bound method> = bound_method %.loc12_28.1, %.loc12_28.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc12_28.4: <specific function> = specific_function %.loc12_28.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc12: init %i32 = call %.loc12_28.4(%.loc12_28.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_28.5: %i32 = value_of_initializer %int.convert_checked.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_28.6: %i32 = converted %.loc12_28.1, %.loc12_28.5 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc12_34.1: ref %i32 = array_index %a.ref, %.loc12_28.6
 // CHECK:STDOUT:   %.loc12_34.2: %i32 = bind_value %.loc12_34.1
 // CHECK:STDOUT:   assign file.%b.var, %.loc12_34.2

toolchain/check/testdata/array/nine_elements.carbon

@@ -32,35 +32,35 @@ var a: [i32; 9] = (1, 2, 3, 4, 5, 6, 7, 8, 9);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.40: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.41: <specific function> = specific_function %.40, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.42: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.43: <bound method> = bound_method %.8, %Convert.14 [template]
-// CHECK:STDOUT:   %.44: <specific function> = specific_function %.43, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.45: %i32 = int_value 4 [template]
-// CHECK:STDOUT:   %.46: <bound method> = bound_method %.9, %Convert.14 [template]
-// CHECK:STDOUT:   %.47: <specific function> = specific_function %.46, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.48: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.49: <bound method> = bound_method %.10, %Convert.14 [template]
-// CHECK:STDOUT:   %.50: <specific function> = specific_function %.49, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.51: %i32 = int_value 6 [template]
-// CHECK:STDOUT:   %.52: <bound method> = bound_method %.11, %Convert.14 [template]
-// CHECK:STDOUT:   %.53: <specific function> = specific_function %.52, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.54: %i32 = int_value 7 [template]
-// CHECK:STDOUT:   %.55: <bound method> = bound_method %.12, %Convert.14 [template]
-// CHECK:STDOUT:   %.56: <specific function> = specific_function %.55, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.57: %i32 = int_value 8 [template]
-// CHECK:STDOUT:   %.58: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.59: <specific function> = specific_function %.58, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.60: %i32 = int_value 9 [template]
-// CHECK:STDOUT:   %array: %.3 = tuple_value (%.36, %.39, %.42, %.45, %.48, %.51, %.54, %.57, %.60) [template]
+// CHECK:STDOUT:   %.37: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.44: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.45: <specific function> = specific_function %.44, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.46: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.47: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.48: <specific function> = specific_function %.47, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.49: %i32 = int_value 4 [template]
+// CHECK:STDOUT:   %.50: <bound method> = bound_method %.9, %Convert.14 [template]
+// CHECK:STDOUT:   %.51: <specific function> = specific_function %.50, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.52: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.53: <bound method> = bound_method %.10, %Convert.14 [template]
+// CHECK:STDOUT:   %.54: <specific function> = specific_function %.53, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.55: %i32 = int_value 6 [template]
+// CHECK:STDOUT:   %.56: <bound method> = bound_method %.11, %Convert.14 [template]
+// CHECK:STDOUT:   %.57: <specific function> = specific_function %.56, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.58: %i32 = int_value 7 [template]
+// CHECK:STDOUT:   %.59: <bound method> = bound_method %.12, %Convert.14 [template]
+// CHECK:STDOUT:   %.60: <specific function> = specific_function %.59, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.61: %i32 = int_value 8 [template]
+// CHECK:STDOUT:   %.62: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.63: <specific function> = specific_function %.62, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.64: %i32 = int_value 9 [template]
+// CHECK:STDOUT:   %array: %.3 = tuple_value (%.40, %.43, %.46, %.49, %.52, %.55, %.58, %.61, %.64) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -100,78 +100,78 @@ var a: [i32; 9] = (1, 2, 3, 4, 5, 6, 7, 8, 9);
 // CHECK:STDOUT:   %.loc11_41: Core.IntLiteral = int_value 8 [template = constants.%.12]
 // CHECK:STDOUT:   %.loc11_44: Core.IntLiteral = int_value 9 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_45.1: %tuple.type = tuple_literal (%.loc11_20, %.loc11_23, %.loc11_26, %.loc11_29, %.loc11_32, %.loc11_35, %.loc11_38, %.loc11_41, %.loc11_44)
-// CHECK:STDOUT:   %.loc11_45.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.3: <bound method> = bound_method %.loc11_20, %.loc11_45.2 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_45.4: <specific function> = specific_function %.loc11_45.3, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.1: init %i32 = call %.loc11_45.4(%.loc11_20) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_45.5: init %i32 = converted %.loc11_20, %int.convert_checked.loc11_45.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc11_45.2: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.3: <bound method> = bound_method %.loc11_20, %.loc11_45.2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_45.4: <specific function> = specific_function %.loc11_45.3, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.1: init %i32 = call %.loc11_45.4(%.loc11_20) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_45.5: init %i32 = converted %.loc11_20, %int.convert_checked.loc11_45.1 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc11_45.6: Core.IntLiteral = int_value 0 [template = constants.%.13]
 // CHECK:STDOUT:   %.loc11_45.7: ref %i32 = array_index file.%a.var, %.loc11_45.6
-// CHECK:STDOUT:   %.loc11_45.8: init %i32 = initialize_from %.loc11_45.5 to %.loc11_45.7 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_45.9: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.10: <bound method> = bound_method %.loc11_23, %.loc11_45.9 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc11_45.11: <specific function> = specific_function %.loc11_45.10, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.2: init %i32 = call %.loc11_45.11(%.loc11_23) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc11_45.12: init %i32 = converted %.loc11_23, %int.convert_checked.loc11_45.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc11_45.8: init %i32 = initialize_from %.loc11_45.5 to %.loc11_45.7 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_45.9: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.10: <bound method> = bound_method %.loc11_23, %.loc11_45.9 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc11_45.11: <specific function> = specific_function %.loc11_45.10, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.2: init %i32 = call %.loc11_45.11(%.loc11_23) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc11_45.12: init %i32 = converted %.loc11_23, %int.convert_checked.loc11_45.2 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc11_45.13: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc11_45.14: ref %i32 = array_index file.%a.var, %.loc11_45.13
-// CHECK:STDOUT:   %.loc11_45.15: init %i32 = initialize_from %.loc11_45.12 to %.loc11_45.14 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc11_45.16: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.17: <bound method> = bound_method %.loc11_26, %.loc11_45.16 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc11_45.18: <specific function> = specific_function %.loc11_45.17, @Convert.2(constants.%.1) [template = constants.%.41]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.3: init %i32 = call %.loc11_45.18(%.loc11_26) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc11_45.19: init %i32 = converted %.loc11_26, %int.convert_checked.loc11_45.3 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_45.15: init %i32 = initialize_from %.loc11_45.12 to %.loc11_45.14 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc11_45.16: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.17: <bound method> = bound_method %.loc11_26, %.loc11_45.16 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc11_45.18: <specific function> = specific_function %.loc11_45.17, @Convert.2(constants.%.1) [template = constants.%.45]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.3: init %i32 = call %.loc11_45.18(%.loc11_26) [template = constants.%.46]
+// CHECK:STDOUT:   %.loc11_45.19: init %i32 = converted %.loc11_26, %int.convert_checked.loc11_45.3 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc11_45.20: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc11_45.21: ref %i32 = array_index file.%a.var, %.loc11_45.20
-// CHECK:STDOUT:   %.loc11_45.22: init %i32 = initialize_from %.loc11_45.19 to %.loc11_45.21 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc11_45.23: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.24: <bound method> = bound_method %.loc11_29, %.loc11_45.23 [template = constants.%.43]
-// CHECK:STDOUT:   %.loc11_45.25: <specific function> = specific_function %.loc11_45.24, @Convert.2(constants.%.1) [template = constants.%.44]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.4: init %i32 = call %.loc11_45.25(%.loc11_29) [template = constants.%.45]
-// CHECK:STDOUT:   %.loc11_45.26: init %i32 = converted %.loc11_29, %int.convert_checked.loc11_45.4 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc11_45.22: init %i32 = initialize_from %.loc11_45.19 to %.loc11_45.21 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc11_45.23: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.24: <bound method> = bound_method %.loc11_29, %.loc11_45.23 [template = constants.%.47]
+// CHECK:STDOUT:   %.loc11_45.25: <specific function> = specific_function %.loc11_45.24, @Convert.2(constants.%.1) [template = constants.%.48]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.4: init %i32 = call %.loc11_45.25(%.loc11_29) [template = constants.%.49]
+// CHECK:STDOUT:   %.loc11_45.26: init %i32 = converted %.loc11_29, %int.convert_checked.loc11_45.4 [template = constants.%.49]
 // CHECK:STDOUT:   %.loc11_45.27: Core.IntLiteral = int_value 3 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc11_45.28: ref %i32 = array_index file.%a.var, %.loc11_45.27
-// CHECK:STDOUT:   %.loc11_45.29: init %i32 = initialize_from %.loc11_45.26 to %.loc11_45.28 [template = constants.%.45]
-// CHECK:STDOUT:   %.loc11_45.30: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.31: <bound method> = bound_method %.loc11_32, %.loc11_45.30 [template = constants.%.46]
-// CHECK:STDOUT:   %.loc11_45.32: <specific function> = specific_function %.loc11_45.31, @Convert.2(constants.%.1) [template = constants.%.47]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.5: init %i32 = call %.loc11_45.32(%.loc11_32) [template = constants.%.48]
-// CHECK:STDOUT:   %.loc11_45.33: init %i32 = converted %.loc11_32, %int.convert_checked.loc11_45.5 [template = constants.%.48]
+// CHECK:STDOUT:   %.loc11_45.29: init %i32 = initialize_from %.loc11_45.26 to %.loc11_45.28 [template = constants.%.49]
+// CHECK:STDOUT:   %.loc11_45.30: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.31: <bound method> = bound_method %.loc11_32, %.loc11_45.30 [template = constants.%.50]
+// CHECK:STDOUT:   %.loc11_45.32: <specific function> = specific_function %.loc11_45.31, @Convert.2(constants.%.1) [template = constants.%.51]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.5: init %i32 = call %.loc11_45.32(%.loc11_32) [template = constants.%.52]
+// CHECK:STDOUT:   %.loc11_45.33: init %i32 = converted %.loc11_32, %int.convert_checked.loc11_45.5 [template = constants.%.52]
 // CHECK:STDOUT:   %.loc11_45.34: Core.IntLiteral = int_value 4 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc11_45.35: ref %i32 = array_index file.%a.var, %.loc11_45.34
-// CHECK:STDOUT:   %.loc11_45.36: init %i32 = initialize_from %.loc11_45.33 to %.loc11_45.35 [template = constants.%.48]
-// CHECK:STDOUT:   %.loc11_45.37: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.38: <bound method> = bound_method %.loc11_35, %.loc11_45.37 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc11_45.39: <specific function> = specific_function %.loc11_45.38, @Convert.2(constants.%.1) [template = constants.%.50]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.6: init %i32 = call %.loc11_45.39(%.loc11_35) [template = constants.%.51]
-// CHECK:STDOUT:   %.loc11_45.40: init %i32 = converted %.loc11_35, %int.convert_checked.loc11_45.6 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc11_45.36: init %i32 = initialize_from %.loc11_45.33 to %.loc11_45.35 [template = constants.%.52]
+// CHECK:STDOUT:   %.loc11_45.37: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.38: <bound method> = bound_method %.loc11_35, %.loc11_45.37 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc11_45.39: <specific function> = specific_function %.loc11_45.38, @Convert.2(constants.%.1) [template = constants.%.54]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.6: init %i32 = call %.loc11_45.39(%.loc11_35) [template = constants.%.55]
+// CHECK:STDOUT:   %.loc11_45.40: init %i32 = converted %.loc11_35, %int.convert_checked.loc11_45.6 [template = constants.%.55]
 // CHECK:STDOUT:   %.loc11_45.41: Core.IntLiteral = int_value 5 [template = constants.%.9]
 // CHECK:STDOUT:   %.loc11_45.42: ref %i32 = array_index file.%a.var, %.loc11_45.41
-// CHECK:STDOUT:   %.loc11_45.43: init %i32 = initialize_from %.loc11_45.40 to %.loc11_45.42 [template = constants.%.51]
-// CHECK:STDOUT:   %.loc11_45.44: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.45: <bound method> = bound_method %.loc11_38, %.loc11_45.44 [template = constants.%.52]
-// CHECK:STDOUT:   %.loc11_45.46: <specific function> = specific_function %.loc11_45.45, @Convert.2(constants.%.1) [template = constants.%.53]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.7: init %i32 = call %.loc11_45.46(%.loc11_38) [template = constants.%.54]
-// CHECK:STDOUT:   %.loc11_45.47: init %i32 = converted %.loc11_38, %int.convert_checked.loc11_45.7 [template = constants.%.54]
+// CHECK:STDOUT:   %.loc11_45.43: init %i32 = initialize_from %.loc11_45.40 to %.loc11_45.42 [template = constants.%.55]
+// CHECK:STDOUT:   %.loc11_45.44: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.45: <bound method> = bound_method %.loc11_38, %.loc11_45.44 [template = constants.%.56]
+// CHECK:STDOUT:   %.loc11_45.46: <specific function> = specific_function %.loc11_45.45, @Convert.2(constants.%.1) [template = constants.%.57]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.7: init %i32 = call %.loc11_45.46(%.loc11_38) [template = constants.%.58]
+// CHECK:STDOUT:   %.loc11_45.47: init %i32 = converted %.loc11_38, %int.convert_checked.loc11_45.7 [template = constants.%.58]
 // CHECK:STDOUT:   %.loc11_45.48: Core.IntLiteral = int_value 6 [template = constants.%.10]
 // CHECK:STDOUT:   %.loc11_45.49: ref %i32 = array_index file.%a.var, %.loc11_45.48
-// CHECK:STDOUT:   %.loc11_45.50: init %i32 = initialize_from %.loc11_45.47 to %.loc11_45.49 [template = constants.%.54]
-// CHECK:STDOUT:   %.loc11_45.51: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.52: <bound method> = bound_method %.loc11_41, %.loc11_45.51 [template = constants.%.55]
-// CHECK:STDOUT:   %.loc11_45.53: <specific function> = specific_function %.loc11_45.52, @Convert.2(constants.%.1) [template = constants.%.56]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.8: init %i32 = call %.loc11_45.53(%.loc11_41) [template = constants.%.57]
-// CHECK:STDOUT:   %.loc11_45.54: init %i32 = converted %.loc11_41, %int.convert_checked.loc11_45.8 [template = constants.%.57]
+// CHECK:STDOUT:   %.loc11_45.50: init %i32 = initialize_from %.loc11_45.47 to %.loc11_45.49 [template = constants.%.58]
+// CHECK:STDOUT:   %.loc11_45.51: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.52: <bound method> = bound_method %.loc11_41, %.loc11_45.51 [template = constants.%.59]
+// CHECK:STDOUT:   %.loc11_45.53: <specific function> = specific_function %.loc11_45.52, @Convert.2(constants.%.1) [template = constants.%.60]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.8: init %i32 = call %.loc11_45.53(%.loc11_41) [template = constants.%.61]
+// CHECK:STDOUT:   %.loc11_45.54: init %i32 = converted %.loc11_41, %int.convert_checked.loc11_45.8 [template = constants.%.61]
 // CHECK:STDOUT:   %.loc11_45.55: Core.IntLiteral = int_value 7 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc11_45.56: ref %i32 = array_index file.%a.var, %.loc11_45.55
-// CHECK:STDOUT:   %.loc11_45.57: init %i32 = initialize_from %.loc11_45.54 to %.loc11_45.56 [template = constants.%.57]
-// CHECK:STDOUT:   %.loc11_45.58: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.59: <bound method> = bound_method %.loc11_44, %.loc11_45.58 [template = constants.%.58]
-// CHECK:STDOUT:   %.loc11_45.60: <specific function> = specific_function %.loc11_45.59, @Convert.2(constants.%.1) [template = constants.%.59]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45.9: init %i32 = call %.loc11_45.60(%.loc11_44) [template = constants.%.60]
-// CHECK:STDOUT:   %.loc11_45.61: init %i32 = converted %.loc11_44, %int.convert_checked.loc11_45.9 [template = constants.%.60]
+// CHECK:STDOUT:   %.loc11_45.57: init %i32 = initialize_from %.loc11_45.54 to %.loc11_45.56 [template = constants.%.61]
+// CHECK:STDOUT:   %.loc11_45.58: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.59: <bound method> = bound_method %.loc11_44, %.loc11_45.58 [template = constants.%.62]
+// CHECK:STDOUT:   %.loc11_45.60: <specific function> = specific_function %.loc11_45.59, @Convert.2(constants.%.1) [template = constants.%.63]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45.9: init %i32 = call %.loc11_45.60(%.loc11_44) [template = constants.%.64]
+// CHECK:STDOUT:   %.loc11_45.61: init %i32 = converted %.loc11_44, %int.convert_checked.loc11_45.9 [template = constants.%.64]
 // CHECK:STDOUT:   %.loc11_45.62: Core.IntLiteral = int_value 8 [template = constants.%.12]
 // CHECK:STDOUT:   %.loc11_45.63: ref %i32 = array_index file.%a.var, %.loc11_45.62
-// CHECK:STDOUT:   %.loc11_45.64: init %i32 = initialize_from %.loc11_45.61 to %.loc11_45.63 [template = constants.%.60]
+// CHECK:STDOUT:   %.loc11_45.64: init %i32 = initialize_from %.loc11_45.61 to %.loc11_45.63 [template = constants.%.64]
 // CHECK:STDOUT:   %.loc11_45.65: init %.3 = array_init (%.loc11_45.8, %.loc11_45.15, %.loc11_45.22, %.loc11_45.29, %.loc11_45.36, %.loc11_45.43, %.loc11_45.50, %.loc11_45.57, %.loc11_45.64) to file.%a.var [template = constants.%array]
 // CHECK:STDOUT:   %.loc11_46: init %.3 = converted %.loc11_45.1, %.loc11_45.65 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%a.var, %.loc11_46

toolchain/check/testdata/as/adapter_conversion.carbon

@@ -124,17 +124,17 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct: %A = struct_value (%.31, %.34) [template]
+// CHECK:STDOUT:   %.32: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.33: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct: %A = struct_value (%.35, %.38) [template]
 // CHECK:STDOUT:   %B: type = class_type @B [template]
-// CHECK:STDOUT:   %.35: <witness> = complete_type_witness %A [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %B [template]
+// CHECK:STDOUT:   %.39: <witness> = complete_type_witness %A [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %B [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -166,7 +166,7 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %A.ref.loc18: type = name_ref A, %A.decl [template = constants.%A]
 // CHECK:STDOUT:   %B.ref.loc21: type = name_ref B, %B.decl [template = constants.%B]
 // CHECK:STDOUT:   %B.ref.loc22: type = name_ref B, %B.decl [template = constants.%B]
-// CHECK:STDOUT:   %.loc22: type = ptr_type %B [template = constants.%.36]
+// CHECK:STDOUT:   %.loc22: type = ptr_type %B [template = constants.%.40]
 // CHECK:STDOUT:   %B.ref.loc24: type = name_ref B, %B.decl [template = constants.%B]
 // CHECK:STDOUT:   %b_factory.var: ref %B = var b_factory
 // CHECK:STDOUT:   %b_factory: ref %B = bind_name b_factory, %b_factory.var
@@ -203,7 +203,7 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT: class @B {
 // CHECK:STDOUT:   %A.ref: type = name_ref A, file.%A.decl [template = constants.%A]
 // CHECK:STDOUT:   adapt_decl %A
-// CHECK:STDOUT:   %.loc15: <witness> = complete_type_witness %A [template = constants.%.35]
+// CHECK:STDOUT:   %.loc15: <witness> = complete_type_witness %A [template = constants.%.39]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%B
@@ -214,20 +214,20 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %.loc9_18: Core.IntLiteral = int_value 1 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc9_26: Core.IntLiteral = int_value 2 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc9_27.1: %.8 = struct_literal (%.loc9_18, %.loc9_26)
-// CHECK:STDOUT:   %.loc9_27.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_27.3: <bound method> = bound_method %.loc9_18, %.loc9_27.2 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_27.4: <specific function> = specific_function %.loc9_27.3, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc9_27.1: init %i32 = call %.loc9_27.4(%.loc9_18) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_27.5: init %i32 = converted %.loc9_18, %int.convert_checked.loc9_27.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_27.2: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_27.3: <bound method> = bound_method %.loc9_18, %.loc9_27.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_27.4: <specific function> = specific_function %.loc9_27.3, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc9_27.1: init %i32 = call %.loc9_27.4(%.loc9_18) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_27.5: init %i32 = converted %.loc9_18, %int.convert_checked.loc9_27.1 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc9_27.6: ref %i32 = class_element_access %return, element0
-// CHECK:STDOUT:   %.loc9_27.7: init %i32 = initialize_from %.loc9_27.5 to %.loc9_27.6 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_27.8: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_27.9: <bound method> = bound_method %.loc9_26, %.loc9_27.8 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_27.10: <specific function> = specific_function %.loc9_27.9, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc9_27.2: init %i32 = call %.loc9_27.10(%.loc9_26) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc9_27.11: init %i32 = converted %.loc9_26, %int.convert_checked.loc9_27.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_27.7: init %i32 = initialize_from %.loc9_27.5 to %.loc9_27.6 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_27.8: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_27.9: <bound method> = bound_method %.loc9_26, %.loc9_27.8 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_27.10: <specific function> = specific_function %.loc9_27.9, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc9_27.2: init %i32 = call %.loc9_27.10(%.loc9_26) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc9_27.11: init %i32 = converted %.loc9_26, %int.convert_checked.loc9_27.2 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc9_27.12: ref %i32 = class_element_access %return, element1
-// CHECK:STDOUT:   %.loc9_27.13: init %i32 = initialize_from %.loc9_27.11 to %.loc9_27.12 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_27.13: init %i32 = initialize_from %.loc9_27.11 to %.loc9_27.12 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc9_27.14: init %A = class_init (%.loc9_27.7, %.loc9_27.13), %return [template = constants.%struct]
 // CHECK:STDOUT:   %.loc9_28: init %A = converted %.loc9_27.1, %.loc9_27.14 [template = constants.%struct]
 // CHECK:STDOUT:   return %.loc9_28 to %return
@@ -238,20 +238,20 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %.loc17_22: Core.IntLiteral = int_value 1 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc17_30: Core.IntLiteral = int_value 2 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc17_31.1: %.8 = struct_literal (%.loc17_22, %.loc17_30)
-// CHECK:STDOUT:   %.loc17_31.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_31.3: <bound method> = bound_method %.loc17_22, %.loc17_31.2 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_31.4: <specific function> = specific_function %.loc17_31.3, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc17_31.1: init %i32 = call %.loc17_31.4(%.loc17_22) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc17_31.5: init %i32 = converted %.loc17_22, %int.convert_checked.loc17_31.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc17_31.2: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_31.3: <bound method> = bound_method %.loc17_22, %.loc17_31.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_31.4: <specific function> = specific_function %.loc17_31.3, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc17_31.1: init %i32 = call %.loc17_31.4(%.loc17_22) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc17_31.5: init %i32 = converted %.loc17_22, %int.convert_checked.loc17_31.1 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc17_31.6: ref %i32 = class_element_access file.%a_ref.var, element0
-// CHECK:STDOUT:   %.loc17_31.7: init %i32 = initialize_from %.loc17_31.5 to %.loc17_31.6 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc17_31.8: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_31.9: <bound method> = bound_method %.loc17_30, %.loc17_31.8 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc17_31.10: <specific function> = specific_function %.loc17_31.9, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc17_31.2: init %i32 = call %.loc17_31.10(%.loc17_30) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc17_31.11: init %i32 = converted %.loc17_30, %int.convert_checked.loc17_31.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc17_31.7: init %i32 = initialize_from %.loc17_31.5 to %.loc17_31.6 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc17_31.8: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_31.9: <bound method> = bound_method %.loc17_30, %.loc17_31.8 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc17_31.10: <specific function> = specific_function %.loc17_31.9, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc17_31.2: init %i32 = call %.loc17_31.10(%.loc17_30) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc17_31.11: init %i32 = converted %.loc17_30, %int.convert_checked.loc17_31.2 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc17_31.12: ref %i32 = class_element_access file.%a_ref.var, element1
-// CHECK:STDOUT:   %.loc17_31.13: init %i32 = initialize_from %.loc17_31.11 to %.loc17_31.12 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc17_31.13: init %i32 = initialize_from %.loc17_31.11 to %.loc17_31.12 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc17_31.14: init %A = class_init (%.loc17_31.7, %.loc17_31.13), file.%a_ref.var [template = constants.%struct]
 // CHECK:STDOUT:   %.loc17_32: init %A = converted %.loc17_31.1, %.loc17_31.14 [template = constants.%struct]
 // CHECK:STDOUT:   assign file.%a_ref.var, %.loc17_32
@@ -267,8 +267,8 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %B.ref.loc22: type = name_ref B, file.%B.decl [template = constants.%B]
 // CHECK:STDOUT:   %.loc22_25.1: ref %B = as_compatible %a_ref.ref.loc22
 // CHECK:STDOUT:   %.loc22_25.2: ref %B = converted %a_ref.ref.loc22, %.loc22_25.1
-// CHECK:STDOUT:   %.loc22_17: %.36 = addr_of %.loc22_25.2
-// CHECK:STDOUT:   %b_ptr: %.36 = bind_name b_ptr, %.loc22_17
+// CHECK:STDOUT:   %.loc22_17: %.40 = addr_of %.loc22_25.2
+// CHECK:STDOUT:   %b_ptr: %.40 = bind_name b_ptr, %.loc22_17
 // CHECK:STDOUT:   %A.ref: type = name_ref A, file.%A.decl [template = constants.%A]
 // CHECK:STDOUT:   %Make.ref: %Make.type = name_ref Make, @A.%Make.decl [template = constants.%Make]
 // CHECK:STDOUT:   %.loc24_5: ref %B = splice_block file.%b_factory.var {}
@@ -293,10 +293,10 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.7, @impl.5(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.7(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.7(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -343,15 +343,15 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %int.make_type_signed.loc8: init type = call constants.%Int(%.loc8_18.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc8_18.2: type = value_of_initializer %int.make_type_signed.loc8 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc8_18.3: type = converted %int.make_type_signed.loc8, %.loc8_18.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc8_15.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_15.2: <bound method> = bound_method %.loc8_13, %.loc8_15.1 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc8_15.3: <specific function> = specific_function %.loc8_15.2, @Convert.7(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc8_15.3(%.loc8_13) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_15.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_15.5: %i32 = converted %.loc8_13, %.loc8_15.4 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc8_15.1: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_15.2: <bound method> = bound_method %.loc8_13, %.loc8_15.1 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc8_15.3: <specific function> = specific_function %.loc8_15.2, @Convert.7(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc8_15.3(%.loc8_13) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_15.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_15.5: %i32 = converted %.loc8_13, %.loc8_15.4 [template = constants.%.30]
 // CHECK:STDOUT:   %A.ref: type = name_ref A, file.%A.decl [template = constants.%A]
-// CHECK:STDOUT:   %.loc8_23.1: %A = as_compatible %.loc8_15.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_23.2: %A = converted %.loc8_15.5, %.loc8_23.1 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc8_23.1: %A = as_compatible %.loc8_15.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_23.2: %A = converted %.loc8_15.5, %.loc8_23.1 [template = constants.%.30]
 // CHECK:STDOUT:   %a: %A = bind_name a, %.loc8_23.2
 // CHECK:STDOUT:   %a.ref: %A = name_ref a, %a
 // CHECK:STDOUT:   %.loc9_19.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
@@ -464,14 +464,14 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.8, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct: %A = struct_value (%.32, %.35) [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct: %A = struct_value (%.36, %.39) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -534,21 +534,21 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %.loc13_33: Core.IntLiteral = int_value 2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc13_34.1: %.9 = struct_literal (%.loc13_25, %.loc13_33)
 // CHECK:STDOUT:   %A.ref.loc13: type = name_ref A, file.%A.decl [template = constants.%A]
-// CHECK:STDOUT:   %.loc13_34.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_34.3: <bound method> = bound_method %.loc13_25, %.loc13_34.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_34.4: <specific function> = specific_function %.loc13_34.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc13_34.1: init %i32 = call %.loc13_34.4(%.loc13_25) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_34.5: init %i32 = converted %.loc13_25, %int.convert_checked.loc13_34.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc13_34.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_34.3: <bound method> = bound_method %.loc13_25, %.loc13_34.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_34.4: <specific function> = specific_function %.loc13_34.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc13_34.1: init %i32 = call %.loc13_34.4(%.loc13_25) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_34.5: init %i32 = converted %.loc13_25, %int.convert_checked.loc13_34.1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc13_34.6: ref %A = temporary_storage
 // CHECK:STDOUT:   %.loc13_34.7: ref %i32 = class_element_access %.loc13_34.6, element0
-// CHECK:STDOUT:   %.loc13_34.8: init %i32 = initialize_from %.loc13_34.5 to %.loc13_34.7 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_34.9: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_34.10: <bound method> = bound_method %.loc13_33, %.loc13_34.9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_34.11: <specific function> = specific_function %.loc13_34.10, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc13_34.2: init %i32 = call %.loc13_34.11(%.loc13_33) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc13_34.12: init %i32 = converted %.loc13_33, %int.convert_checked.loc13_34.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_34.8: init %i32 = initialize_from %.loc13_34.5 to %.loc13_34.7 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_34.9: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_34.10: <bound method> = bound_method %.loc13_33, %.loc13_34.9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_34.11: <specific function> = specific_function %.loc13_34.10, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc13_34.2: init %i32 = call %.loc13_34.11(%.loc13_33) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_34.12: init %i32 = converted %.loc13_33, %int.convert_checked.loc13_34.2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_34.13: ref %i32 = class_element_access %.loc13_34.6, element1
-// CHECK:STDOUT:   %.loc13_34.14: init %i32 = initialize_from %.loc13_34.12 to %.loc13_34.13 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_34.14: init %i32 = initialize_from %.loc13_34.12 to %.loc13_34.13 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_34.15: init %A = class_init (%.loc13_34.8, %.loc13_34.14), %.loc13_34.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_34.16: ref %A = temporary %.loc13_34.6, %.loc13_34.15
 // CHECK:STDOUT:   %.loc13_36: ref %A = converted %.loc13_34.1, %.loc13_34.16
@@ -561,21 +561,21 @@ var b: B = {.x = 1} as B;
 // CHECK:STDOUT:   %.loc24_32: Core.IntLiteral = int_value 2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc24_33.1: %.9 = struct_literal (%.loc24_24, %.loc24_32)
 // CHECK:STDOUT:   %A.ref.loc24: type = name_ref A, file.%A.decl [template = constants.%A]
-// CHECK:STDOUT:   %.loc24_33.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc24_33.3: <bound method> = bound_method %.loc24_24, %.loc24_33.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc24_33.4: <specific function> = specific_function %.loc24_33.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc24_33.1: init %i32 = call %.loc24_33.4(%.loc24_24) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc24_33.5: init %i32 = converted %.loc24_24, %int.convert_checked.loc24_33.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc24_33.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc24_33.3: <bound method> = bound_method %.loc24_24, %.loc24_33.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc24_33.4: <specific function> = specific_function %.loc24_33.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc24_33.1: init %i32 = call %.loc24_33.4(%.loc24_24) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc24_33.5: init %i32 = converted %.loc24_24, %int.convert_checked.loc24_33.1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc24_33.6: ref %A = temporary_storage
 // CHECK:STDOUT:   %.loc24_33.7: ref %i32 = class_element_access %.loc24_33.6, element0
-// CHECK:STDOUT:   %.loc24_33.8: init %i32 = initialize_from %.loc24_33.5 to %.loc24_33.7 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc24_33.9: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc24_33.10: <bound method> = bound_method %.loc24_32, %.loc24_33.9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc24_33.11: <specific function> = specific_function %.loc24_33.10, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc24_33.2: init %i32 = call %.loc24_33.11(%.loc24_32) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc24_33.12: init %i32 = converted %.loc24_32, %int.convert_checked.loc24_33.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc24_33.8: init %i32 = initialize_from %.loc24_33.5 to %.loc24_33.7 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc24_33.9: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc24_33.10: <bound method> = bound_method %.loc24_32, %.loc24_33.9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc24_33.11: <specific function> = specific_function %.loc24_33.10, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc24_33.2: init %i32 = call %.loc24_33.11(%.loc24_32) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc24_33.12: init %i32 = converted %.loc24_32, %int.convert_checked.loc24_33.2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc24_33.13: ref %i32 = class_element_access %.loc24_33.6, element1
-// CHECK:STDOUT:   %.loc24_33.14: init %i32 = initialize_from %.loc24_33.12 to %.loc24_33.13 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc24_33.14: init %i32 = initialize_from %.loc24_33.12 to %.loc24_33.13 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc24_33.15: init %A = class_init (%.loc24_33.8, %.loc24_33.14), %.loc24_33.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc24_33.16: ref %A = temporary %.loc24_33.6, %.loc24_33.15
 // CHECK:STDOUT:   %.loc24_35: ref %A = converted %.loc24_33.1, %.loc24_33.16

toolchain/check/testdata/as/basic.carbon

@@ -25,10 +25,10 @@ fn Main() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.7, @impl.5(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.7(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.7(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -66,12 +66,12 @@ fn Main() -> i32 {
 // CHECK:STDOUT:   %int.make_type_signed.loc12: init type = call constants.%Int(%.loc12_15.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc12_15.2: type = value_of_initializer %int.make_type_signed.loc12 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc12_15.3: type = converted %int.make_type_signed.loc12, %.loc12_15.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc12_12.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_12.2: <bound method> = bound_method %.loc12_10, %.loc12_12.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_12.3: <specific function> = specific_function %.loc12_12.2, @Convert.7(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc12_12.3(%.loc12_10) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_12.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_12.5: %i32 = converted %.loc12_10, %.loc12_12.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc12_12.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_12.2: <bound method> = bound_method %.loc12_10, %.loc12_12.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_12.3: <specific function> = specific_function %.loc12_12.2, @Convert.7(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc12_12.3(%.loc12_10) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_12.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_12.5: %i32 = converted %.loc12_10, %.loc12_12.4 [template = constants.%.29]
 // CHECK:STDOUT:   return %.loc12_12.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/as/overloaded.carbon

@@ -39,20 +39,20 @@ let n: i32 = ((4 as i32) as X) as i32;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.2 [template]
 // CHECK:STDOUT:   %Convert.2: %Convert.type.2 = struct_value () [template]
 // CHECK:STDOUT:   %Convert.type.3: type = fn_type @Convert.1, @As(%X) [template]
-// CHECK:STDOUT:   %.9: <witness> = interface_witness (%Convert.2) [template]
+// CHECK:STDOUT:   %.12: <witness> = interface_witness (%Convert.2) [template]
 // CHECK:STDOUT:   %As.type.4: type = facet_type <@As, @As(%i32)> [template]
 // CHECK:STDOUT:   %Convert.type.4: type = fn_type @Convert.3 [template]
 // CHECK:STDOUT:   %Convert.4: %Convert.type.4 = struct_value () [template]
 // CHECK:STDOUT:   %Convert.type.5: type = fn_type @Convert.1, @As(%i32) [template]
-// CHECK:STDOUT:   %.13: <witness> = interface_witness (%Convert.4) [template]
-// CHECK:STDOUT:   %.14: Core.IntLiteral = int_value 4 [template]
+// CHECK:STDOUT:   %.17: <witness> = interface_witness (%Convert.4) [template]
+// CHECK:STDOUT:   %.18: Core.IntLiteral = int_value 4 [template]
 // CHECK:STDOUT:   %Convert.type.17: type = fn_type @Convert.9, @impl.7(%.1) [template]
 // CHECK:STDOUT:   %Convert.17: %Convert.type.17 = struct_value () [template]
-// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.17) [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.14, %Convert.17 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.9(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 4 [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.33, %Convert.2 [template]
+// CHECK:STDOUT:   %.36: <witness> = interface_witness (%Convert.17) [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.18, %Convert.17 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.9(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 4 [template]
+// CHECK:STDOUT:   %.40: <bound method> = bound_method %.39, %Convert.2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -116,7 +116,7 @@ let n: i32 = ((4 as i32) as X) as i32;
 // CHECK:STDOUT:     %return.param: ref %X = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %X = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc15_24: <witness> = interface_witness (%Convert.decl) [template = constants.%.9]
+// CHECK:STDOUT:   %.loc15_24: <witness> = interface_witness (%Convert.decl) [template = constants.%.12]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Convert = %Convert.decl
@@ -140,7 +140,7 @@ let n: i32 = ((4 as i32) as X) as i32;
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc19_24: <witness> = interface_witness (%Convert.decl) [template = constants.%.13]
+// CHECK:STDOUT:   %.loc19_24: <witness> = interface_witness (%Convert.decl) [template = constants.%.17]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Convert = %Convert.decl
@@ -182,20 +182,20 @@ let n: i32 = ((4 as i32) as X) as i32;
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc23_16: Core.IntLiteral = int_value 4 [template = constants.%.14]
+// CHECK:STDOUT:   %.loc23_16: Core.IntLiteral = int_value 4 [template = constants.%.18]
 // CHECK:STDOUT:   %.loc23_21.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc23_21: init type = call constants.%Int(%.loc23_21.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc23_21.2: type = value_of_initializer %int.make_type_signed.loc23_21 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc23_21.3: type = converted %int.make_type_signed.loc23_21, %.loc23_21.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc23_18.1: %Convert.type.5 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.17]
-// CHECK:STDOUT:   %.loc23_18.2: <bound method> = bound_method %.loc23_16, %.loc23_18.1 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc23_18.3: <specific function> = specific_function %.loc23_18.2, @Convert.9(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc23_18.3(%.loc23_16) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc23_18.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.33]
-// CHECK:STDOUT:   %.loc23_18.5: %i32 = converted %.loc23_16, %.loc23_18.4 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc23_18.1: %Convert.type.5 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.17]
+// CHECK:STDOUT:   %.loc23_18.2: <bound method> = bound_method %.loc23_16, %.loc23_18.1 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc23_18.3: <specific function> = specific_function %.loc23_18.2, @Convert.9(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc23_18.3(%.loc23_16) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc23_18.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.39]
+// CHECK:STDOUT:   %.loc23_18.5: %i32 = converted %.loc23_16, %.loc23_18.4 [template = constants.%.39]
 // CHECK:STDOUT:   %X.ref: type = name_ref X, file.%X.decl [template = constants.%X]
-// CHECK:STDOUT:   %.loc23_26.1: %Convert.type.3 = interface_witness_access constants.%.9, element0 [template = constants.%Convert.2]
-// CHECK:STDOUT:   %.loc23_26.2: <bound method> = bound_method %.loc23_18.5, %.loc23_26.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc23_26.1: %Convert.type.3 = interface_witness_access constants.%.12, element0 [template = constants.%Convert.2]
+// CHECK:STDOUT:   %.loc23_26.2: <bound method> = bound_method %.loc23_18.5, %.loc23_26.1 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc23_26.3: ref %X = temporary_storage
 // CHECK:STDOUT:   %Convert.call.loc23_26: init %X = call %.loc23_26.2(%.loc23_18.5) to %.loc23_26.3
 // CHECK:STDOUT:   %.loc23_26.4: init %X = converted %.loc23_18.5, %Convert.call.loc23_26
@@ -203,7 +203,7 @@ let n: i32 = ((4 as i32) as X) as i32;
 // CHECK:STDOUT:   %int.make_type_signed.loc23_35: init type = call constants.%Int(%.loc23_35.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc23_35.2: type = value_of_initializer %int.make_type_signed.loc23_35 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc23_35.3: type = converted %int.make_type_signed.loc23_35, %.loc23_35.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc23_32.1: %Convert.type.5 = interface_witness_access constants.%.13, element0 [template = constants.%Convert.4]
+// CHECK:STDOUT:   %.loc23_32.1: %Convert.type.5 = interface_witness_access constants.%.17, element0 [template = constants.%Convert.4]
 // CHECK:STDOUT:   %.loc23_32.2: <bound method> = bound_method %.loc23_26.4, %.loc23_32.1
 // CHECK:STDOUT:   %.loc23_26.5: ref %X = temporary %.loc23_26.3, %.loc23_26.4
 // CHECK:STDOUT:   %.loc23_26.6: %X = bind_value %.loc23_26.5

toolchain/check/testdata/basics/builtin_types.carbon

@@ -24,15 +24,15 @@ var test_type: type = i32;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 64 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 64 [template]
 // CHECK:STDOUT:   %Float.type: type = fn_type @Float [template]
 // CHECK:STDOUT:   %Float: %Float.type = struct_value () [template]
-// CHECK:STDOUT:   %.27: f64 = float_literal 0.10000000000000001 [template]
-// CHECK:STDOUT:   %.29: String = string_literal "Test" [template]
+// CHECK:STDOUT:   %.31: f64 = float_literal 0.10000000000000001 [template]
+// CHECK:STDOUT:   %.33: String = string_literal "Test" [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -60,7 +60,7 @@ var test_type: type = i32;
 // CHECK:STDOUT:   %.loc11_15.3: type = converted %int.make_type_signed, %.loc11_15.2 [template = constants.%i32]
 // CHECK:STDOUT:   %test_i32.var: ref %i32 = var test_i32
 // CHECK:STDOUT:   %test_i32: ref %i32 = bind_name test_i32, %test_i32.var
-// CHECK:STDOUT:   %.loc12_15.1: Core.IntLiteral = int_value 64 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc12_15.1: Core.IntLiteral = int_value 64 [template = constants.%.30]
 // CHECK:STDOUT:   %float.make_type: init type = call constants.%Float(%.loc12_15.1) [template = f64]
 // CHECK:STDOUT:   %.loc12_15.2: type = value_of_initializer %float.make_type [template = f64]
 // CHECK:STDOUT:   %.loc12_15.3: type = converted %float.make_type, %.loc12_15.2 [template = f64]
@@ -73,15 +73,15 @@ var test_type: type = i32;
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_21: Core.IntLiteral = int_value 0 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc11_22.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_22.2: <bound method> = bound_method %.loc11_21, %.loc11_22.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc11_22.3: <specific function> = specific_function %.loc11_22.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_22.3(%.loc11_21) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_22.4: init %i32 = converted %.loc11_21, %int.convert_checked [template = constants.%.25]
+// CHECK:STDOUT:   %.loc11_22.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_22.2: <bound method> = bound_method %.loc11_21, %.loc11_22.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11_22.3: <specific function> = specific_function %.loc11_22.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_22.3(%.loc11_21) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_22.4: init %i32 = converted %.loc11_21, %int.convert_checked [template = constants.%.29]
 // CHECK:STDOUT:   assign file.%test_i32.var, %.loc11_22.4
-// CHECK:STDOUT:   %.loc12: f64 = float_literal 0.10000000000000001 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12: f64 = float_literal 0.10000000000000001 [template = constants.%.31]
 // CHECK:STDOUT:   assign file.%test_f64.var, %.loc12
-// CHECK:STDOUT:   %.loc13: String = string_literal "Test" [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13: String = string_literal "Test" [template = constants.%.33]
 // CHECK:STDOUT:   %test_str: String = bind_name test_str, %.loc13
 // CHECK:STDOUT:   %.loc14: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed: init type = call constants.%Int(%.loc14) [template = constants.%i32]

toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon

@@ -48,15 +48,15 @@ let e: f64 = 5.0e39999999999999999993;
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 39999999999999999993 [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 2147483648 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.26, %Convert.14 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
 // CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2147483648 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 64 [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 39999999999999999993 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2147483648 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2147483648 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 64 [template]
 // CHECK:STDOUT:   %Float.type: type = fn_type @Float [template]
 // CHECK:STDOUT:   %Float: %Float.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -93,11 +93,11 @@ let e: f64 = 5.0e39999999999999999993;
 // CHECK:STDOUT:   %int.make_type_signed.loc27: init type = call constants.%Int(%.loc27_8.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc27_8.2: type = value_of_initializer %int.make_type_signed.loc27 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc27_8.3: type = converted %int.make_type_signed.loc27, %.loc27_8.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc33_8.1: Core.IntLiteral = int_value 64 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc33_8.1: Core.IntLiteral = int_value 64 [template = constants.%.34]
 // CHECK:STDOUT:   %float.make_type.loc33: init type = call constants.%Float(%.loc33_8.1) [template = f64]
 // CHECK:STDOUT:   %.loc33_8.2: type = value_of_initializer %float.make_type.loc33 [template = f64]
 // CHECK:STDOUT:   %.loc33_8.3: type = converted %float.make_type.loc33, %.loc33_8.2 [template = f64]
-// CHECK:STDOUT:   %.loc38_8.1: Core.IntLiteral = int_value 64 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc38_8.1: Core.IntLiteral = int_value 64 [template = constants.%.34]
 // CHECK:STDOUT:   %float.make_type.loc38: init type = call constants.%Float(%.loc38_8.1) [template = f64]
 // CHECK:STDOUT:   %.loc38_8.2: type = value_of_initializer %float.make_type.loc38 [template = f64]
 // CHECK:STDOUT:   %.loc38_8.3: type = converted %float.make_type.loc38, %.loc38_8.2 [template = f64]
@@ -106,28 +106,28 @@ let e: f64 = 5.0e39999999999999999993;
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc15_14: Core.IntLiteral = int_value 39999999999999999993 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc15_34.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_34.2: <bound method> = bound_method %.loc15_14, %.loc15_34.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc15_34.3: <specific function> = specific_function %.loc15_34.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_34.3(%.loc15_14) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_34.4: %i32 = value_of_initializer %int.convert_checked.loc15 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_34.5: %i32 = converted %.loc15_14, %.loc15_34.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc15_34.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_34.2: <bound method> = bound_method %.loc15_14, %.loc15_34.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc15_34.3: <specific function> = specific_function %.loc15_34.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_34.3(%.loc15_14) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_34.4: %i32 = value_of_initializer %int.convert_checked.loc15 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_34.5: %i32 = converted %.loc15_14, %.loc15_34.4 [template = constants.%.29]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc15_34.5
-// CHECK:STDOUT:   %.loc21_14: Core.IntLiteral = int_value 2147483648 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc21_27.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_27.2: <bound method> = bound_method %.loc21_14, %.loc21_27.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc21_27.3: <specific function> = specific_function %.loc21_27.2, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc21: init %i32 = call %.loc21_27.3(%.loc21_14) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_27.4: %i32 = value_of_initializer %int.convert_checked.loc21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_27.5: %i32 = converted %.loc21_14, %.loc21_27.4 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc21_14: Core.IntLiteral = int_value 2147483648 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc21_27.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_27.2: <bound method> = bound_method %.loc21_14, %.loc21_27.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc21_27.3: <specific function> = specific_function %.loc21_27.2, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc21: init %i32 = call %.loc21_27.3(%.loc21_14) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_27.4: %i32 = value_of_initializer %int.convert_checked.loc21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_27.5: %i32 = converted %.loc21_14, %.loc21_27.4 [template = constants.%.33]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc21_27.5
-// CHECK:STDOUT:   %.loc27_14: Core.IntLiteral = int_value 2147483648 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc27_25.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc27_25.2: <bound method> = bound_method %.loc27_14, %.loc27_25.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc27_25.3: <specific function> = specific_function %.loc27_25.2, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc27: init %i32 = call %.loc27_25.3(%.loc27_14) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc27_25.4: %i32 = value_of_initializer %int.convert_checked.loc27 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc27_25.5: %i32 = converted %.loc27_14, %.loc27_25.4 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc27_14: Core.IntLiteral = int_value 2147483648 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc27_25.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc27_25.2: <bound method> = bound_method %.loc27_14, %.loc27_25.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc27_25.3: <specific function> = specific_function %.loc27_25.2, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc27: init %i32 = call %.loc27_25.3(%.loc27_14) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc27_25.4: %i32 = value_of_initializer %int.convert_checked.loc27 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc27_25.5: %i32 = converted %.loc27_14, %.loc27_25.4 [template = constants.%.33]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc27_25.5
 // CHECK:STDOUT:   %d: f64 = bind_name d, <error>
 // CHECK:STDOUT:   %e: f64 = bind_name e, <error>

toolchain/check/testdata/basics/numeric_literals.carbon

@@ -48,34 +48,34 @@ fn F() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 8 [template]
-// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.33: <bound method> = bound_method %.5, %Convert.14 [template]
 // CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 9 [template]
-// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 4 [template]
-// CHECK:STDOUT:   %.39: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.41: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 5 [template]
-// CHECK:STDOUT:   %array.1: %.3 = tuple_value (%.31, %.35, %.31, %.31, %.41, %.41) [template]
-// CHECK:STDOUT:   %.43: Core.IntLiteral = int_value 64 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 8 [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 9 [template]
+// CHECK:STDOUT:   %.40: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.41: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 4 [template]
+// CHECK:STDOUT:   %.43: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.44: <specific function> = specific_function %.43, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.45: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.46: Core.IntLiteral = int_value 5 [template]
+// CHECK:STDOUT:   %array.1: %.3 = tuple_value (%.35, %.39, %.35, %.35, %.45, %.45) [template]
+// CHECK:STDOUT:   %.47: Core.IntLiteral = int_value 64 [template]
 // CHECK:STDOUT:   %Float.type: type = fn_type @Float [template]
 // CHECK:STDOUT:   %Float: %Float.type = struct_value () [template]
-// CHECK:STDOUT:   %.44: type = array_type %.2, f64 [template]
-// CHECK:STDOUT:   %.46: f64 = float_literal 0.90000000000000002 [template]
-// CHECK:STDOUT:   %.47: f64 = float_literal 8 [template]
-// CHECK:STDOUT:   %.48: f64 = float_literal 80 [template]
-// CHECK:STDOUT:   %.49: f64 = float_literal 1.0E+7 [template]
-// CHECK:STDOUT:   %.50: f64 = float_literal 1.0E+8 [template]
-// CHECK:STDOUT:   %.51: f64 = float_literal 1.0E-8 [template]
+// CHECK:STDOUT:   %.48: type = array_type %.2, f64 [template]
+// CHECK:STDOUT:   %.50: f64 = float_literal 0.90000000000000002 [template]
+// CHECK:STDOUT:   %.51: f64 = float_literal 8 [template]
+// CHECK:STDOUT:   %.52: f64 = float_literal 80 [template]
+// CHECK:STDOUT:   %.53: f64 = float_literal 1.0E+7 [template]
+// CHECK:STDOUT:   %.54: f64 = float_literal 1.0E+8 [template]
+// CHECK:STDOUT:   %.55: f64 = float_literal 1.0E-8 [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (f64, f64, f64, f64, f64, f64) [template]
-// CHECK:STDOUT:   %array.2: %.44 = tuple_value (%.46, %.47, %.48, %.49, %.50, %.51) [template]
+// CHECK:STDOUT:   %array.2: %.48 = tuple_value (%.50, %.51, %.52, %.53, %.54, %.55) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -114,92 +114,92 @@ fn F() {
 // CHECK:STDOUT:   %.loc19: Core.IntLiteral = int_value 2147483647 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc20: Core.IntLiteral = int_value 2147483647 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc21_3.1: %tuple.type.1 = tuple_literal (%.loc15, %.loc16, %.loc17, %.loc18, %.loc19, %.loc20)
-// CHECK:STDOUT:   %.loc21_3.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_3.3: <bound method> = bound_method %.loc15, %.loc21_3.2 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_3.4: <specific function> = specific_function %.loc21_3.3, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc21_3.1: init %i32 = call %.loc21_3.4(%.loc15) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.5: init %i32 = converted %.loc15, %int.convert_checked.loc21_3.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc21_3.2: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_3.3: <bound method> = bound_method %.loc15, %.loc21_3.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_3.4: <specific function> = specific_function %.loc21_3.3, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc21_3.1: init %i32 = call %.loc21_3.4(%.loc15) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.5: init %i32 = converted %.loc15, %int.convert_checked.loc21_3.1 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc21_3.6: Core.IntLiteral = int_value 0 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc21_3.7: ref %i32 = array_index %ints.var, %.loc21_3.6
-// CHECK:STDOUT:   %.loc21_3.8: init %i32 = initialize_from %.loc21_3.5 to %.loc21_3.7 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.9: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_3.10: <bound method> = bound_method %.loc16, %.loc21_3.9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc21_3.11: <specific function> = specific_function %.loc21_3.10, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc21_3.2: init %i32 = call %.loc21_3.11(%.loc16) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc21_3.12: init %i32 = converted %.loc16, %int.convert_checked.loc21_3.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc21_3.13: Core.IntLiteral = int_value 1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc21_3.8: init %i32 = initialize_from %.loc21_3.5 to %.loc21_3.7 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.9: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_3.10: <bound method> = bound_method %.loc16, %.loc21_3.9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc21_3.11: <specific function> = specific_function %.loc21_3.10, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc21_3.2: init %i32 = call %.loc21_3.11(%.loc16) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc21_3.12: init %i32 = converted %.loc16, %int.convert_checked.loc21_3.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc21_3.13: Core.IntLiteral = int_value 1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc21_3.14: ref %i32 = array_index %ints.var, %.loc21_3.13
-// CHECK:STDOUT:   %.loc21_3.15: init %i32 = initialize_from %.loc21_3.12 to %.loc21_3.14 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc21_3.16: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_3.17: <bound method> = bound_method %.loc17, %.loc21_3.16 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_3.18: <specific function> = specific_function %.loc21_3.17, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc21_3.3: init %i32 = call %.loc21_3.18(%.loc17) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.19: init %i32 = converted %.loc17, %int.convert_checked.loc21_3.3 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.20: Core.IntLiteral = int_value 2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc21_3.15: init %i32 = initialize_from %.loc21_3.12 to %.loc21_3.14 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc21_3.16: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_3.17: <bound method> = bound_method %.loc17, %.loc21_3.16 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_3.18: <specific function> = specific_function %.loc21_3.17, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc21_3.3: init %i32 = call %.loc21_3.18(%.loc17) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.19: init %i32 = converted %.loc17, %int.convert_checked.loc21_3.3 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.20: Core.IntLiteral = int_value 2 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc21_3.21: ref %i32 = array_index %ints.var, %.loc21_3.20
-// CHECK:STDOUT:   %.loc21_3.22: init %i32 = initialize_from %.loc21_3.19 to %.loc21_3.21 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.23: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_3.24: <bound method> = bound_method %.loc18, %.loc21_3.23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_3.25: <specific function> = specific_function %.loc21_3.24, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc21_3.4: init %i32 = call %.loc21_3.25(%.loc18) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.26: init %i32 = converted %.loc18, %int.convert_checked.loc21_3.4 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.27: Core.IntLiteral = int_value 3 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc21_3.22: init %i32 = initialize_from %.loc21_3.19 to %.loc21_3.21 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.23: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_3.24: <bound method> = bound_method %.loc18, %.loc21_3.23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_3.25: <specific function> = specific_function %.loc21_3.24, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc21_3.4: init %i32 = call %.loc21_3.25(%.loc18) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.26: init %i32 = converted %.loc18, %int.convert_checked.loc21_3.4 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.27: Core.IntLiteral = int_value 3 [template = constants.%.41]
 // CHECK:STDOUT:   %.loc21_3.28: ref %i32 = array_index %ints.var, %.loc21_3.27
-// CHECK:STDOUT:   %.loc21_3.29: init %i32 = initialize_from %.loc21_3.26 to %.loc21_3.28 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc21_3.30: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_3.31: <bound method> = bound_method %.loc19, %.loc21_3.30 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc21_3.32: <specific function> = specific_function %.loc21_3.31, @Convert.2(constants.%.1) [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc21_3.5: init %i32 = call %.loc21_3.32(%.loc19) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_3.33: init %i32 = converted %.loc19, %int.convert_checked.loc21_3.5 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_3.34: Core.IntLiteral = int_value 4 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc21_3.29: init %i32 = initialize_from %.loc21_3.26 to %.loc21_3.28 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc21_3.30: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_3.31: <bound method> = bound_method %.loc19, %.loc21_3.30 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc21_3.32: <specific function> = specific_function %.loc21_3.31, @Convert.2(constants.%.1) [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc21_3.5: init %i32 = call %.loc21_3.32(%.loc19) [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_3.33: init %i32 = converted %.loc19, %int.convert_checked.loc21_3.5 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_3.34: Core.IntLiteral = int_value 4 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc21_3.35: ref %i32 = array_index %ints.var, %.loc21_3.34
-// CHECK:STDOUT:   %.loc21_3.36: init %i32 = initialize_from %.loc21_3.33 to %.loc21_3.35 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_3.37: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_3.38: <bound method> = bound_method %.loc20, %.loc21_3.37 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc21_3.39: <specific function> = specific_function %.loc21_3.38, @Convert.2(constants.%.1) [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc21_3.6: init %i32 = call %.loc21_3.39(%.loc20) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_3.40: init %i32 = converted %.loc20, %int.convert_checked.loc21_3.6 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_3.41: Core.IntLiteral = int_value 5 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc21_3.36: init %i32 = initialize_from %.loc21_3.33 to %.loc21_3.35 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_3.37: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_3.38: <bound method> = bound_method %.loc20, %.loc21_3.37 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc21_3.39: <specific function> = specific_function %.loc21_3.38, @Convert.2(constants.%.1) [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc21_3.6: init %i32 = call %.loc21_3.39(%.loc20) [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_3.40: init %i32 = converted %.loc20, %int.convert_checked.loc21_3.6 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_3.41: Core.IntLiteral = int_value 5 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc21_3.42: ref %i32 = array_index %ints.var, %.loc21_3.41
-// CHECK:STDOUT:   %.loc21_3.43: init %i32 = initialize_from %.loc21_3.40 to %.loc21_3.42 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc21_3.43: init %i32 = initialize_from %.loc21_3.40 to %.loc21_3.42 [template = constants.%.45]
 // CHECK:STDOUT:   %.loc21_3.44: init %.3 = array_init (%.loc21_3.8, %.loc21_3.15, %.loc21_3.22, %.loc21_3.29, %.loc21_3.36, %.loc21_3.43) to %ints.var [template = constants.%array.1]
 // CHECK:STDOUT:   %.loc21_4: init %.3 = converted %.loc21_3.1, %.loc21_3.44 [template = constants.%array.1]
 // CHECK:STDOUT:   assign %ints.var, %.loc21_4
-// CHECK:STDOUT:   %.loc22_16.1: Core.IntLiteral = int_value 64 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc22_16.1: Core.IntLiteral = int_value 64 [template = constants.%.47]
 // CHECK:STDOUT:   %float.make_type: init type = call constants.%Float(%.loc22_16.1) [template = f64]
 // CHECK:STDOUT:   %.loc22_21: Core.IntLiteral = int_value 6 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc22_16.2: type = value_of_initializer %float.make_type [template = f64]
 // CHECK:STDOUT:   %.loc22_16.3: type = converted %float.make_type, %.loc22_16.2 [template = f64]
-// CHECK:STDOUT:   %.loc22_22: type = array_type %.loc22_21, f64 [template = constants.%.44]
-// CHECK:STDOUT:   %floats.var: ref %.44 = var floats
-// CHECK:STDOUT:   %floats: ref %.44 = bind_name floats, %floats.var
-// CHECK:STDOUT:   %.loc23: f64 = float_literal 0.90000000000000002 [template = constants.%.46]
-// CHECK:STDOUT:   %.loc24: f64 = float_literal 8 [template = constants.%.47]
-// CHECK:STDOUT:   %.loc25: f64 = float_literal 80 [template = constants.%.48]
-// CHECK:STDOUT:   %.loc26: f64 = float_literal 1.0E+7 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc27: f64 = float_literal 1.0E+8 [template = constants.%.50]
-// CHECK:STDOUT:   %.loc28: f64 = float_literal 1.0E-8 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc22_22: type = array_type %.loc22_21, f64 [template = constants.%.48]
+// CHECK:STDOUT:   %floats.var: ref %.48 = var floats
+// CHECK:STDOUT:   %floats: ref %.48 = bind_name floats, %floats.var
+// CHECK:STDOUT:   %.loc23: f64 = float_literal 0.90000000000000002 [template = constants.%.50]
+// CHECK:STDOUT:   %.loc24: f64 = float_literal 8 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc25: f64 = float_literal 80 [template = constants.%.52]
+// CHECK:STDOUT:   %.loc26: f64 = float_literal 1.0E+7 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc27: f64 = float_literal 1.0E+8 [template = constants.%.54]
+// CHECK:STDOUT:   %.loc28: f64 = float_literal 1.0E-8 [template = constants.%.55]
 // CHECK:STDOUT:   %.loc29_3.1: %tuple.type.2 = tuple_literal (%.loc23, %.loc24, %.loc25, %.loc26, %.loc27, %.loc28)
 // CHECK:STDOUT:   %.loc29_3.2: Core.IntLiteral = int_value 0 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc29_3.3: ref f64 = array_index %floats.var, %.loc29_3.2
-// CHECK:STDOUT:   %.loc29_3.4: init f64 = initialize_from %.loc23 to %.loc29_3.3 [template = constants.%.46]
-// CHECK:STDOUT:   %.loc29_3.5: Core.IntLiteral = int_value 1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc29_3.4: init f64 = initialize_from %.loc23 to %.loc29_3.3 [template = constants.%.50]
+// CHECK:STDOUT:   %.loc29_3.5: Core.IntLiteral = int_value 1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc29_3.6: ref f64 = array_index %floats.var, %.loc29_3.5
-// CHECK:STDOUT:   %.loc29_3.7: init f64 = initialize_from %.loc24 to %.loc29_3.6 [template = constants.%.47]
-// CHECK:STDOUT:   %.loc29_3.8: Core.IntLiteral = int_value 2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc29_3.7: init f64 = initialize_from %.loc24 to %.loc29_3.6 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc29_3.8: Core.IntLiteral = int_value 2 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc29_3.9: ref f64 = array_index %floats.var, %.loc29_3.8
-// CHECK:STDOUT:   %.loc29_3.10: init f64 = initialize_from %.loc25 to %.loc29_3.9 [template = constants.%.48]
-// CHECK:STDOUT:   %.loc29_3.11: Core.IntLiteral = int_value 3 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc29_3.10: init f64 = initialize_from %.loc25 to %.loc29_3.9 [template = constants.%.52]
+// CHECK:STDOUT:   %.loc29_3.11: Core.IntLiteral = int_value 3 [template = constants.%.41]
 // CHECK:STDOUT:   %.loc29_3.12: ref f64 = array_index %floats.var, %.loc29_3.11
-// CHECK:STDOUT:   %.loc29_3.13: init f64 = initialize_from %.loc26 to %.loc29_3.12 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc29_3.14: Core.IntLiteral = int_value 4 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc29_3.13: init f64 = initialize_from %.loc26 to %.loc29_3.12 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc29_3.14: Core.IntLiteral = int_value 4 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc29_3.15: ref f64 = array_index %floats.var, %.loc29_3.14
-// CHECK:STDOUT:   %.loc29_3.16: init f64 = initialize_from %.loc27 to %.loc29_3.15 [template = constants.%.50]
-// CHECK:STDOUT:   %.loc29_3.17: Core.IntLiteral = int_value 5 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc29_3.16: init f64 = initialize_from %.loc27 to %.loc29_3.15 [template = constants.%.54]
+// CHECK:STDOUT:   %.loc29_3.17: Core.IntLiteral = int_value 5 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc29_3.18: ref f64 = array_index %floats.var, %.loc29_3.17
-// CHECK:STDOUT:   %.loc29_3.19: init f64 = initialize_from %.loc28 to %.loc29_3.18 [template = constants.%.51]
-// CHECK:STDOUT:   %.loc29_3.20: init %.44 = array_init (%.loc29_3.4, %.loc29_3.7, %.loc29_3.10, %.loc29_3.13, %.loc29_3.16, %.loc29_3.19) to %floats.var [template = constants.%array.2]
-// CHECK:STDOUT:   %.loc29_4: init %.44 = converted %.loc29_3.1, %.loc29_3.20 [template = constants.%array.2]
+// CHECK:STDOUT:   %.loc29_3.19: init f64 = initialize_from %.loc28 to %.loc29_3.18 [template = constants.%.55]
+// CHECK:STDOUT:   %.loc29_3.20: init %.48 = array_init (%.loc29_3.4, %.loc29_3.7, %.loc29_3.10, %.loc29_3.13, %.loc29_3.16, %.loc29_3.19) to %floats.var [template = constants.%array.2]
+// CHECK:STDOUT:   %.loc29_4: init %.48 = converted %.loc29_3.1, %.loc29_3.20 [template = constants.%array.2]
 // CHECK:STDOUT:   assign %floats.var, %.loc29_4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/parens.carbon

@@ -22,14 +22,14 @@ var b: i32 = ((2));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.26, %Convert.14 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
 // CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -65,18 +65,18 @@ var b: i32 = ((2));
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_15: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc11_17.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_17.2: <bound method> = bound_method %.loc11_15, %.loc11_17.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc11_17.3: <specific function> = specific_function %.loc11_17.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc11: init %i32 = call %.loc11_17.3(%.loc11_15) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_17.4: init %i32 = converted %.loc11_15, %int.convert_checked.loc11 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc11_17.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_17.2: <bound method> = bound_method %.loc11_15, %.loc11_17.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11_17.3: <specific function> = specific_function %.loc11_17.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc11: init %i32 = call %.loc11_17.3(%.loc11_15) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_17.4: init %i32 = converted %.loc11_15, %int.convert_checked.loc11 [template = constants.%.29]
 // CHECK:STDOUT:   assign file.%a.var, %.loc11_17.4
-// CHECK:STDOUT:   %.loc12_16: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_19.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_19.2: <bound method> = bound_method %.loc12_16, %.loc12_19.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_19.3: <specific function> = specific_function %.loc12_19.2, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12: init %i32 = call %.loc12_19.3(%.loc12_16) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_19.4: init %i32 = converted %.loc12_16, %int.convert_checked.loc12 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_16: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_19.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_19.2: <bound method> = bound_method %.loc12_16, %.loc12_19.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_19.3: <specific function> = specific_function %.loc12_19.2, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12: init %i32 = call %.loc12_19.3(%.loc12_16) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_19.4: init %i32 = converted %.loc12_16, %int.convert_checked.loc12 [template = constants.%.33]
 // CHECK:STDOUT:   assign file.%b.var, %.loc12_19.4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/run_i32.carbon

@@ -23,10 +23,10 @@ fn Run() -> i32 { return 0; }
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -60,12 +60,12 @@ fn Run() -> i32 { return 0; }
 // CHECK:STDOUT: fn @Run() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_26: Core.IntLiteral = int_value 0 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc11_27.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.2: <bound method> = bound_method %.loc11_26, %.loc11_27.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc11_27.3: <specific function> = specific_function %.loc11_27.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_27.3(%.loc11_26) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_27.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_27.5: %i32 = converted %.loc11_26, %.loc11_27.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc11_27.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.2: <bound method> = bound_method %.loc11_26, %.loc11_27.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11_27.3: <specific function> = specific_function %.loc11_27.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc11_27.3(%.loc11_26) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_27.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_27.5: %i32 = converted %.loc11_26, %.loc11_27.4 [template = constants.%.29]
 // CHECK:STDOUT:   return %.loc11_27.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/builtins/float/make_type.carbon

@@ -99,11 +99,11 @@ var dyn: Float(dyn_size);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 64 [template]
-// CHECK:STDOUT:   %.26: f64 = float_literal 0 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 64 [template]
+// CHECK:STDOUT:   %.30: f64 = float_literal 0 [template]
 // CHECK:STDOUT:   %Int.type: type = fn_type @Int [template]
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
 // CHECK:STDOUT:   %GetFloat.type: type = fn_type @GetFloat [template]
@@ -131,12 +131,12 @@ var dyn: Float(dyn_size);
 // CHECK:STDOUT:   %default.import = import <invalid>
 // CHECK:STDOUT:   %Float.ref: %Float.type = name_ref Float, imports.%import_ref.1 [template = constants.%Float]
 // CHECK:STDOUT:   %.loc6_14.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc6_14.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_14.3: <bound method> = bound_method %.loc6_14.1, %.loc6_14.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc6_14.4: <specific function> = specific_function %.loc6_14.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc6_14.4(%.loc6_14.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc6_14.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc6_14.6: %i32 = converted %.loc6_14.1, %.loc6_14.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc6_14.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_14.3: <bound method> = bound_method %.loc6_14.1, %.loc6_14.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc6_14.4: <specific function> = specific_function %.loc6_14.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc6_14.4(%.loc6_14.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc6_14.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc6_14.6: %i32 = converted %.loc6_14.1, %.loc6_14.5 [template = constants.%.29]
 // CHECK:STDOUT:   %float.make_type: init type = call %Float.ref(%.loc6_14.6) [template = f64]
 // CHECK:STDOUT:   %.loc6_16.1: type = value_of_initializer %float.make_type [template = f64]
 // CHECK:STDOUT:   %.loc6_16.2: type = converted %float.make_type, %.loc6_16.1 [template = f64]
@@ -173,7 +173,7 @@ var dyn: Float(dyn_size);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc6: f64 = float_literal 0 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc6: f64 = float_literal 0 [template = constants.%.30]
 // CHECK:STDOUT:   assign file.%f.var, %.loc6
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -188,16 +188,16 @@ var dyn: Float(dyn_size);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.21: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.22: <bound method> = bound_method %.1, %Convert.14 [template]
-// CHECK:STDOUT:   %.23: <specific function> = specific_function %.22, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.24: %i32 = int_value 32 [template]
+// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.26: <bound method> = bound_method %.1, %Convert.14 [template]
+// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.28: %i32 = int_value 32 [template]
 // CHECK:STDOUT:   %Int.type: type = fn_type @Int [template]
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
-// CHECK:STDOUT:   %.25: Core.IntLiteral = int_value 64 [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.25, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 64 [template]
+// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 64 [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.29, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 64 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -222,12 +222,12 @@ var dyn: Float(dyn_size);
 // CHECK:STDOUT:   %default.import = import <invalid>
 // CHECK:STDOUT:   %Float.ref.loc10: %Float.type = name_ref Float, imports.%import_ref.1 [template = constants.%Float]
 // CHECK:STDOUT:   %.loc10_26.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.21, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.22]
-// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.23]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.24]
-// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.24]
-// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.24]
+// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.27]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.28]
+// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.28]
+// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.28]
 // CHECK:STDOUT:   %float.make_type.loc10: init type = call %Float.ref.loc10(%.loc10_26.6) [template = <error>]
 // CHECK:STDOUT:   %.loc10_28.1: type = value_of_initializer %float.make_type.loc10 [template = <error>]
 // CHECK:STDOUT:   %.loc10_28.2: type = converted %float.make_type.loc10, %.loc10_28.1 [template = <error>]
@@ -253,12 +253,12 @@ var dyn: Float(dyn_size);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc12_21: Core.IntLiteral = int_value 64 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_23.1: %Convert.type.2 = interface_witness_access constants.%.21, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_23.2: <bound method> = bound_method %.loc12_21, %.loc12_23.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_23.3: <specific function> = specific_function %.loc12_23.2, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc12_23.3(%.loc12_21) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_23.4: init %i32 = converted %.loc12_21, %int.convert_checked [template = constants.%.28]
+// CHECK:STDOUT:   %.loc12_21: Core.IntLiteral = int_value 64 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_23.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_23.2: <bound method> = bound_method %.loc12_21, %.loc12_23.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_23.3: <specific function> = specific_function %.loc12_23.2, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc12_23.3(%.loc12_21) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_23.4: init %i32 = converted %.loc12_21, %int.convert_checked [template = constants.%.32]
 // CHECK:STDOUT:   assign file.%dyn_size.var, %.loc12_23.4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/and.carbon

@@ -34,22 +34,22 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 12 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 10 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 8 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 12 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 10 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 8 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 8 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 8 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -104,39 +104,39 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:   %And.ref: %And.type = name_ref And, %And.decl [template = constants.%And]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 12 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_24.1: Core.IntLiteral = int_value 10 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_24.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_24.3: <bound method> = bound_method %.loc4_24.1, %.loc4_24.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_24.4: <specific function> = specific_function %.loc4_24.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_24: init %i32 = call %.loc4_24.4(%.loc4_24.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_24.5: %i32 = value_of_initializer %int.convert_checked.loc4_24 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_24.6: %i32 = converted %.loc4_24.1, %.loc4_24.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.and: init %i32 = call %And.ref(%.loc4_20.6, %.loc4_24.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_24.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_24.3: <bound method> = bound_method %.loc4_24.1, %.loc4_24.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_24.4: <specific function> = specific_function %.loc4_24.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_24: init %i32 = call %.loc4_24.4(%.loc4_24.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_24.5: %i32 = value_of_initializer %int.convert_checked.loc4_24 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_24.6: %i32 = converted %.loc4_24.1, %.loc4_24.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.and: init %i32 = call %And.ref(%.loc4_20.6, %.loc4_24.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.and, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.and [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.and, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.and, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_27: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.and, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.and [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.and, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.and, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_27: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 8 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 8 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -181,9 +181,9 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/builtins/int/complement.carbon

@@ -36,24 +36,24 @@ fn RuntimeCall(a: i32) -> i32 {
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1193046 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -1193047 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 16777215 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 16777215 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 15584169 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1193046 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -1193047 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 16777215 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 16777215 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 15584169 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.32: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.31, %Convert.15 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 15584169 [template]
-// CHECK:STDOUT:   %.36: type = array_type %.35, %i32 [template]
-// CHECK:STDOUT:   %.37: type = ptr_type %.36 [template]
+// CHECK:STDOUT:   %.36: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.35, %Convert.15 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 15584169 [template]
+// CHECK:STDOUT:   %.40: type = array_type %.39, %i32 [template]
+// CHECK:STDOUT:   %.41: type = ptr_type %.40 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -128,43 +128,43 @@ fn RuntimeCall(a: i32) -> i32 {
 // CHECK:STDOUT:   %And.ref: %And.type = name_ref And, %And.decl [template = constants.%And]
 // CHECK:STDOUT:   %Complement.ref: %Complement.type = name_ref Complement, %Complement.decl [template = constants.%Complement]
 // CHECK:STDOUT:   %.loc5_31.1: Core.IntLiteral = int_value 1193046 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc5_31.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc5_31.3: <bound method> = bound_method %.loc5_31.1, %.loc5_31.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc5_31.4: <specific function> = specific_function %.loc5_31.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc5_31: init %i32 = call %.loc5_31.4(%.loc5_31.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_31.5: %i32 = value_of_initializer %int.convert_checked.loc5_31 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_31.6: %i32 = converted %.loc5_31.1, %.loc5_31.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.complement: init %i32 = call %Complement.ref(%.loc5_31.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc5_42.1: Core.IntLiteral = int_value 16777215 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc5_30.1: %i32 = value_of_initializer %int.complement [template = constants.%.26]
-// CHECK:STDOUT:   %.loc5_30.2: %i32 = converted %int.complement, %.loc5_30.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc5_42.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc5_42.3: <bound method> = bound_method %.loc5_42.1, %.loc5_42.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc5_42.4: <specific function> = specific_function %.loc5_42.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc5_42: init %i32 = call %.loc5_42.4(%.loc5_42.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc5_42.5: %i32 = value_of_initializer %int.convert_checked.loc5_42 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc5_42.6: %i32 = converted %.loc5_42.1, %.loc5_42.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.and: init %i32 = call %And.ref(%.loc5_30.2, %.loc5_42.6) [template = constants.%.31]
+// CHECK:STDOUT:   %.loc5_31.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc5_31.3: <bound method> = bound_method %.loc5_31.1, %.loc5_31.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc5_31.4: <specific function> = specific_function %.loc5_31.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc5_31: init %i32 = call %.loc5_31.4(%.loc5_31.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_31.5: %i32 = value_of_initializer %int.convert_checked.loc5_31 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_31.6: %i32 = converted %.loc5_31.1, %.loc5_31.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.complement: init %i32 = call %Complement.ref(%.loc5_31.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc5_42.1: Core.IntLiteral = int_value 16777215 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc5_30.1: %i32 = value_of_initializer %int.complement [template = constants.%.30]
+// CHECK:STDOUT:   %.loc5_30.2: %i32 = converted %int.complement, %.loc5_30.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc5_42.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc5_42.3: <bound method> = bound_method %.loc5_42.1, %.loc5_42.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc5_42.4: <specific function> = specific_function %.loc5_42.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc5_42: init %i32 = call %.loc5_42.4(%.loc5_42.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_42.5: %i32 = value_of_initializer %int.convert_checked.loc5_42 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_42.6: %i32 = converted %.loc5_42.1, %.loc5_42.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.and: init %i32 = call %And.ref(%.loc5_30.2, %.loc5_42.6) [template = constants.%.35]
 // CHECK:STDOUT:   %.loc5_11.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_11.3: type = converted %int.make_type_signed.loc5, %.loc5_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19.1: %Convert.type.6 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc5_19.2: <bound method> = bound_method %int.and, %.loc5_19.1 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc5_19.3: <specific function> = specific_function %.loc5_19.2, @Convert.4(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc5_19.4: %i32 = value_of_initializer %int.and [template = constants.%.31]
-// CHECK:STDOUT:   %.loc5_19.5: %i32 = converted %int.and, %.loc5_19.4 [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc5_19: init Core.IntLiteral = call %.loc5_19.3(%.loc5_19.5) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc5_19 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_19.7: Core.IntLiteral = converted %int.and, %.loc5_19.6 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_51: type = array_type %.loc5_19.7, %i32 [template = constants.%.36]
-// CHECK:STDOUT:   %arr.var: ref %.36 = var arr
-// CHECK:STDOUT:   %arr: ref %.36 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc5_19.1: %Convert.type.6 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc5_19.2: <bound method> = bound_method %int.and, %.loc5_19.1 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc5_19.3: <specific function> = specific_function %.loc5_19.2, @Convert.4(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc5_19.4: %i32 = value_of_initializer %int.and [template = constants.%.35]
+// CHECK:STDOUT:   %.loc5_19.5: %i32 = converted %int.and, %.loc5_19.4 [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc5_19: init Core.IntLiteral = call %.loc5_19.3(%.loc5_19.5) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc5_19 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_19.7: Core.IntLiteral = converted %int.and, %.loc5_19.6 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_51: type = array_type %.loc5_19.7, %i32 [template = constants.%.40]
+// CHECK:STDOUT:   %arr.var: ref %.40 = var arr
+// CHECK:STDOUT:   %arr: ref %.40 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc6_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc6: init type = call constants.%Int(%.loc6_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc6_18: Core.IntLiteral = int_value 15584169 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc6_18: Core.IntLiteral = int_value 15584169 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc6_13.2: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_13.3: type = converted %int.make_type_signed.loc6, %.loc6_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc6_26: type = array_type %.loc6_18, %i32 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc6_27: type = ptr_type %.36 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc6_26: type = array_type %.loc6_18, %i32 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc6_27: type = ptr_type %.40 [template = constants.%.41]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -202,9 +202,9 @@ fn RuntimeCall(a: i32) -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.36 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc6: %.37 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.37 = bind_name arr_p, %.loc6
+// CHECK:STDOUT:   %arr.ref: ref %.40 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc6: %.41 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.41 = bind_name arr_p, %.loc6
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/builtins/int/eq.carbon

@@ -54,16 +54,16 @@ fn WrongResult(a: i32, b: i32) -> i32 = "int.eq";
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.29: bool = bool_literal true [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.34: bool = bool_literal false [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.33: bool = bool_literal true [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.38: bool = bool_literal false [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -179,21 +179,21 @@ fn WrongResult(a: i32, b: i32) -> i32 = "int.eq";
 // CHECK:STDOUT:   %Eq.ref.loc8: %Eq.type = name_ref Eq, file.%Eq.decl [template = constants.%Eq]
 // CHECK:STDOUT:   %.loc8_19.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc8_22.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc8_19.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_19.3: <bound method> = bound_method %.loc8_19.1, %.loc8_19.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_19.4: <specific function> = specific_function %.loc8_19.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc8_19: init %i32 = call %.loc8_19.4(%.loc8_19.1) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_19.5: %i32 = value_of_initializer %int.convert_checked.loc8_19 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_19.6: %i32 = converted %.loc8_19.1, %.loc8_19.5 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_22.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_22.3: <bound method> = bound_method %.loc8_22.1, %.loc8_22.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_22.4: <specific function> = specific_function %.loc8_22.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc8_22: init %i32 = call %.loc8_22.4(%.loc8_22.1) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_22.5: %i32 = value_of_initializer %int.convert_checked.loc8_22 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_22.6: %i32 = converted %.loc8_22.1, %.loc8_22.5 [template = constants.%.28]
-// CHECK:STDOUT:   %int.eq.loc8: init bool = call %Eq.ref.loc8(%.loc8_19.6, %.loc8_22.6) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_13.1: bool = value_of_initializer %int.eq.loc8 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_13.2: bool = converted %int.eq.loc8, %.loc8_13.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_19.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_19.3: <bound method> = bound_method %.loc8_19.1, %.loc8_19.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_19.4: <specific function> = specific_function %.loc8_19.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc8_19: init %i32 = call %.loc8_19.4(%.loc8_19.1) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_19.5: %i32 = value_of_initializer %int.convert_checked.loc8_19 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_19.6: %i32 = converted %.loc8_19.1, %.loc8_19.5 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_22.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_22.3: <bound method> = bound_method %.loc8_22.1, %.loc8_22.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_22.4: <specific function> = specific_function %.loc8_22.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc8_22: init %i32 = call %.loc8_22.4(%.loc8_22.1) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_22.5: %i32 = value_of_initializer %int.convert_checked.loc8_22 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_22.6: %i32 = converted %.loc8_22.1, %.loc8_22.5 [template = constants.%.32]
+// CHECK:STDOUT:   %int.eq.loc8: init bool = call %Eq.ref.loc8(%.loc8_19.6, %.loc8_22.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_13.1: bool = value_of_initializer %int.eq.loc8 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_13.2: bool = converted %int.eq.loc8, %.loc8_13.1 [template = constants.%.33]
 // CHECK:STDOUT:   if %.loc8_13.2 br !if.expr.then.loc8 else br !if.expr.else.loc8
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc8:
@@ -209,22 +209,22 @@ fn WrongResult(a: i32, b: i32) -> i32 = "int.eq";
 // CHECK:STDOUT:   %false_.ref: %False = name_ref false_, %false_
 // CHECK:STDOUT:   %Eq.ref.loc9: %Eq.type = name_ref Eq, file.%Eq.decl [template = constants.%Eq]
 // CHECK:STDOUT:   %.loc9_20.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc9_23.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_20.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_20.3: <bound method> = bound_method %.loc9_20.1, %.loc9_20.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_20.4: <specific function> = specific_function %.loc9_20.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc9_20: init %i32 = call %.loc9_20.4(%.loc9_20.1) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_20.5: %i32 = value_of_initializer %int.convert_checked.loc9_20 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_20.6: %i32 = converted %.loc9_20.1, %.loc9_20.5 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_23.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_23.3: <bound method> = bound_method %.loc9_23.1, %.loc9_23.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_23.4: <specific function> = specific_function %.loc9_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc9_23: init %i32 = call %.loc9_23.4(%.loc9_23.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_23.5: %i32 = value_of_initializer %int.convert_checked.loc9_23 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_23.6: %i32 = converted %.loc9_23.1, %.loc9_23.5 [template = constants.%.33]
-// CHECK:STDOUT:   %int.eq.loc9: init bool = call %Eq.ref.loc9(%.loc9_20.6, %.loc9_23.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc9_14.1: bool = value_of_initializer %int.eq.loc9 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc9_14.2: bool = converted %int.eq.loc9, %.loc9_14.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_23.1: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_20.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_20.3: <bound method> = bound_method %.loc9_20.1, %.loc9_20.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_20.4: <specific function> = specific_function %.loc9_20.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc9_20: init %i32 = call %.loc9_20.4(%.loc9_20.1) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_20.5: %i32 = value_of_initializer %int.convert_checked.loc9_20 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_20.6: %i32 = converted %.loc9_20.1, %.loc9_20.5 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_23.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_23.3: <bound method> = bound_method %.loc9_23.1, %.loc9_23.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_23.4: <specific function> = specific_function %.loc9_23.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc9_23: init %i32 = call %.loc9_23.4(%.loc9_23.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_23.5: %i32 = value_of_initializer %int.convert_checked.loc9_23 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_23.6: %i32 = converted %.loc9_23.1, %.loc9_23.5 [template = constants.%.37]
+// CHECK:STDOUT:   %int.eq.loc9: init bool = call %Eq.ref.loc9(%.loc9_20.6, %.loc9_23.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc9_14.1: bool = value_of_initializer %int.eq.loc9 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc9_14.2: bool = converted %int.eq.loc9, %.loc9_14.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc9_14.2 br !if.expr.then.loc9 else br !if.expr.else.loc9
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc9:

toolchain/check/testdata/builtins/int/greater.carbon

@@ -52,20 +52,20 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.33: bool = bool_literal false [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
-// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.38: bool = bool_literal true [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.37: bool = bool_literal false [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.39: <bound method> = bound_method %.38, %Convert.14 [template]
+// CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.42: bool = bool_literal true [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -203,21 +203,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Greater.ref.loc9: %Greater.type = name_ref Greater, file.%Greater.decl [template = constants.%Greater]
 // CHECK:STDOUT:   %.loc9_25.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_28.1: Core.IntLiteral = int_value 2 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_28.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_28.3: <bound method> = bound_method %.loc9_28.1, %.loc9_28.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_28.4: <specific function> = specific_function %.loc9_28.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc9_28: init %i32 = call %.loc9_28.4(%.loc9_28.1) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_28.5: %i32 = value_of_initializer %int.convert_checked.loc9_28 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_28.6: %i32 = converted %.loc9_28.1, %.loc9_28.5 [template = constants.%.32]
-// CHECK:STDOUT:   %int.greater.loc9: init bool = call %Greater.ref.loc9(%.loc9_25.6, %.loc9_28.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_14.1: bool = value_of_initializer %int.greater.loc9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_14.2: bool = converted %int.greater.loc9, %.loc9_14.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_28.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_28.3: <bound method> = bound_method %.loc9_28.1, %.loc9_28.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_28.4: <specific function> = specific_function %.loc9_28.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc9_28: init %i32 = call %.loc9_28.4(%.loc9_28.1) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_28.5: %i32 = value_of_initializer %int.convert_checked.loc9_28 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_28.6: %i32 = converted %.loc9_28.1, %.loc9_28.5 [template = constants.%.36]
+// CHECK:STDOUT:   %int.greater.loc9: init bool = call %Greater.ref.loc9(%.loc9_25.6, %.loc9_28.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_14.1: bool = value_of_initializer %int.greater.loc9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_14.2: bool = converted %int.greater.loc9, %.loc9_14.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc9_14.2 br !if.expr.then.loc9 else br !if.expr.else.loc9
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc9:
@@ -234,21 +234,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Greater.ref.loc10: %Greater.type = name_ref Greater, file.%Greater.decl [template = constants.%Greater]
 // CHECK:STDOUT:   %.loc10_25.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_28.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc10_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_25.3: <bound method> = bound_method %.loc10_25.1, %.loc10_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_25.4: <specific function> = specific_function %.loc10_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_25: init %i32 = call %.loc10_25.4(%.loc10_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_25.5: %i32 = value_of_initializer %int.convert_checked.loc10_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_25.6: %i32 = converted %.loc10_25.1, %.loc10_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_28.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_28.3: <bound method> = bound_method %.loc10_28.1, %.loc10_28.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_28.4: <specific function> = specific_function %.loc10_28.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_28: init %i32 = call %.loc10_28.4(%.loc10_28.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_28.5: %i32 = value_of_initializer %int.convert_checked.loc10_28 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_28.6: %i32 = converted %.loc10_28.1, %.loc10_28.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.greater.loc10: init bool = call %Greater.ref.loc10(%.loc10_25.6, %.loc10_28.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc10_14.1: bool = value_of_initializer %int.greater.loc10 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc10_14.2: bool = converted %int.greater.loc10, %.loc10_14.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_25.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_25.3: <bound method> = bound_method %.loc10_25.1, %.loc10_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_25.4: <specific function> = specific_function %.loc10_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_25: init %i32 = call %.loc10_25.4(%.loc10_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_25.5: %i32 = value_of_initializer %int.convert_checked.loc10_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_25.6: %i32 = converted %.loc10_25.1, %.loc10_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_28.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_28.3: <bound method> = bound_method %.loc10_28.1, %.loc10_28.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_28.4: <specific function> = specific_function %.loc10_28.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_28: init %i32 = call %.loc10_28.4(%.loc10_28.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_28.5: %i32 = value_of_initializer %int.convert_checked.loc10_28 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_28.6: %i32 = converted %.loc10_28.1, %.loc10_28.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.greater.loc10: init bool = call %Greater.ref.loc10(%.loc10_25.6, %.loc10_28.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_14.1: bool = value_of_initializer %int.greater.loc10 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_14.2: bool = converted %int.greater.loc10, %.loc10_14.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc10_14.2 br !if.expr.then.loc10 else br !if.expr.else.loc10
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc10:
@@ -264,22 +264,22 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %true_.ref.loc11: %True = name_ref true_, %true_
 // CHECK:STDOUT:   %Greater.ref.loc11: %Greater.type = name_ref Greater, file.%Greater.decl [template = constants.%Greater]
 // CHECK:STDOUT:   %.loc11_24.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc11_27.1: Core.IntLiteral = int_value 0 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_24.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_24.3: <bound method> = bound_method %.loc11_24.1, %.loc11_24.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_24.4: <specific function> = specific_function %.loc11_24.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc11_24: init %i32 = call %.loc11_24.4(%.loc11_24.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_24.5: %i32 = value_of_initializer %int.convert_checked.loc11_24 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_24.6: %i32 = converted %.loc11_24.1, %.loc11_24.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_27.1, %.loc11_27.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27: init %i32 = call %.loc11_27.4(%.loc11_27.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc11_27.5: %i32 = value_of_initializer %int.convert_checked.loc11_27 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc11_27.6: %i32 = converted %.loc11_27.1, %.loc11_27.5 [template = constants.%.37]
-// CHECK:STDOUT:   %int.greater.loc11: init bool = call %Greater.ref.loc11(%.loc11_24.6, %.loc11_27.6) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_13.1: bool = value_of_initializer %int.greater.loc11 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_13.2: bool = converted %int.greater.loc11, %.loc11_13.1 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_27.1: Core.IntLiteral = int_value 0 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_24.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_24.3: <bound method> = bound_method %.loc11_24.1, %.loc11_24.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_24.4: <specific function> = specific_function %.loc11_24.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc11_24: init %i32 = call %.loc11_24.4(%.loc11_24.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_24.5: %i32 = value_of_initializer %int.convert_checked.loc11_24 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_24.6: %i32 = converted %.loc11_24.1, %.loc11_24.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_27.1, %.loc11_27.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27: init %i32 = call %.loc11_27.4(%.loc11_27.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc11_27.5: %i32 = value_of_initializer %int.convert_checked.loc11_27 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc11_27.6: %i32 = converted %.loc11_27.1, %.loc11_27.5 [template = constants.%.41]
+// CHECK:STDOUT:   %int.greater.loc11: init bool = call %Greater.ref.loc11(%.loc11_24.6, %.loc11_27.6) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_13.1: bool = value_of_initializer %int.greater.loc11 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_13.2: bool = converted %int.greater.loc11, %.loc11_13.1 [template = constants.%.42]
 // CHECK:STDOUT:   if %.loc11_13.2 br !if.expr.then.loc11 else br !if.expr.else.loc11
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc11:
@@ -296,25 +296,25 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Greater.ref.loc12: %Greater.type = name_ref Greater, file.%Greater.decl [template = constants.%Greater]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_32.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc12_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_32.3: <bound method> = bound_method %.loc12_32.1, %.loc12_32.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_32.4: <specific function> = specific_function %.loc12_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12_32: init %i32 = call %.loc12_32.4(%.loc12_32.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_32.5: %i32 = value_of_initializer %int.convert_checked.loc12_32 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_32.6: %i32 = converted %.loc12_32.1, %.loc12_32.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_32.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_36.1: Core.IntLiteral = int_value 0 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc12_31.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_31.2: %i32 = converted %int.snegate.loc12, %.loc12_31.1 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_36.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_36.3: <bound method> = bound_method %.loc12_36.1, %.loc12_36.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc12_36.4: <specific function> = specific_function %.loc12_36.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc12_36: init %i32 = call %.loc12_36.4(%.loc12_36.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc12_36.5: %i32 = value_of_initializer %int.convert_checked.loc12_36 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc12_36.6: %i32 = converted %.loc12_36.1, %.loc12_36.5 [template = constants.%.37]
-// CHECK:STDOUT:   %int.greater.loc12: init bool = call %Greater.ref.loc12(%.loc12_31.2, %.loc12_36.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_14.1: bool = value_of_initializer %int.greater.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_14.2: bool = converted %int.greater.loc12, %.loc12_14.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_32.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_32.3: <bound method> = bound_method %.loc12_32.1, %.loc12_32.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_32.4: <specific function> = specific_function %.loc12_32.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12_32: init %i32 = call %.loc12_32.4(%.loc12_32.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_32.5: %i32 = value_of_initializer %int.convert_checked.loc12_32 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_32.6: %i32 = converted %.loc12_32.1, %.loc12_32.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_32.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_36.1: Core.IntLiteral = int_value 0 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc12_31.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_31.2: %i32 = converted %int.snegate.loc12, %.loc12_31.1 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_36.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_36.3: <bound method> = bound_method %.loc12_36.1, %.loc12_36.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc12_36.4: <specific function> = specific_function %.loc12_36.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc12_36: init %i32 = call %.loc12_36.4(%.loc12_36.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc12_36.5: %i32 = value_of_initializer %int.convert_checked.loc12_36 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc12_36.6: %i32 = converted %.loc12_36.1, %.loc12_36.5 [template = constants.%.41]
+// CHECK:STDOUT:   %int.greater.loc12: init bool = call %Greater.ref.loc12(%.loc12_31.2, %.loc12_36.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_14.1: bool = value_of_initializer %int.greater.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_14.2: bool = converted %int.greater.loc12, %.loc12_14.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc12_14.2 br !if.expr.then.loc12 else br !if.expr.else.loc12
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc12:
@@ -329,27 +329,27 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %.loc12_14.3: type = block_arg !if.expr.result.loc12 [template = constants.%False]
 // CHECK:STDOUT:   %true_.ref.loc13: %True = name_ref true_, %true_
 // CHECK:STDOUT:   %Greater.ref.loc13: %Greater.type = name_ref Greater, file.%Greater.decl [template = constants.%Greater]
-// CHECK:STDOUT:   %.loc13_24.1: Core.IntLiteral = int_value 0 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_24.1: Core.IntLiteral = int_value 0 [template = constants.%.38]
 // CHECK:STDOUT:   %Negate.ref.loc13: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc13_34.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc13_34.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_34.3: <bound method> = bound_method %.loc13_34.1, %.loc13_34.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_34.4: <specific function> = specific_function %.loc13_34.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc13_34: init %i32 = call %.loc13_34.4(%.loc13_34.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_34.5: %i32 = value_of_initializer %int.convert_checked.loc13_34 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_34.6: %i32 = converted %.loc13_34.1, %.loc13_34.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_34.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_24.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_24.3: <bound method> = bound_method %.loc13_24.1, %.loc13_24.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc13_24.4: <specific function> = specific_function %.loc13_24.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc13_24: init %i32 = call %.loc13_24.4(%.loc13_24.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_24.5: %i32 = value_of_initializer %int.convert_checked.loc13_24 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_24.6: %i32 = converted %.loc13_24.1, %.loc13_24.5 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_33.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_33.2: %i32 = converted %int.snegate.loc13, %.loc13_33.1 [template = constants.%.39]
-// CHECK:STDOUT:   %int.greater.loc13: init bool = call %Greater.ref.loc13(%.loc13_24.6, %.loc13_33.2) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_13.1: bool = value_of_initializer %int.greater.loc13 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_13.2: bool = converted %int.greater.loc13, %.loc13_13.1 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_34.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_34.3: <bound method> = bound_method %.loc13_34.1, %.loc13_34.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_34.4: <specific function> = specific_function %.loc13_34.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc13_34: init %i32 = call %.loc13_34.4(%.loc13_34.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_34.5: %i32 = value_of_initializer %int.convert_checked.loc13_34 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_34.6: %i32 = converted %.loc13_34.1, %.loc13_34.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_34.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_24.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_24.3: <bound method> = bound_method %.loc13_24.1, %.loc13_24.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_24.4: <specific function> = specific_function %.loc13_24.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc13_24: init %i32 = call %.loc13_24.4(%.loc13_24.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_24.5: %i32 = value_of_initializer %int.convert_checked.loc13_24 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_24.6: %i32 = converted %.loc13_24.1, %.loc13_24.5 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_33.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_33.2: %i32 = converted %int.snegate.loc13, %.loc13_33.1 [template = constants.%.43]
+// CHECK:STDOUT:   %int.greater.loc13: init bool = call %Greater.ref.loc13(%.loc13_24.6, %.loc13_33.2) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_13.1: bool = value_of_initializer %int.greater.loc13 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_13.2: bool = converted %int.greater.loc13, %.loc13_13.1 [template = constants.%.42]
 // CHECK:STDOUT:   if %.loc13_13.2 br !if.expr.then.loc13 else br !if.expr.else.loc13
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc13:

toolchain/check/testdata/builtins/int/greater_eq.carbon

@@ -52,20 +52,20 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.33: bool = bool_literal false [template]
-// CHECK:STDOUT:   %.34: bool = bool_literal true [template]
-// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.36: <bound method> = bound_method %.35, %Convert.14 [template]
-// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.38: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.37: bool = bool_literal false [template]
+// CHECK:STDOUT:   %.38: bool = bool_literal true [template]
+// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.40: <bound method> = bound_method %.39, %Convert.14 [template]
+// CHECK:STDOUT:   %.41: <specific function> = specific_function %.40, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.42: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -203,21 +203,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %GreaterEq.ref.loc9: %GreaterEq.type = name_ref GreaterEq, file.%GreaterEq.decl [template = constants.%GreaterEq]
 // CHECK:STDOUT:   %.loc9_27.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_30.1: Core.IntLiteral = int_value 2 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc9_27.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_27.3: <bound method> = bound_method %.loc9_27.1, %.loc9_27.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_27.4: <specific function> = specific_function %.loc9_27.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc9_27: init %i32 = call %.loc9_27.4(%.loc9_27.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_27.5: %i32 = value_of_initializer %int.convert_checked.loc9_27 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_27.6: %i32 = converted %.loc9_27.1, %.loc9_27.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_30.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_30.3: <bound method> = bound_method %.loc9_30.1, %.loc9_30.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_30.4: <specific function> = specific_function %.loc9_30.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc9_30: init %i32 = call %.loc9_30.4(%.loc9_30.1) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_30.5: %i32 = value_of_initializer %int.convert_checked.loc9_30 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_30.6: %i32 = converted %.loc9_30.1, %.loc9_30.5 [template = constants.%.32]
-// CHECK:STDOUT:   %int.greater_eq.loc9: init bool = call %GreaterEq.ref.loc9(%.loc9_27.6, %.loc9_30.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_14.1: bool = value_of_initializer %int.greater_eq.loc9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_14.2: bool = converted %int.greater_eq.loc9, %.loc9_14.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_27.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_27.3: <bound method> = bound_method %.loc9_27.1, %.loc9_27.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_27.4: <specific function> = specific_function %.loc9_27.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc9_27: init %i32 = call %.loc9_27.4(%.loc9_27.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_27.5: %i32 = value_of_initializer %int.convert_checked.loc9_27 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_27.6: %i32 = converted %.loc9_27.1, %.loc9_27.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_30.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_30.3: <bound method> = bound_method %.loc9_30.1, %.loc9_30.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_30.4: <specific function> = specific_function %.loc9_30.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc9_30: init %i32 = call %.loc9_30.4(%.loc9_30.1) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_30.5: %i32 = value_of_initializer %int.convert_checked.loc9_30 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_30.6: %i32 = converted %.loc9_30.1, %.loc9_30.5 [template = constants.%.36]
+// CHECK:STDOUT:   %int.greater_eq.loc9: init bool = call %GreaterEq.ref.loc9(%.loc9_27.6, %.loc9_30.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_14.1: bool = value_of_initializer %int.greater_eq.loc9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_14.2: bool = converted %int.greater_eq.loc9, %.loc9_14.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc9_14.2 br !if.expr.then.loc9 else br !if.expr.else.loc9
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc9:
@@ -234,21 +234,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %GreaterEq.ref.loc10: %GreaterEq.type = name_ref GreaterEq, file.%GreaterEq.decl [template = constants.%GreaterEq]
 // CHECK:STDOUT:   %.loc10_26.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_29.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_26: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked.loc10_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_29.3: <bound method> = bound_method %.loc10_29.1, %.loc10_29.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_29.4: <specific function> = specific_function %.loc10_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_29: init %i32 = call %.loc10_29.4(%.loc10_29.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_29.5: %i32 = value_of_initializer %int.convert_checked.loc10_29 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_29.6: %i32 = converted %.loc10_29.1, %.loc10_29.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.greater_eq.loc10: init bool = call %GreaterEq.ref.loc10(%.loc10_26.6, %.loc10_29.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_13.1: bool = value_of_initializer %int.greater_eq.loc10 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_13.2: bool = converted %int.greater_eq.loc10, %.loc10_13.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_26: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked.loc10_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_29.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_29.3: <bound method> = bound_method %.loc10_29.1, %.loc10_29.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_29.4: <specific function> = specific_function %.loc10_29.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_29: init %i32 = call %.loc10_29.4(%.loc10_29.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_29.5: %i32 = value_of_initializer %int.convert_checked.loc10_29 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_29.6: %i32 = converted %.loc10_29.1, %.loc10_29.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.greater_eq.loc10: init bool = call %GreaterEq.ref.loc10(%.loc10_26.6, %.loc10_29.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_13.1: bool = value_of_initializer %int.greater_eq.loc10 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_13.2: bool = converted %int.greater_eq.loc10, %.loc10_13.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc10_13.2 br !if.expr.then.loc10 else br !if.expr.else.loc10
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc10:
@@ -264,22 +264,22 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %true_.ref.loc11: %True = name_ref true_, %true_
 // CHECK:STDOUT:   %GreaterEq.ref.loc11: %GreaterEq.type = name_ref GreaterEq, file.%GreaterEq.decl [template = constants.%GreaterEq]
 // CHECK:STDOUT:   %.loc11_26.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc11_29.1: Core.IntLiteral = int_value 0 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc11_26.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_26.3: <bound method> = bound_method %.loc11_26.1, %.loc11_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_26.4: <specific function> = specific_function %.loc11_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc11_26: init %i32 = call %.loc11_26.4(%.loc11_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_26.5: %i32 = value_of_initializer %int.convert_checked.loc11_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_26.6: %i32 = converted %.loc11_26.1, %.loc11_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_29.3: <bound method> = bound_method %.loc11_29.1, %.loc11_29.2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_29.4: <specific function> = specific_function %.loc11_29.3, @Convert.2(constants.%.1) [template = constants.%.37]
-// CHECK:STDOUT:   %int.convert_checked.loc11_29: init %i32 = call %.loc11_29.4(%.loc11_29.1) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_29.5: %i32 = value_of_initializer %int.convert_checked.loc11_29 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_29.6: %i32 = converted %.loc11_29.1, %.loc11_29.5 [template = constants.%.38]
-// CHECK:STDOUT:   %int.greater_eq.loc11: init bool = call %GreaterEq.ref.loc11(%.loc11_26.6, %.loc11_29.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_13.1: bool = value_of_initializer %int.greater_eq.loc11 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_13.2: bool = converted %int.greater_eq.loc11, %.loc11_13.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_29.1: Core.IntLiteral = int_value 0 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc11_26.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_26.3: <bound method> = bound_method %.loc11_26.1, %.loc11_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_26.4: <specific function> = specific_function %.loc11_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc11_26: init %i32 = call %.loc11_26.4(%.loc11_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_26.5: %i32 = value_of_initializer %int.convert_checked.loc11_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_26.6: %i32 = converted %.loc11_26.1, %.loc11_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_29.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_29.3: <bound method> = bound_method %.loc11_29.1, %.loc11_29.2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_29.4: <specific function> = specific_function %.loc11_29.3, @Convert.2(constants.%.1) [template = constants.%.41]
+// CHECK:STDOUT:   %int.convert_checked.loc11_29: init %i32 = call %.loc11_29.4(%.loc11_29.1) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_29.5: %i32 = value_of_initializer %int.convert_checked.loc11_29 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_29.6: %i32 = converted %.loc11_29.1, %.loc11_29.5 [template = constants.%.42]
+// CHECK:STDOUT:   %int.greater_eq.loc11: init bool = call %GreaterEq.ref.loc11(%.loc11_26.6, %.loc11_29.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_13.1: bool = value_of_initializer %int.greater_eq.loc11 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_13.2: bool = converted %int.greater_eq.loc11, %.loc11_13.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc11_13.2 br !if.expr.then.loc11 else br !if.expr.else.loc11
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc11:
@@ -296,25 +296,25 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %GreaterEq.ref.loc12: %GreaterEq.type = name_ref GreaterEq, file.%GreaterEq.decl [template = constants.%GreaterEq]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_34.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc12_34.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_34.3: <bound method> = bound_method %.loc12_34.1, %.loc12_34.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_34.4: <specific function> = specific_function %.loc12_34.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12_34: init %i32 = call %.loc12_34.4(%.loc12_34.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_34.5: %i32 = value_of_initializer %int.convert_checked.loc12_34 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_34.6: %i32 = converted %.loc12_34.1, %.loc12_34.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_34.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_38.1: Core.IntLiteral = int_value 0 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc12_33.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_33.2: %i32 = converted %int.snegate.loc12, %.loc12_33.1 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_38.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_38.3: <bound method> = bound_method %.loc12_38.1, %.loc12_38.2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc12_38.4: <specific function> = specific_function %.loc12_38.3, @Convert.2(constants.%.1) [template = constants.%.37]
-// CHECK:STDOUT:   %int.convert_checked.loc12_38: init %i32 = call %.loc12_38.4(%.loc12_38.1) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc12_38.5: %i32 = value_of_initializer %int.convert_checked.loc12_38 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc12_38.6: %i32 = converted %.loc12_38.1, %.loc12_38.5 [template = constants.%.38]
-// CHECK:STDOUT:   %int.greater_eq.loc12: init bool = call %GreaterEq.ref.loc12(%.loc12_33.2, %.loc12_38.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_14.1: bool = value_of_initializer %int.greater_eq.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_14.2: bool = converted %int.greater_eq.loc12, %.loc12_14.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_34.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_34.3: <bound method> = bound_method %.loc12_34.1, %.loc12_34.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_34.4: <specific function> = specific_function %.loc12_34.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12_34: init %i32 = call %.loc12_34.4(%.loc12_34.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_34.5: %i32 = value_of_initializer %int.convert_checked.loc12_34 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_34.6: %i32 = converted %.loc12_34.1, %.loc12_34.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_34.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_38.1: Core.IntLiteral = int_value 0 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc12_33.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_33.2: %i32 = converted %int.snegate.loc12, %.loc12_33.1 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_38.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_38.3: <bound method> = bound_method %.loc12_38.1, %.loc12_38.2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc12_38.4: <specific function> = specific_function %.loc12_38.3, @Convert.2(constants.%.1) [template = constants.%.41]
+// CHECK:STDOUT:   %int.convert_checked.loc12_38: init %i32 = call %.loc12_38.4(%.loc12_38.1) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc12_38.5: %i32 = value_of_initializer %int.convert_checked.loc12_38 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc12_38.6: %i32 = converted %.loc12_38.1, %.loc12_38.5 [template = constants.%.42]
+// CHECK:STDOUT:   %int.greater_eq.loc12: init bool = call %GreaterEq.ref.loc12(%.loc12_33.2, %.loc12_38.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_14.1: bool = value_of_initializer %int.greater_eq.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_14.2: bool = converted %int.greater_eq.loc12, %.loc12_14.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc12_14.2 br !if.expr.then.loc12 else br !if.expr.else.loc12
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc12:
@@ -329,27 +329,27 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %.loc12_14.3: type = block_arg !if.expr.result.loc12 [template = constants.%False]
 // CHECK:STDOUT:   %true_.ref.loc13: %True = name_ref true_, %true_
 // CHECK:STDOUT:   %GreaterEq.ref.loc13: %GreaterEq.type = name_ref GreaterEq, file.%GreaterEq.decl [template = constants.%GreaterEq]
-// CHECK:STDOUT:   %.loc13_26.1: Core.IntLiteral = int_value 0 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_26.1: Core.IntLiteral = int_value 0 [template = constants.%.39]
 // CHECK:STDOUT:   %Negate.ref.loc13: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc13_36.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc13_36.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_36.3: <bound method> = bound_method %.loc13_36.1, %.loc13_36.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_36.4: <specific function> = specific_function %.loc13_36.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc13_36: init %i32 = call %.loc13_36.4(%.loc13_36.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_36.5: %i32 = value_of_initializer %int.convert_checked.loc13_36 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_36.6: %i32 = converted %.loc13_36.1, %.loc13_36.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_36.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_26.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_26.3: <bound method> = bound_method %.loc13_26.1, %.loc13_26.2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc13_26.4: <specific function> = specific_function %.loc13_26.3, @Convert.2(constants.%.1) [template = constants.%.37]
-// CHECK:STDOUT:   %int.convert_checked.loc13_26: init %i32 = call %.loc13_26.4(%.loc13_26.1) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_26.5: %i32 = value_of_initializer %int.convert_checked.loc13_26 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_26.6: %i32 = converted %.loc13_26.1, %.loc13_26.5 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_35.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_35.2: %i32 = converted %int.snegate.loc13, %.loc13_35.1 [template = constants.%.39]
-// CHECK:STDOUT:   %int.greater_eq.loc13: init bool = call %GreaterEq.ref.loc13(%.loc13_26.6, %.loc13_35.2) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_13.1: bool = value_of_initializer %int.greater_eq.loc13 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_13.2: bool = converted %int.greater_eq.loc13, %.loc13_13.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_36.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_36.3: <bound method> = bound_method %.loc13_36.1, %.loc13_36.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_36.4: <specific function> = specific_function %.loc13_36.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc13_36: init %i32 = call %.loc13_36.4(%.loc13_36.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_36.5: %i32 = value_of_initializer %int.convert_checked.loc13_36 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_36.6: %i32 = converted %.loc13_36.1, %.loc13_36.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_36.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_26.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_26.3: <bound method> = bound_method %.loc13_26.1, %.loc13_26.2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc13_26.4: <specific function> = specific_function %.loc13_26.3, @Convert.2(constants.%.1) [template = constants.%.41]
+// CHECK:STDOUT:   %int.convert_checked.loc13_26: init %i32 = call %.loc13_26.4(%.loc13_26.1) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_26.5: %i32 = value_of_initializer %int.convert_checked.loc13_26 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_26.6: %i32 = converted %.loc13_26.1, %.loc13_26.5 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_35.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_35.2: %i32 = converted %int.snegate.loc13, %.loc13_35.1 [template = constants.%.43]
+// CHECK:STDOUT:   %int.greater_eq.loc13: init bool = call %GreaterEq.ref.loc13(%.loc13_26.6, %.loc13_35.2) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_13.1: bool = value_of_initializer %int.greater_eq.loc13 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_13.2: bool = converted %int.greater_eq.loc13, %.loc13_13.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc13_13.2 br !if.expr.then.loc13 else br !if.expr.else.loc13
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc13:

toolchain/check/testdata/builtins/int/left_shift.carbon

@@ -78,22 +78,22 @@ let negative: i32 = LeftShift(1, Negate(1));
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 20 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 20 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 20 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 20 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -148,39 +148,39 @@ let negative: i32 = LeftShift(1, Negate(1));
 // CHECK:STDOUT:   %LeftShift.ref: %LeftShift.type = name_ref LeftShift, %LeftShift.decl [template = constants.%LeftShift]
 // CHECK:STDOUT:   %.loc4_26.1: Core.IntLiteral = int_value 5 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_29.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_26.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_26.3: <bound method> = bound_method %.loc4_26.1, %.loc4_26.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_26.4: <specific function> = specific_function %.loc4_26.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_26: init %i32 = call %.loc4_26.4(%.loc4_26.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_26.5: %i32 = value_of_initializer %int.convert_checked.loc4_26 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_26.6: %i32 = converted %.loc4_26.1, %.loc4_26.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_29.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_29.3: <bound method> = bound_method %.loc4_29.1, %.loc4_29.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_29.4: <specific function> = specific_function %.loc4_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_29: init %i32 = call %.loc4_29.4(%.loc4_29.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_29.5: %i32 = value_of_initializer %int.convert_checked.loc4_29 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_29.6: %i32 = converted %.loc4_29.1, %.loc4_29.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.left_shift: init %i32 = call %LeftShift.ref(%.loc4_26.6, %.loc4_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_26.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_26.3: <bound method> = bound_method %.loc4_26.1, %.loc4_26.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_26.4: <specific function> = specific_function %.loc4_26.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_26: init %i32 = call %.loc4_26.4(%.loc4_26.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_26.5: %i32 = value_of_initializer %int.convert_checked.loc4_26 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_26.6: %i32 = converted %.loc4_26.1, %.loc4_26.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_29.3: <bound method> = bound_method %.loc4_29.1, %.loc4_29.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_29.4: <specific function> = specific_function %.loc4_29.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_29: init %i32 = call %.loc4_29.4(%.loc4_29.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_29.5: %i32 = value_of_initializer %int.convert_checked.loc4_29 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_29.6: %i32 = converted %.loc4_29.1, %.loc4_29.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.left_shift: init %i32 = call %LeftShift.ref(%.loc4_26.6, %.loc4_29.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_25.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_25.2: <bound method> = bound_method %int.left_shift, %.loc4_25.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_25.3: <specific function> = specific_function %.loc4_25.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_25.4: %i32 = value_of_initializer %int.left_shift [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_25.5: %i32 = converted %int.left_shift, %.loc4_25.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_25: init Core.IntLiteral = call %.loc4_25.3(%.loc4_25.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_25 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25.7: Core.IntLiteral = converted %int.left_shift, %.loc4_25.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_31: type = array_type %.loc4_25.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_25.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_25.2: <bound method> = bound_method %int.left_shift, %.loc4_25.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_25.3: <specific function> = specific_function %.loc4_25.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_25.4: %i32 = value_of_initializer %int.left_shift [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_25.5: %i32 = converted %int.left_shift, %.loc4_25.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_25: init Core.IntLiteral = call %.loc4_25.3(%.loc4_25.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_25 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25.7: Core.IntLiteral = converted %int.left_shift, %.loc4_25.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_31: type = array_type %.loc4_25.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 20 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 20 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_20: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_21: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_20: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_21: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -225,9 +225,9 @@ let negative: i32 = LeftShift(1, Negate(1));
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -247,30 +247,30 @@ let negative: i32 = LeftShift(1, Negate(1));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 31 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value -2147483648 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.1, %Convert.14 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
 // CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 32 [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 33 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 31 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.1, %Convert.14 [template]
 // CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 33 [template]
-// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 1000 [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 32 [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 33 [template]
 // CHECK:STDOUT:   %.39: <bound method> = bound_method %.38, %Convert.14 [template]
 // CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.41: %i32 = int_value 1000 [template]
-// CHECK:STDOUT:   %.42: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.43: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.44: <bound method> = bound_method %.43, %Convert.14 [template]
-// CHECK:STDOUT:   %.45: <specific function> = specific_function %.44, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.46: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 33 [template]
+// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 1000 [template]
+// CHECK:STDOUT:   %.43: <bound method> = bound_method %.42, %Convert.14 [template]
+// CHECK:STDOUT:   %.44: <specific function> = specific_function %.43, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.45: %i32 = int_value 1000 [template]
+// CHECK:STDOUT:   %.46: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.47: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.48: <bound method> = bound_method %.47, %Convert.14 [template]
+// CHECK:STDOUT:   %.49: <specific function> = specific_function %.48, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.50: %i32 = int_value -1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -386,132 +386,132 @@ let negative: i32 = LeftShift(1, Negate(1));
 // CHECK:STDOUT:   %LeftShift.ref.loc8: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
 // CHECK:STDOUT:   %.loc8_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc8_32.1: Core.IntLiteral = int_value 31 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc8_29.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_29.3: <bound method> = bound_method %.loc8_29.1, %.loc8_29.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc8_29.4: <specific function> = specific_function %.loc8_29.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc8_29: init %i32 = call %.loc8_29.4(%.loc8_29.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_29.5: %i32 = value_of_initializer %int.convert_checked.loc8_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_29.6: %i32 = converted %.loc8_29.1, %.loc8_29.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_32.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_32.3: <bound method> = bound_method %.loc8_32.1, %.loc8_32.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc8_32.4: <specific function> = specific_function %.loc8_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc8_32: init %i32 = call %.loc8_32.4(%.loc8_32.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_32.5: %i32 = value_of_initializer %int.convert_checked.loc8_32 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_32.6: %i32 = converted %.loc8_32.1, %.loc8_32.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.left_shift.loc8: init %i32 = call %LeftShift.ref.loc8(%.loc8_29.6, %.loc8_32.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_35.1: %i32 = value_of_initializer %int.left_shift.loc8 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_35.2: %i32 = converted %int.left_shift.loc8, %.loc8_35.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_29.3: <bound method> = bound_method %.loc8_29.1, %.loc8_29.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc8_29.4: <specific function> = specific_function %.loc8_29.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc8_29: init %i32 = call %.loc8_29.4(%.loc8_29.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_29.5: %i32 = value_of_initializer %int.convert_checked.loc8_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_29.6: %i32 = converted %.loc8_29.1, %.loc8_29.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_32.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_32.3: <bound method> = bound_method %.loc8_32.1, %.loc8_32.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc8_32.4: <specific function> = specific_function %.loc8_32.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc8_32: init %i32 = call %.loc8_32.4(%.loc8_32.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_32.5: %i32 = value_of_initializer %int.convert_checked.loc8_32 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_32.6: %i32 = converted %.loc8_32.1, %.loc8_32.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.left_shift.loc8: init %i32 = call %LeftShift.ref.loc8(%.loc8_29.6, %.loc8_32.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_35.1: %i32 = value_of_initializer %int.left_shift.loc8 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_35.2: %i32 = converted %int.left_shift.loc8, %.loc8_35.1 [template = constants.%.34]
 // CHECK:STDOUT:   %size_1: %i32 = bind_name size_1, %.loc8_35.2
 // CHECK:STDOUT:   %LeftShift.ref.loc13: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
 // CHECK:STDOUT:   %.loc13_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc13_32.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc13_29.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_29.3: <bound method> = bound_method %.loc13_29.1, %.loc13_29.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc13_29.4: <specific function> = specific_function %.loc13_29.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc13_29: init %i32 = call %.loc13_29.4(%.loc13_29.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_29.5: %i32 = value_of_initializer %int.convert_checked.loc13_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_29.6: %i32 = converted %.loc13_29.1, %.loc13_29.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_32.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_32.3: <bound method> = bound_method %.loc13_32.1, %.loc13_32.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc13_32.4: <specific function> = specific_function %.loc13_32.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc13_32: init %i32 = call %.loc13_32.4(%.loc13_32.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_32.5: %i32 = value_of_initializer %int.convert_checked.loc13_32 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_32.6: %i32 = converted %.loc13_32.1, %.loc13_32.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_29.3: <bound method> = bound_method %.loc13_29.1, %.loc13_29.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_29.4: <specific function> = specific_function %.loc13_29.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc13_29: init %i32 = call %.loc13_29.4(%.loc13_29.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_29.5: %i32 = value_of_initializer %int.convert_checked.loc13_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_29.6: %i32 = converted %.loc13_29.1, %.loc13_29.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_32.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_32.3: <bound method> = bound_method %.loc13_32.1, %.loc13_32.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_32.4: <specific function> = specific_function %.loc13_32.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc13_32: init %i32 = call %.loc13_32.4(%.loc13_32.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_32.5: %i32 = value_of_initializer %int.convert_checked.loc13_32 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_32.6: %i32 = converted %.loc13_32.1, %.loc13_32.5 [template = constants.%.37]
 // CHECK:STDOUT:   %int.left_shift.loc13: init %i32 = call %LeftShift.ref.loc13(%.loc13_29.6, %.loc13_32.6) [template = <error>]
 // CHECK:STDOUT:   %.loc13_35.1: %i32 = value_of_initializer %int.left_shift.loc13 [template = <error>]
 // CHECK:STDOUT:   %.loc13_35.2: %i32 = converted %int.left_shift.loc13, %.loc13_35.1 [template = <error>]
 // CHECK:STDOUT:   %size_2: %i32 = bind_name size_2, %.loc13_35.2
 // CHECK:STDOUT:   %LeftShift.ref.loc18: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
 // CHECK:STDOUT:   %.loc18_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc18_32.1: Core.IntLiteral = int_value 33 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc18_29.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_29.3: <bound method> = bound_method %.loc18_29.1, %.loc18_29.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc18_29.4: <specific function> = specific_function %.loc18_29.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc18_29: init %i32 = call %.loc18_29.4(%.loc18_29.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc18_29.5: %i32 = value_of_initializer %int.convert_checked.loc18_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc18_29.6: %i32 = converted %.loc18_29.1, %.loc18_29.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc18_32.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_32.3: <bound method> = bound_method %.loc18_32.1, %.loc18_32.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc18_32.4: <specific function> = specific_function %.loc18_32.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc18_32: init %i32 = call %.loc18_32.4(%.loc18_32.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc18_32.5: %i32 = value_of_initializer %int.convert_checked.loc18_32 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc18_32.6: %i32 = converted %.loc18_32.1, %.loc18_32.5 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc18_32.1: Core.IntLiteral = int_value 33 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc18_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_29.3: <bound method> = bound_method %.loc18_29.1, %.loc18_29.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc18_29.4: <specific function> = specific_function %.loc18_29.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc18_29: init %i32 = call %.loc18_29.4(%.loc18_29.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_29.5: %i32 = value_of_initializer %int.convert_checked.loc18_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_29.6: %i32 = converted %.loc18_29.1, %.loc18_29.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_32.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_32.3: <bound method> = bound_method %.loc18_32.1, %.loc18_32.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc18_32.4: <specific function> = specific_function %.loc18_32.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc18_32: init %i32 = call %.loc18_32.4(%.loc18_32.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc18_32.5: %i32 = value_of_initializer %int.convert_checked.loc18_32 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc18_32.6: %i32 = converted %.loc18_32.1, %.loc18_32.5 [template = constants.%.41]
 // CHECK:STDOUT:   %int.left_shift.loc18: init %i32 = call %LeftShift.ref.loc18(%.loc18_29.6, %.loc18_32.6) [template = <error>]
 // CHECK:STDOUT:   %.loc18_35.1: %i32 = value_of_initializer %int.left_shift.loc18 [template = <error>]
 // CHECK:STDOUT:   %.loc18_35.2: %i32 = converted %int.left_shift.loc18, %.loc18_35.1 [template = <error>]
 // CHECK:STDOUT:   %size_3: %i32 = bind_name size_3, %.loc18_35.2
 // CHECK:STDOUT:   %LeftShift.ref.loc21: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
-// CHECK:STDOUT:   %.loc21_33.1: Core.IntLiteral = int_value 1000 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc21_33.1: Core.IntLiteral = int_value 1000 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc21_39.1: Core.IntLiteral = int_value 31 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc21_33.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_33.3: <bound method> = bound_method %.loc21_33.1, %.loc21_33.2 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc21_33.4: <specific function> = specific_function %.loc21_33.3, @Convert.2(constants.%.1) [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc21_33: init %i32 = call %.loc21_33.4(%.loc21_33.1) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_33.5: %i32 = value_of_initializer %int.convert_checked.loc21_33 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_33.6: %i32 = converted %.loc21_33.1, %.loc21_33.5 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc21_39.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc21_39.3: <bound method> = bound_method %.loc21_39.1, %.loc21_39.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc21_39.4: <specific function> = specific_function %.loc21_39.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc21_39: init %i32 = call %.loc21_39.4(%.loc21_39.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_39.5: %i32 = value_of_initializer %int.convert_checked.loc21_39 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc21_39.6: %i32 = converted %.loc21_39.1, %.loc21_39.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.left_shift.loc21: init %i32 = call %LeftShift.ref.loc21(%.loc21_33.6, %.loc21_39.6) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc21_42.1: %i32 = value_of_initializer %int.left_shift.loc21 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc21_42.2: %i32 = converted %int.left_shift.loc21, %.loc21_42.1 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc21_33.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_33.3: <bound method> = bound_method %.loc21_33.1, %.loc21_33.2 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc21_33.4: <specific function> = specific_function %.loc21_33.3, @Convert.2(constants.%.1) [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc21_33: init %i32 = call %.loc21_33.4(%.loc21_33.1) [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_33.5: %i32 = value_of_initializer %int.convert_checked.loc21_33 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_33.6: %i32 = converted %.loc21_33.1, %.loc21_33.5 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc21_39.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc21_39.3: <bound method> = bound_method %.loc21_39.1, %.loc21_39.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc21_39.4: <specific function> = specific_function %.loc21_39.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc21_39: init %i32 = call %.loc21_39.4(%.loc21_39.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_39.5: %i32 = value_of_initializer %int.convert_checked.loc21_39 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc21_39.6: %i32 = converted %.loc21_39.1, %.loc21_39.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.left_shift.loc21: init %i32 = call %LeftShift.ref.loc21(%.loc21_33.6, %.loc21_39.6) [template = constants.%.46]
+// CHECK:STDOUT:   %.loc21_42.1: %i32 = value_of_initializer %int.left_shift.loc21 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc21_42.2: %i32 = converted %int.left_shift.loc21, %.loc21_42.1 [template = constants.%.46]
 // CHECK:STDOUT:   %overflow_1: %i32 = bind_name overflow_1, %.loc21_42.2
 // CHECK:STDOUT:   %LeftShift.ref.loc26: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
-// CHECK:STDOUT:   %.loc26_33.1: Core.IntLiteral = int_value 1000 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc26_33.1: Core.IntLiteral = int_value 1000 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc26_39.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc26_33.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc26_33.3: <bound method> = bound_method %.loc26_33.1, %.loc26_33.2 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc26_33.4: <specific function> = specific_function %.loc26_33.3, @Convert.2(constants.%.1) [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc26_33: init %i32 = call %.loc26_33.4(%.loc26_33.1) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc26_33.5: %i32 = value_of_initializer %int.convert_checked.loc26_33 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc26_33.6: %i32 = converted %.loc26_33.1, %.loc26_33.5 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc26_39.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc26_39.3: <bound method> = bound_method %.loc26_39.1, %.loc26_39.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc26_39.4: <specific function> = specific_function %.loc26_39.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc26_39: init %i32 = call %.loc26_39.4(%.loc26_39.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc26_39.5: %i32 = value_of_initializer %int.convert_checked.loc26_39 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc26_39.6: %i32 = converted %.loc26_39.1, %.loc26_39.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc26_33.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc26_33.3: <bound method> = bound_method %.loc26_33.1, %.loc26_33.2 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc26_33.4: <specific function> = specific_function %.loc26_33.3, @Convert.2(constants.%.1) [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc26_33: init %i32 = call %.loc26_33.4(%.loc26_33.1) [template = constants.%.45]
+// CHECK:STDOUT:   %.loc26_33.5: %i32 = value_of_initializer %int.convert_checked.loc26_33 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc26_33.6: %i32 = converted %.loc26_33.1, %.loc26_33.5 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc26_39.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc26_39.3: <bound method> = bound_method %.loc26_39.1, %.loc26_39.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc26_39.4: <specific function> = specific_function %.loc26_39.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc26_39: init %i32 = call %.loc26_39.4(%.loc26_39.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc26_39.5: %i32 = value_of_initializer %int.convert_checked.loc26_39 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc26_39.6: %i32 = converted %.loc26_39.1, %.loc26_39.5 [template = constants.%.37]
 // CHECK:STDOUT:   %int.left_shift.loc26: init %i32 = call %LeftShift.ref.loc26(%.loc26_33.6, %.loc26_39.6) [template = <error>]
 // CHECK:STDOUT:   %.loc26_42.1: %i32 = value_of_initializer %int.left_shift.loc26 [template = <error>]
 // CHECK:STDOUT:   %.loc26_42.2: %i32 = converted %int.left_shift.loc26, %.loc26_42.1 [template = <error>]
 // CHECK:STDOUT:   %overflow_2: %i32 = bind_name overflow_2, %.loc26_42.2
 // CHECK:STDOUT:   %LeftShift.ref.loc29: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
-// CHECK:STDOUT:   %.loc29_36.1: Core.IntLiteral = int_value 0 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc29_36.1: Core.IntLiteral = int_value 0 [template = constants.%.47]
 // CHECK:STDOUT:   %.loc29_39.1: Core.IntLiteral = int_value 31 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc29_36.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc29_36.3: <bound method> = bound_method %.loc29_36.1, %.loc29_36.2 [template = constants.%.44]
-// CHECK:STDOUT:   %.loc29_36.4: <specific function> = specific_function %.loc29_36.3, @Convert.2(constants.%.1) [template = constants.%.45]
-// CHECK:STDOUT:   %int.convert_checked.loc29_36: init %i32 = call %.loc29_36.4(%.loc29_36.1) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc29_36.5: %i32 = value_of_initializer %int.convert_checked.loc29_36 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc29_36.6: %i32 = converted %.loc29_36.1, %.loc29_36.5 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc29_39.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc29_39.3: <bound method> = bound_method %.loc29_39.1, %.loc29_39.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc29_39.4: <specific function> = specific_function %.loc29_39.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc29_39: init %i32 = call %.loc29_39.4(%.loc29_39.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc29_39.5: %i32 = value_of_initializer %int.convert_checked.loc29_39 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc29_39.6: %i32 = converted %.loc29_39.1, %.loc29_39.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.left_shift.loc29: init %i32 = call %LeftShift.ref.loc29(%.loc29_36.6, %.loc29_39.6) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc29_42.1: %i32 = value_of_initializer %int.left_shift.loc29 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc29_42.2: %i32 = converted %int.left_shift.loc29, %.loc29_42.1 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc29_36.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc29_36.3: <bound method> = bound_method %.loc29_36.1, %.loc29_36.2 [template = constants.%.48]
+// CHECK:STDOUT:   %.loc29_36.4: <specific function> = specific_function %.loc29_36.3, @Convert.2(constants.%.1) [template = constants.%.49]
+// CHECK:STDOUT:   %int.convert_checked.loc29_36: init %i32 = call %.loc29_36.4(%.loc29_36.1) [template = constants.%.46]
+// CHECK:STDOUT:   %.loc29_36.5: %i32 = value_of_initializer %int.convert_checked.loc29_36 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc29_36.6: %i32 = converted %.loc29_36.1, %.loc29_36.5 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc29_39.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc29_39.3: <bound method> = bound_method %.loc29_39.1, %.loc29_39.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc29_39.4: <specific function> = specific_function %.loc29_39.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc29_39: init %i32 = call %.loc29_39.4(%.loc29_39.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc29_39.5: %i32 = value_of_initializer %int.convert_checked.loc29_39 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc29_39.6: %i32 = converted %.loc29_39.1, %.loc29_39.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.left_shift.loc29: init %i32 = call %LeftShift.ref.loc29(%.loc29_36.6, %.loc29_39.6) [template = constants.%.46]
+// CHECK:STDOUT:   %.loc29_42.1: %i32 = value_of_initializer %int.left_shift.loc29 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc29_42.2: %i32 = converted %int.left_shift.loc29, %.loc29_42.1 [template = constants.%.46]
 // CHECK:STDOUT:   %no_overflow_1: %i32 = bind_name no_overflow_1, %.loc29_42.2
 // CHECK:STDOUT:   %LeftShift.ref.loc34: %LeftShift.type = name_ref LeftShift, file.%LeftShift.decl [template = constants.%LeftShift]
-// CHECK:STDOUT:   %.loc34_36.1: Core.IntLiteral = int_value 0 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc34_36.1: Core.IntLiteral = int_value 0 [template = constants.%.47]
 // CHECK:STDOUT:   %.loc34_39.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc34_36.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc34_36.3: <bound method> = bound_method %.loc34_36.1, %.loc34_36.2 [template = constants.%.44]
-// CHECK:STDOUT:   %.loc34_36.4: <specific function> = specific_function %.loc34_36.3, @Convert.2(constants.%.1) [template = constants.%.45]
-// CHECK:STDOUT:   %int.convert_checked.loc34_36: init %i32 = call %.loc34_36.4(%.loc34_36.1) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc34_36.5: %i32 = value_of_initializer %int.convert_checked.loc34_36 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc34_36.6: %i32 = converted %.loc34_36.1, %.loc34_36.5 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc34_39.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc34_39.3: <bound method> = bound_method %.loc34_39.1, %.loc34_39.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc34_39.4: <specific function> = specific_function %.loc34_39.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc34_39: init %i32 = call %.loc34_39.4(%.loc34_39.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc34_39.5: %i32 = value_of_initializer %int.convert_checked.loc34_39 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc34_39.6: %i32 = converted %.loc34_39.1, %.loc34_39.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc34_36.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc34_36.3: <bound method> = bound_method %.loc34_36.1, %.loc34_36.2 [template = constants.%.48]
+// CHECK:STDOUT:   %.loc34_36.4: <specific function> = specific_function %.loc34_36.3, @Convert.2(constants.%.1) [template = constants.%.49]
+// CHECK:STDOUT:   %int.convert_checked.loc34_36: init %i32 = call %.loc34_36.4(%.loc34_36.1) [template = constants.%.46]
+// CHECK:STDOUT:   %.loc34_36.5: %i32 = value_of_initializer %int.convert_checked.loc34_36 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc34_36.6: %i32 = converted %.loc34_36.1, %.loc34_36.5 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc34_39.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc34_39.3: <bound method> = bound_method %.loc34_39.1, %.loc34_39.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc34_39.4: <specific function> = specific_function %.loc34_39.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc34_39: init %i32 = call %.loc34_39.4(%.loc34_39.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc34_39.5: %i32 = value_of_initializer %int.convert_checked.loc34_39 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc34_39.6: %i32 = converted %.loc34_39.1, %.loc34_39.5 [template = constants.%.37]
 // CHECK:STDOUT:   %int.left_shift.loc34: init %i32 = call %LeftShift.ref.loc34(%.loc34_36.6, %.loc34_39.6) [template = <error>]
 // CHECK:STDOUT:   %.loc34_42.1: %i32 = value_of_initializer %int.left_shift.loc34 [template = <error>]
 // CHECK:STDOUT:   %.loc34_42.2: %i32 = converted %int.left_shift.loc34, %.loc34_42.1 [template = <error>]
@@ -520,21 +520,21 @@ let negative: i32 = LeftShift(1, Negate(1));
 // CHECK:STDOUT:   %.loc40_31.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc40_41.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc40_41.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc40_41.3: <bound method> = bound_method %.loc40_41.1, %.loc40_41.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc40_41.4: <specific function> = specific_function %.loc40_41.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc40_41: init %i32 = call %.loc40_41.4(%.loc40_41.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc40_41.5: %i32 = value_of_initializer %int.convert_checked.loc40_41 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc40_41.6: %i32 = converted %.loc40_41.1, %.loc40_41.5 [template = constants.%.26]
-// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc40_41.6) [template = constants.%.46]
-// CHECK:STDOUT:   %.loc40_31.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc40_31.3: <bound method> = bound_method %.loc40_31.1, %.loc40_31.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc40_31.4: <specific function> = specific_function %.loc40_31.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc40_31: init %i32 = call %.loc40_31.4(%.loc40_31.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc40_31.5: %i32 = value_of_initializer %int.convert_checked.loc40_31 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc40_31.6: %i32 = converted %.loc40_31.1, %.loc40_31.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc40_40.1: %i32 = value_of_initializer %int.snegate [template = constants.%.46]
-// CHECK:STDOUT:   %.loc40_40.2: %i32 = converted %int.snegate, %.loc40_40.1 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc40_41.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc40_41.3: <bound method> = bound_method %.loc40_41.1, %.loc40_41.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc40_41.4: <specific function> = specific_function %.loc40_41.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc40_41: init %i32 = call %.loc40_41.4(%.loc40_41.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc40_41.5: %i32 = value_of_initializer %int.convert_checked.loc40_41 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc40_41.6: %i32 = converted %.loc40_41.1, %.loc40_41.5 [template = constants.%.30]
+// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc40_41.6) [template = constants.%.50]
+// CHECK:STDOUT:   %.loc40_31.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc40_31.3: <bound method> = bound_method %.loc40_31.1, %.loc40_31.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc40_31.4: <specific function> = specific_function %.loc40_31.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc40_31: init %i32 = call %.loc40_31.4(%.loc40_31.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc40_31.5: %i32 = value_of_initializer %int.convert_checked.loc40_31 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc40_31.6: %i32 = converted %.loc40_31.1, %.loc40_31.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc40_40.1: %i32 = value_of_initializer %int.snegate [template = constants.%.50]
+// CHECK:STDOUT:   %.loc40_40.2: %i32 = converted %int.snegate, %.loc40_40.1 [template = constants.%.50]
 // CHECK:STDOUT:   %int.left_shift.loc40: init %i32 = call %LeftShift.ref.loc40(%.loc40_31.6, %.loc40_40.2) [template = <error>]
 // CHECK:STDOUT:   %.loc40_44.1: %i32 = value_of_initializer %int.left_shift.loc40 [template = <error>]
 // CHECK:STDOUT:   %.loc40_44.2: %i32 = converted %int.left_shift.loc40, %.loc40_44.1 [template = <error>]

toolchain/check/testdata/builtins/int/less.carbon

@@ -52,20 +52,20 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.33: bool = bool_literal true [template]
-// CHECK:STDOUT:   %.34: bool = bool_literal false [template]
-// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.36: <bound method> = bound_method %.35, %Convert.14 [template]
-// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.38: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.37: bool = bool_literal true [template]
+// CHECK:STDOUT:   %.38: bool = bool_literal false [template]
+// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.40: <bound method> = bound_method %.39, %Convert.14 [template]
+// CHECK:STDOUT:   %.41: <specific function> = specific_function %.40, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.42: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -203,21 +203,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Less.ref.loc9: %Less.type = name_ref Less, file.%Less.decl [template = constants.%Less]
 // CHECK:STDOUT:   %.loc9_21.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_24.1: Core.IntLiteral = int_value 2 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc9_21.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_21.3: <bound method> = bound_method %.loc9_21.1, %.loc9_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_21.4: <specific function> = specific_function %.loc9_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc9_21: init %i32 = call %.loc9_21.4(%.loc9_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_21.5: %i32 = value_of_initializer %int.convert_checked.loc9_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_21.6: %i32 = converted %.loc9_21.1, %.loc9_21.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_24.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_24.3: <bound method> = bound_method %.loc9_24.1, %.loc9_24.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_24.4: <specific function> = specific_function %.loc9_24.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc9_24: init %i32 = call %.loc9_24.4(%.loc9_24.1) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_24.5: %i32 = value_of_initializer %int.convert_checked.loc9_24 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_24.6: %i32 = converted %.loc9_24.1, %.loc9_24.5 [template = constants.%.32]
-// CHECK:STDOUT:   %int.less.loc9: init bool = call %Less.ref.loc9(%.loc9_21.6, %.loc9_24.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_13.1: bool = value_of_initializer %int.less.loc9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_13.2: bool = converted %int.less.loc9, %.loc9_13.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_21.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_21.3: <bound method> = bound_method %.loc9_21.1, %.loc9_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_21.4: <specific function> = specific_function %.loc9_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc9_21: init %i32 = call %.loc9_21.4(%.loc9_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_21.5: %i32 = value_of_initializer %int.convert_checked.loc9_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_21.6: %i32 = converted %.loc9_21.1, %.loc9_21.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_24.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_24.3: <bound method> = bound_method %.loc9_24.1, %.loc9_24.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_24.4: <specific function> = specific_function %.loc9_24.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc9_24: init %i32 = call %.loc9_24.4(%.loc9_24.1) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_24.5: %i32 = value_of_initializer %int.convert_checked.loc9_24 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_24.6: %i32 = converted %.loc9_24.1, %.loc9_24.5 [template = constants.%.36]
+// CHECK:STDOUT:   %int.less.loc9: init bool = call %Less.ref.loc9(%.loc9_21.6, %.loc9_24.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_13.1: bool = value_of_initializer %int.less.loc9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_13.2: bool = converted %int.less.loc9, %.loc9_13.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc9_13.2 br !if.expr.then.loc9 else br !if.expr.else.loc9
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc9:
@@ -234,21 +234,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Less.ref.loc10: %Less.type = name_ref Less, file.%Less.decl [template = constants.%Less]
 // CHECK:STDOUT:   %.loc10_22.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_25.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc10_22.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_22.3: <bound method> = bound_method %.loc10_22.1, %.loc10_22.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_22.4: <specific function> = specific_function %.loc10_22.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_22: init %i32 = call %.loc10_22.4(%.loc10_22.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_22.5: %i32 = value_of_initializer %int.convert_checked.loc10_22 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_22.6: %i32 = converted %.loc10_22.1, %.loc10_22.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_25.3: <bound method> = bound_method %.loc10_25.1, %.loc10_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_25.4: <specific function> = specific_function %.loc10_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_25: init %i32 = call %.loc10_25.4(%.loc10_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_25.5: %i32 = value_of_initializer %int.convert_checked.loc10_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_25.6: %i32 = converted %.loc10_25.1, %.loc10_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.less.loc10: init bool = call %Less.ref.loc10(%.loc10_22.6, %.loc10_25.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_14.1: bool = value_of_initializer %int.less.loc10 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_14.2: bool = converted %int.less.loc10, %.loc10_14.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc10_22.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_22.3: <bound method> = bound_method %.loc10_22.1, %.loc10_22.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_22.4: <specific function> = specific_function %.loc10_22.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_22: init %i32 = call %.loc10_22.4(%.loc10_22.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_22.5: %i32 = value_of_initializer %int.convert_checked.loc10_22 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_22.6: %i32 = converted %.loc10_22.1, %.loc10_22.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_25.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_25.3: <bound method> = bound_method %.loc10_25.1, %.loc10_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_25.4: <specific function> = specific_function %.loc10_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_25: init %i32 = call %.loc10_25.4(%.loc10_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_25.5: %i32 = value_of_initializer %int.convert_checked.loc10_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_25.6: %i32 = converted %.loc10_25.1, %.loc10_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.less.loc10: init bool = call %Less.ref.loc10(%.loc10_22.6, %.loc10_25.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_14.1: bool = value_of_initializer %int.less.loc10 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_14.2: bool = converted %int.less.loc10, %.loc10_14.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc10_14.2 br !if.expr.then.loc10 else br !if.expr.else.loc10
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc10:
@@ -264,22 +264,22 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %false_.ref.loc11: %False = name_ref false_, %false_
 // CHECK:STDOUT:   %Less.ref.loc11: %Less.type = name_ref Less, file.%Less.decl [template = constants.%Less]
 // CHECK:STDOUT:   %.loc11_22.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc11_25.1: Core.IntLiteral = int_value 0 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc11_22.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_22.3: <bound method> = bound_method %.loc11_22.1, %.loc11_22.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_22.4: <specific function> = specific_function %.loc11_22.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc11_22: init %i32 = call %.loc11_22.4(%.loc11_22.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_22.5: %i32 = value_of_initializer %int.convert_checked.loc11_22 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_22.6: %i32 = converted %.loc11_22.1, %.loc11_22.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_25.3: <bound method> = bound_method %.loc11_25.1, %.loc11_25.2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_25.4: <specific function> = specific_function %.loc11_25.3, @Convert.2(constants.%.1) [template = constants.%.37]
-// CHECK:STDOUT:   %int.convert_checked.loc11_25: init %i32 = call %.loc11_25.4(%.loc11_25.1) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_25.5: %i32 = value_of_initializer %int.convert_checked.loc11_25 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_25.6: %i32 = converted %.loc11_25.1, %.loc11_25.5 [template = constants.%.38]
-// CHECK:STDOUT:   %int.less.loc11: init bool = call %Less.ref.loc11(%.loc11_22.6, %.loc11_25.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_14.1: bool = value_of_initializer %int.less.loc11 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_14.2: bool = converted %int.less.loc11, %.loc11_14.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_25.1: Core.IntLiteral = int_value 0 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc11_22.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_22.3: <bound method> = bound_method %.loc11_22.1, %.loc11_22.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_22.4: <specific function> = specific_function %.loc11_22.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc11_22: init %i32 = call %.loc11_22.4(%.loc11_22.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_22.5: %i32 = value_of_initializer %int.convert_checked.loc11_22 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_22.6: %i32 = converted %.loc11_22.1, %.loc11_22.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_25.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_25.3: <bound method> = bound_method %.loc11_25.1, %.loc11_25.2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_25.4: <specific function> = specific_function %.loc11_25.3, @Convert.2(constants.%.1) [template = constants.%.41]
+// CHECK:STDOUT:   %int.convert_checked.loc11_25: init %i32 = call %.loc11_25.4(%.loc11_25.1) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_25.5: %i32 = value_of_initializer %int.convert_checked.loc11_25 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_25.6: %i32 = converted %.loc11_25.1, %.loc11_25.5 [template = constants.%.42]
+// CHECK:STDOUT:   %int.less.loc11: init bool = call %Less.ref.loc11(%.loc11_22.6, %.loc11_25.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_14.1: bool = value_of_initializer %int.less.loc11 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_14.2: bool = converted %int.less.loc11, %.loc11_14.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc11_14.2 br !if.expr.then.loc11 else br !if.expr.else.loc11
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc11:
@@ -296,25 +296,25 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Less.ref.loc12: %Less.type = name_ref Less, file.%Less.decl [template = constants.%Less]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_28.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc12_28.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_28.3: <bound method> = bound_method %.loc12_28.1, %.loc12_28.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_28.4: <specific function> = specific_function %.loc12_28.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12_28: init %i32 = call %.loc12_28.4(%.loc12_28.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_28.5: %i32 = value_of_initializer %int.convert_checked.loc12_28 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_28.6: %i32 = converted %.loc12_28.1, %.loc12_28.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_28.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_32.1: Core.IntLiteral = int_value 0 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc12_27.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_27.2: %i32 = converted %int.snegate.loc12, %.loc12_27.1 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_32.3: <bound method> = bound_method %.loc12_32.1, %.loc12_32.2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc12_32.4: <specific function> = specific_function %.loc12_32.3, @Convert.2(constants.%.1) [template = constants.%.37]
-// CHECK:STDOUT:   %int.convert_checked.loc12_32: init %i32 = call %.loc12_32.4(%.loc12_32.1) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc12_32.5: %i32 = value_of_initializer %int.convert_checked.loc12_32 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc12_32.6: %i32 = converted %.loc12_32.1, %.loc12_32.5 [template = constants.%.38]
-// CHECK:STDOUT:   %int.less.loc12: init bool = call %Less.ref.loc12(%.loc12_27.2, %.loc12_32.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_13.1: bool = value_of_initializer %int.less.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_13.2: bool = converted %int.less.loc12, %.loc12_13.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_28.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_28.3: <bound method> = bound_method %.loc12_28.1, %.loc12_28.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_28.4: <specific function> = specific_function %.loc12_28.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12_28: init %i32 = call %.loc12_28.4(%.loc12_28.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_28.5: %i32 = value_of_initializer %int.convert_checked.loc12_28 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_28.6: %i32 = converted %.loc12_28.1, %.loc12_28.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_28.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_32.1: Core.IntLiteral = int_value 0 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc12_27.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_27.2: %i32 = converted %int.snegate.loc12, %.loc12_27.1 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_32.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_32.3: <bound method> = bound_method %.loc12_32.1, %.loc12_32.2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc12_32.4: <specific function> = specific_function %.loc12_32.3, @Convert.2(constants.%.1) [template = constants.%.41]
+// CHECK:STDOUT:   %int.convert_checked.loc12_32: init %i32 = call %.loc12_32.4(%.loc12_32.1) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc12_32.5: %i32 = value_of_initializer %int.convert_checked.loc12_32 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc12_32.6: %i32 = converted %.loc12_32.1, %.loc12_32.5 [template = constants.%.42]
+// CHECK:STDOUT:   %int.less.loc12: init bool = call %Less.ref.loc12(%.loc12_27.2, %.loc12_32.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_13.1: bool = value_of_initializer %int.less.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_13.2: bool = converted %int.less.loc12, %.loc12_13.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc12_13.2 br !if.expr.then.loc12 else br !if.expr.else.loc12
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc12:
@@ -329,27 +329,27 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %.loc12_13.3: type = block_arg !if.expr.result.loc12 [template = constants.%True]
 // CHECK:STDOUT:   %false_.ref.loc13: %False = name_ref false_, %false_
 // CHECK:STDOUT:   %Less.ref.loc13: %Less.type = name_ref Less, file.%Less.decl [template = constants.%Less]
-// CHECK:STDOUT:   %.loc13_22.1: Core.IntLiteral = int_value 0 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_22.1: Core.IntLiteral = int_value 0 [template = constants.%.39]
 // CHECK:STDOUT:   %Negate.ref.loc13: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc13_32.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc13_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_32.3: <bound method> = bound_method %.loc13_32.1, %.loc13_32.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_32.4: <specific function> = specific_function %.loc13_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc13_32: init %i32 = call %.loc13_32.4(%.loc13_32.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_32.5: %i32 = value_of_initializer %int.convert_checked.loc13_32 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_32.6: %i32 = converted %.loc13_32.1, %.loc13_32.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_32.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_22.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_22.3: <bound method> = bound_method %.loc13_22.1, %.loc13_22.2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc13_22.4: <specific function> = specific_function %.loc13_22.3, @Convert.2(constants.%.1) [template = constants.%.37]
-// CHECK:STDOUT:   %int.convert_checked.loc13_22: init %i32 = call %.loc13_22.4(%.loc13_22.1) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_22.5: %i32 = value_of_initializer %int.convert_checked.loc13_22 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_22.6: %i32 = converted %.loc13_22.1, %.loc13_22.5 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_31.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_31.2: %i32 = converted %int.snegate.loc13, %.loc13_31.1 [template = constants.%.39]
-// CHECK:STDOUT:   %int.less.loc13: init bool = call %Less.ref.loc13(%.loc13_22.6, %.loc13_31.2) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_14.1: bool = value_of_initializer %int.less.loc13 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_14.2: bool = converted %int.less.loc13, %.loc13_14.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_32.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_32.3: <bound method> = bound_method %.loc13_32.1, %.loc13_32.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_32.4: <specific function> = specific_function %.loc13_32.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc13_32: init %i32 = call %.loc13_32.4(%.loc13_32.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_32.5: %i32 = value_of_initializer %int.convert_checked.loc13_32 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_32.6: %i32 = converted %.loc13_32.1, %.loc13_32.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_32.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_22.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_22.3: <bound method> = bound_method %.loc13_22.1, %.loc13_22.2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc13_22.4: <specific function> = specific_function %.loc13_22.3, @Convert.2(constants.%.1) [template = constants.%.41]
+// CHECK:STDOUT:   %int.convert_checked.loc13_22: init %i32 = call %.loc13_22.4(%.loc13_22.1) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_22.5: %i32 = value_of_initializer %int.convert_checked.loc13_22 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_22.6: %i32 = converted %.loc13_22.1, %.loc13_22.5 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_31.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_31.2: %i32 = converted %int.snegate.loc13, %.loc13_31.1 [template = constants.%.43]
+// CHECK:STDOUT:   %int.less.loc13: init bool = call %Less.ref.loc13(%.loc13_22.6, %.loc13_31.2) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_14.1: bool = value_of_initializer %int.less.loc13 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_14.2: bool = converted %int.less.loc13, %.loc13_14.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc13_14.2 br !if.expr.then.loc13 else br !if.expr.else.loc13
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc13:

toolchain/check/testdata/builtins/int/less_eq.carbon

@@ -52,20 +52,20 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.33: bool = bool_literal true [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
-// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.38: bool = bool_literal false [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.37: bool = bool_literal true [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.39: <bound method> = bound_method %.38, %Convert.14 [template]
+// CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.42: bool = bool_literal false [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -203,21 +203,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %LessEq.ref.loc9: %LessEq.type = name_ref LessEq, file.%LessEq.decl [template = constants.%LessEq]
 // CHECK:STDOUT:   %.loc9_23.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc9_26.1: Core.IntLiteral = int_value 2 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc9_23.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_23.3: <bound method> = bound_method %.loc9_23.1, %.loc9_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_23.4: <specific function> = specific_function %.loc9_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc9_23: init %i32 = call %.loc9_23.4(%.loc9_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_23.5: %i32 = value_of_initializer %int.convert_checked.loc9_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_23.6: %i32 = converted %.loc9_23.1, %.loc9_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_26.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_26.3: <bound method> = bound_method %.loc9_26.1, %.loc9_26.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_26.4: <specific function> = specific_function %.loc9_26.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc9_26: init %i32 = call %.loc9_26.4(%.loc9_26.1) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_26.5: %i32 = value_of_initializer %int.convert_checked.loc9_26 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_26.6: %i32 = converted %.loc9_26.1, %.loc9_26.5 [template = constants.%.32]
-// CHECK:STDOUT:   %int.less_eq.loc9: init bool = call %LessEq.ref.loc9(%.loc9_23.6, %.loc9_26.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_13.1: bool = value_of_initializer %int.less_eq.loc9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_13.2: bool = converted %int.less_eq.loc9, %.loc9_13.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_23.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_23.3: <bound method> = bound_method %.loc9_23.1, %.loc9_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_23.4: <specific function> = specific_function %.loc9_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc9_23: init %i32 = call %.loc9_23.4(%.loc9_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_23.5: %i32 = value_of_initializer %int.convert_checked.loc9_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_23.6: %i32 = converted %.loc9_23.1, %.loc9_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_26.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_26.3: <bound method> = bound_method %.loc9_26.1, %.loc9_26.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_26.4: <specific function> = specific_function %.loc9_26.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc9_26: init %i32 = call %.loc9_26.4(%.loc9_26.1) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_26.5: %i32 = value_of_initializer %int.convert_checked.loc9_26 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_26.6: %i32 = converted %.loc9_26.1, %.loc9_26.5 [template = constants.%.36]
+// CHECK:STDOUT:   %int.less_eq.loc9: init bool = call %LessEq.ref.loc9(%.loc9_23.6, %.loc9_26.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_13.1: bool = value_of_initializer %int.less_eq.loc9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_13.2: bool = converted %int.less_eq.loc9, %.loc9_13.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc9_13.2 br !if.expr.then.loc9 else br !if.expr.else.loc9
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc9:
@@ -234,21 +234,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %LessEq.ref.loc10: %LessEq.type = name_ref LessEq, file.%LessEq.decl [template = constants.%LessEq]
 // CHECK:STDOUT:   %.loc10_23.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc10_26.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc10_23.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_23.3: <bound method> = bound_method %.loc10_23.1, %.loc10_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_23.4: <specific function> = specific_function %.loc10_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_23: init %i32 = call %.loc10_23.4(%.loc10_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_23.5: %i32 = value_of_initializer %int.convert_checked.loc10_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_23.6: %i32 = converted %.loc10_23.1, %.loc10_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_26: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked.loc10_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.less_eq.loc10: init bool = call %LessEq.ref.loc10(%.loc10_23.6, %.loc10_26.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc10_13.1: bool = value_of_initializer %int.less_eq.loc10 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc10_13.2: bool = converted %int.less_eq.loc10, %.loc10_13.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_23.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_23.3: <bound method> = bound_method %.loc10_23.1, %.loc10_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_23.4: <specific function> = specific_function %.loc10_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_23: init %i32 = call %.loc10_23.4(%.loc10_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_23.5: %i32 = value_of_initializer %int.convert_checked.loc10_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_23.6: %i32 = converted %.loc10_23.1, %.loc10_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_26: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked.loc10_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.less_eq.loc10: init bool = call %LessEq.ref.loc10(%.loc10_23.6, %.loc10_26.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_13.1: bool = value_of_initializer %int.less_eq.loc10 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_13.2: bool = converted %int.less_eq.loc10, %.loc10_13.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc10_13.2 br !if.expr.then.loc10 else br !if.expr.else.loc10
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc10:
@@ -264,22 +264,22 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %false_.ref.loc11: %False = name_ref false_, %false_
 // CHECK:STDOUT:   %LessEq.ref.loc11: %LessEq.type = name_ref LessEq, file.%LessEq.decl [template = constants.%LessEq]
 // CHECK:STDOUT:   %.loc11_24.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc11_27.1: Core.IntLiteral = int_value 0 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc11_24.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_24.3: <bound method> = bound_method %.loc11_24.1, %.loc11_24.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_24.4: <specific function> = specific_function %.loc11_24.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc11_24: init %i32 = call %.loc11_24.4(%.loc11_24.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_24.5: %i32 = value_of_initializer %int.convert_checked.loc11_24 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_24.6: %i32 = converted %.loc11_24.1, %.loc11_24.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_27.1, %.loc11_27.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc11_27: init %i32 = call %.loc11_27.4(%.loc11_27.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc11_27.5: %i32 = value_of_initializer %int.convert_checked.loc11_27 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc11_27.6: %i32 = converted %.loc11_27.1, %.loc11_27.5 [template = constants.%.37]
-// CHECK:STDOUT:   %int.less_eq.loc11: init bool = call %LessEq.ref.loc11(%.loc11_24.6, %.loc11_27.6) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_14.1: bool = value_of_initializer %int.less_eq.loc11 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc11_14.2: bool = converted %int.less_eq.loc11, %.loc11_14.1 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_27.1: Core.IntLiteral = int_value 0 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc11_24.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_24.3: <bound method> = bound_method %.loc11_24.1, %.loc11_24.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_24.4: <specific function> = specific_function %.loc11_24.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc11_24: init %i32 = call %.loc11_24.4(%.loc11_24.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_24.5: %i32 = value_of_initializer %int.convert_checked.loc11_24 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_24.6: %i32 = converted %.loc11_24.1, %.loc11_24.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_27.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_27.3: <bound method> = bound_method %.loc11_27.1, %.loc11_27.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc11_27.4: <specific function> = specific_function %.loc11_27.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc11_27: init %i32 = call %.loc11_27.4(%.loc11_27.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc11_27.5: %i32 = value_of_initializer %int.convert_checked.loc11_27 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc11_27.6: %i32 = converted %.loc11_27.1, %.loc11_27.5 [template = constants.%.41]
+// CHECK:STDOUT:   %int.less_eq.loc11: init bool = call %LessEq.ref.loc11(%.loc11_24.6, %.loc11_27.6) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_14.1: bool = value_of_initializer %int.less_eq.loc11 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc11_14.2: bool = converted %int.less_eq.loc11, %.loc11_14.1 [template = constants.%.42]
 // CHECK:STDOUT:   if %.loc11_14.2 br !if.expr.then.loc11 else br !if.expr.else.loc11
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc11:
@@ -296,25 +296,25 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %LessEq.ref.loc12: %LessEq.type = name_ref LessEq, file.%LessEq.decl [template = constants.%LessEq]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_30.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc12_30.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_30.3: <bound method> = bound_method %.loc12_30.1, %.loc12_30.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_30.4: <specific function> = specific_function %.loc12_30.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12_30: init %i32 = call %.loc12_30.4(%.loc12_30.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_30.5: %i32 = value_of_initializer %int.convert_checked.loc12_30 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_30.6: %i32 = converted %.loc12_30.1, %.loc12_30.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_30.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_34.1: Core.IntLiteral = int_value 0 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc12_29.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_29.2: %i32 = converted %int.snegate.loc12, %.loc12_29.1 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc12_34.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_34.3: <bound method> = bound_method %.loc12_34.1, %.loc12_34.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc12_34.4: <specific function> = specific_function %.loc12_34.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc12_34: init %i32 = call %.loc12_34.4(%.loc12_34.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc12_34.5: %i32 = value_of_initializer %int.convert_checked.loc12_34 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc12_34.6: %i32 = converted %.loc12_34.1, %.loc12_34.5 [template = constants.%.37]
-// CHECK:STDOUT:   %int.less_eq.loc12: init bool = call %LessEq.ref.loc12(%.loc12_29.2, %.loc12_34.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_13.1: bool = value_of_initializer %int.less_eq.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_13.2: bool = converted %int.less_eq.loc12, %.loc12_13.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_30.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_30.3: <bound method> = bound_method %.loc12_30.1, %.loc12_30.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_30.4: <specific function> = specific_function %.loc12_30.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12_30: init %i32 = call %.loc12_30.4(%.loc12_30.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_30.5: %i32 = value_of_initializer %int.convert_checked.loc12_30 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_30.6: %i32 = converted %.loc12_30.1, %.loc12_30.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_30.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_34.1: Core.IntLiteral = int_value 0 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc12_29.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_29.2: %i32 = converted %int.snegate.loc12, %.loc12_29.1 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc12_34.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_34.3: <bound method> = bound_method %.loc12_34.1, %.loc12_34.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc12_34.4: <specific function> = specific_function %.loc12_34.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc12_34: init %i32 = call %.loc12_34.4(%.loc12_34.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc12_34.5: %i32 = value_of_initializer %int.convert_checked.loc12_34 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc12_34.6: %i32 = converted %.loc12_34.1, %.loc12_34.5 [template = constants.%.41]
+// CHECK:STDOUT:   %int.less_eq.loc12: init bool = call %LessEq.ref.loc12(%.loc12_29.2, %.loc12_34.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_13.1: bool = value_of_initializer %int.less_eq.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_13.2: bool = converted %int.less_eq.loc12, %.loc12_13.1 [template = constants.%.37]
 // CHECK:STDOUT:   if %.loc12_13.2 br !if.expr.then.loc12 else br !if.expr.else.loc12
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc12:
@@ -329,27 +329,27 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %.loc12_13.3: type = block_arg !if.expr.result.loc12 [template = constants.%True]
 // CHECK:STDOUT:   %false_.ref.loc13: %False = name_ref false_, %false_
 // CHECK:STDOUT:   %LessEq.ref.loc13: %LessEq.type = name_ref LessEq, file.%LessEq.decl [template = constants.%LessEq]
-// CHECK:STDOUT:   %.loc13_24.1: Core.IntLiteral = int_value 0 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_24.1: Core.IntLiteral = int_value 0 [template = constants.%.38]
 // CHECK:STDOUT:   %Negate.ref.loc13: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc13_34.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc13_34.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_34.3: <bound method> = bound_method %.loc13_34.1, %.loc13_34.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_34.4: <specific function> = specific_function %.loc13_34.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc13_34: init %i32 = call %.loc13_34.4(%.loc13_34.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_34.5: %i32 = value_of_initializer %int.convert_checked.loc13_34 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_34.6: %i32 = converted %.loc13_34.1, %.loc13_34.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_34.6) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_24.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_24.3: <bound method> = bound_method %.loc13_24.1, %.loc13_24.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc13_24.4: <specific function> = specific_function %.loc13_24.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc13_24: init %i32 = call %.loc13_24.4(%.loc13_24.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_24.5: %i32 = value_of_initializer %int.convert_checked.loc13_24 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_24.6: %i32 = converted %.loc13_24.1, %.loc13_24.5 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_33.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_33.2: %i32 = converted %int.snegate.loc13, %.loc13_33.1 [template = constants.%.39]
-// CHECK:STDOUT:   %int.less_eq.loc13: init bool = call %LessEq.ref.loc13(%.loc13_24.6, %.loc13_33.2) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_14.1: bool = value_of_initializer %int.less_eq.loc13 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc13_14.2: bool = converted %int.less_eq.loc13, %.loc13_14.1 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_34.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_34.3: <bound method> = bound_method %.loc13_34.1, %.loc13_34.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_34.4: <specific function> = specific_function %.loc13_34.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc13_34: init %i32 = call %.loc13_34.4(%.loc13_34.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_34.5: %i32 = value_of_initializer %int.convert_checked.loc13_34 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_34.6: %i32 = converted %.loc13_34.1, %.loc13_34.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.snegate.loc13: init %i32 = call %Negate.ref.loc13(%.loc13_34.6) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_24.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_24.3: <bound method> = bound_method %.loc13_24.1, %.loc13_24.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_24.4: <specific function> = specific_function %.loc13_24.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc13_24: init %i32 = call %.loc13_24.4(%.loc13_24.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_24.5: %i32 = value_of_initializer %int.convert_checked.loc13_24 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_24.6: %i32 = converted %.loc13_24.1, %.loc13_24.5 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_33.1: %i32 = value_of_initializer %int.snegate.loc13 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_33.2: %i32 = converted %int.snegate.loc13, %.loc13_33.1 [template = constants.%.43]
+// CHECK:STDOUT:   %int.less_eq.loc13: init bool = call %LessEq.ref.loc13(%.loc13_24.6, %.loc13_33.2) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_14.1: bool = value_of_initializer %int.less_eq.loc13 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc13_14.2: bool = converted %int.less_eq.loc13, %.loc13_14.1 [template = constants.%.42]
 // CHECK:STDOUT:   if %.loc13_14.2 br !if.expr.then.loc13 else br !if.expr.else.loc13
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc13:

toolchain/check/testdata/builtins/int/make_type_signed.carbon

@@ -526,17 +526,17 @@ var m: Int(1000000000);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.26, %Convert.15 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value -1 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value -1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -582,21 +582,21 @@ var m: Int(1000000000);
 // CHECK:STDOUT:   %Int.ref: %Int.type.2 = name_ref Int, imports.%import_ref.2 [template = constants.%Int.2]
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_19.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc12_19.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_19.3: <bound method> = bound_method %.loc12_19.1, %.loc12_19.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_19.4: <specific function> = specific_function %.loc12_19.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc12_19: init %i32 = call %.loc12_19.4(%.loc12_19.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_19.5: %i32 = value_of_initializer %int.convert_checked.loc12_19 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_19.6: %i32 = converted %.loc12_19.1, %.loc12_19.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc12_19.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_18.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc12_18.2: <bound method> = bound_method %int.snegate, %.loc12_18.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_18.3: <specific function> = specific_function %.loc12_18.2, @Convert.4(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_18.4: %i32 = value_of_initializer %int.snegate [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_18.5: %i32 = converted %int.snegate, %.loc12_18.4 [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked.loc12_18: init Core.IntLiteral = call %.loc12_18.3(%.loc12_18.5) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_18.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc12_18 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_18.7: Core.IntLiteral = converted %int.snegate, %.loc12_18.6 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_19.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_19.3: <bound method> = bound_method %.loc12_19.1, %.loc12_19.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_19.4: <specific function> = specific_function %.loc12_19.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc12_19: init %i32 = call %.loc12_19.4(%.loc12_19.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_19.5: %i32 = value_of_initializer %int.convert_checked.loc12_19 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_19.6: %i32 = converted %.loc12_19.1, %.loc12_19.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc12_19.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_18.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc12_18.2: <bound method> = bound_method %int.snegate, %.loc12_18.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_18.3: <specific function> = specific_function %.loc12_18.2, @Convert.4(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_18.4: %i32 = value_of_initializer %int.snegate [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_18.5: %i32 = converted %int.snegate, %.loc12_18.4 [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked.loc12_18: init Core.IntLiteral = call %.loc12_18.3(%.loc12_18.5) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_18.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc12_18 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_18.7: Core.IntLiteral = converted %int.snegate, %.loc12_18.6 [template = constants.%.34]
 // CHECK:STDOUT:   %int.make_type_signed: init type = call %Int.ref(%.loc12_18.7) [template = <error>]
 // CHECK:STDOUT:   %.loc12_21.1: type = value_of_initializer %int.make_type_signed [template = <error>]
 // CHECK:STDOUT:   %.loc12_21.2: type = converted %int.make_type_signed, %.loc12_21.1 [template = <error>]

toolchain/check/testdata/builtins/int/make_type_unsigned.carbon

@@ -325,17 +325,17 @@ var m: UInt(1000000000);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.26, %Convert.15 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value -1 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value -1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -381,21 +381,21 @@ var m: UInt(1000000000);
 // CHECK:STDOUT:   %UInt.ref: %UInt.type = name_ref UInt, imports.%import_ref.2 [template = constants.%UInt]
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_20.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc12_20.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_20.3: <bound method> = bound_method %.loc12_20.1, %.loc12_20.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_20.4: <specific function> = specific_function %.loc12_20.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc12_20: init %i32 = call %.loc12_20.4(%.loc12_20.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_20.5: %i32 = value_of_initializer %int.convert_checked.loc12_20 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_20.6: %i32 = converted %.loc12_20.1, %.loc12_20.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc12_20.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_19.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc12_19.2: <bound method> = bound_method %int.snegate, %.loc12_19.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_19.3: <specific function> = specific_function %.loc12_19.2, @Convert.4(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_19.4: %i32 = value_of_initializer %int.snegate [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_19.5: %i32 = converted %int.snegate, %.loc12_19.4 [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked.loc12_19: init Core.IntLiteral = call %.loc12_19.3(%.loc12_19.5) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc12_19 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_19.7: Core.IntLiteral = converted %int.snegate, %.loc12_19.6 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_20.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_20.3: <bound method> = bound_method %.loc12_20.1, %.loc12_20.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_20.4: <specific function> = specific_function %.loc12_20.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc12_20: init %i32 = call %.loc12_20.4(%.loc12_20.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_20.5: %i32 = value_of_initializer %int.convert_checked.loc12_20 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_20.6: %i32 = converted %.loc12_20.1, %.loc12_20.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc12_20.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc12_19.2: <bound method> = bound_method %int.snegate, %.loc12_19.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_19.3: <specific function> = specific_function %.loc12_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_19.4: %i32 = value_of_initializer %int.snegate [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_19.5: %i32 = converted %int.snegate, %.loc12_19.4 [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked.loc12_19: init Core.IntLiteral = call %.loc12_19.3(%.loc12_19.5) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc12_19 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_19.7: Core.IntLiteral = converted %int.snegate, %.loc12_19.6 [template = constants.%.34]
 // CHECK:STDOUT:   %int.make_type_unsigned: init type = call %UInt.ref(%.loc12_19.7) [template = <error>]
 // CHECK:STDOUT:   %.loc12_22.1: type = value_of_initializer %int.make_type_unsigned [template = <error>]
 // CHECK:STDOUT:   %.loc12_22.2: type = converted %int.make_type_unsigned, %.loc12_22.1 [template = <error>]

toolchain/check/testdata/builtins/int/neq.carbon

@@ -45,16 +45,16 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.29: bool = bool_literal false [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.34: bool = bool_literal true [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.33: bool = bool_literal false [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.38: bool = bool_literal true [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -170,21 +170,21 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %Neq.ref.loc8: %Neq.type = name_ref Neq, file.%Neq.decl [template = constants.%Neq]
 // CHECK:STDOUT:   %.loc8_21.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc8_24.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc8_21.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_21.3: <bound method> = bound_method %.loc8_21.1, %.loc8_21.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_21.4: <specific function> = specific_function %.loc8_21.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc8_21: init %i32 = call %.loc8_21.4(%.loc8_21.1) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_21.5: %i32 = value_of_initializer %int.convert_checked.loc8_21 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_21.6: %i32 = converted %.loc8_21.1, %.loc8_21.5 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_24.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_24.3: <bound method> = bound_method %.loc8_24.1, %.loc8_24.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_24.4: <specific function> = specific_function %.loc8_24.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc8_24: init %i32 = call %.loc8_24.4(%.loc8_24.1) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_24.5: %i32 = value_of_initializer %int.convert_checked.loc8_24 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc8_24.6: %i32 = converted %.loc8_24.1, %.loc8_24.5 [template = constants.%.28]
-// CHECK:STDOUT:   %int.neq.loc8: init bool = call %Neq.ref.loc8(%.loc8_21.6, %.loc8_24.6) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_14.1: bool = value_of_initializer %int.neq.loc8 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_14.2: bool = converted %int.neq.loc8, %.loc8_14.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_21.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_21.3: <bound method> = bound_method %.loc8_21.1, %.loc8_21.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_21.4: <specific function> = specific_function %.loc8_21.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc8_21: init %i32 = call %.loc8_21.4(%.loc8_21.1) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_21.5: %i32 = value_of_initializer %int.convert_checked.loc8_21 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_21.6: %i32 = converted %.loc8_21.1, %.loc8_21.5 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_24.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_24.3: <bound method> = bound_method %.loc8_24.1, %.loc8_24.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_24.4: <specific function> = specific_function %.loc8_24.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc8_24: init %i32 = call %.loc8_24.4(%.loc8_24.1) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_24.5: %i32 = value_of_initializer %int.convert_checked.loc8_24 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc8_24.6: %i32 = converted %.loc8_24.1, %.loc8_24.5 [template = constants.%.32]
+// CHECK:STDOUT:   %int.neq.loc8: init bool = call %Neq.ref.loc8(%.loc8_21.6, %.loc8_24.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_14.1: bool = value_of_initializer %int.neq.loc8 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_14.2: bool = converted %int.neq.loc8, %.loc8_14.1 [template = constants.%.33]
 // CHECK:STDOUT:   if %.loc8_14.2 br !if.expr.then.loc8 else br !if.expr.else.loc8
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc8:
@@ -200,22 +200,22 @@ fn RuntimeCall(a: i32, b: i32) -> bool {
 // CHECK:STDOUT:   %true_.ref: %True = name_ref true_, %true_
 // CHECK:STDOUT:   %Neq.ref.loc9: %Neq.type = name_ref Neq, file.%Neq.decl [template = constants.%Neq]
 // CHECK:STDOUT:   %.loc9_20.1: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc9_23.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_20.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_20.3: <bound method> = bound_method %.loc9_20.1, %.loc9_20.2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_20.4: <specific function> = specific_function %.loc9_20.3, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc9_20: init %i32 = call %.loc9_20.4(%.loc9_20.1) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_20.5: %i32 = value_of_initializer %int.convert_checked.loc9_20 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_20.6: %i32 = converted %.loc9_20.1, %.loc9_20.5 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_23.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_23.3: <bound method> = bound_method %.loc9_23.1, %.loc9_23.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_23.4: <specific function> = specific_function %.loc9_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc9_23: init %i32 = call %.loc9_23.4(%.loc9_23.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_23.5: %i32 = value_of_initializer %int.convert_checked.loc9_23 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_23.6: %i32 = converted %.loc9_23.1, %.loc9_23.5 [template = constants.%.33]
-// CHECK:STDOUT:   %int.neq.loc9: init bool = call %Neq.ref.loc9(%.loc9_20.6, %.loc9_23.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc9_13.1: bool = value_of_initializer %int.neq.loc9 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc9_13.2: bool = converted %int.neq.loc9, %.loc9_13.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_23.1: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_20.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_20.3: <bound method> = bound_method %.loc9_20.1, %.loc9_20.2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_20.4: <specific function> = specific_function %.loc9_20.3, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc9_20: init %i32 = call %.loc9_20.4(%.loc9_20.1) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_20.5: %i32 = value_of_initializer %int.convert_checked.loc9_20 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_20.6: %i32 = converted %.loc9_20.1, %.loc9_20.5 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_23.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_23.3: <bound method> = bound_method %.loc9_23.1, %.loc9_23.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_23.4: <specific function> = specific_function %.loc9_23.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc9_23: init %i32 = call %.loc9_23.4(%.loc9_23.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_23.5: %i32 = value_of_initializer %int.convert_checked.loc9_23 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_23.6: %i32 = converted %.loc9_23.1, %.loc9_23.5 [template = constants.%.37]
+// CHECK:STDOUT:   %int.neq.loc9: init bool = call %Neq.ref.loc9(%.loc9_20.6, %.loc9_23.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc9_13.1: bool = value_of_initializer %int.neq.loc9 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc9_13.2: bool = converted %int.neq.loc9, %.loc9_13.1 [template = constants.%.38]
 // CHECK:STDOUT:   if %.loc9_13.2 br !if.expr.then.loc9 else br !if.expr.else.loc9
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.then.loc9:

toolchain/check/testdata/builtins/int/or.carbon

@@ -34,22 +34,22 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 12 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 10 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 14 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 12 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 10 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 14 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 14 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 14 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -104,39 +104,39 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:   %Or.ref: %Or.type = name_ref Or, %Or.decl [template = constants.%Or]
 // CHECK:STDOUT:   %.loc4_19.1: Core.IntLiteral = int_value 12 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 10 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_19.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_19.3: <bound method> = bound_method %.loc4_19.1, %.loc4_19.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_19.4: <specific function> = specific_function %.loc4_19.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init %i32 = call %.loc4_19.4(%.loc4_19.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_19.6: %i32 = converted %.loc4_19.1, %.loc4_19.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.or: init %i32 = call %Or.ref(%.loc4_19.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_19.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_19.3: <bound method> = bound_method %.loc4_19.1, %.loc4_19.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_19.4: <specific function> = specific_function %.loc4_19.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init %i32 = call %.loc4_19.4(%.loc4_19.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_19.6: %i32 = converted %.loc4_19.1, %.loc4_19.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.or: init %i32 = call %Or.ref(%.loc4_19.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_18.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_18.2: <bound method> = bound_method %int.or, %.loc4_18.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_18.3: <specific function> = specific_function %.loc4_18.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_18.4: %i32 = value_of_initializer %int.or [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_18.5: %i32 = converted %int.or, %.loc4_18.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_18: init Core.IntLiteral = call %.loc4_18.3(%.loc4_18.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_18.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_18 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_18.7: Core.IntLiteral = converted %int.or, %.loc4_18.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_26: type = array_type %.loc4_18.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_18.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_18.2: <bound method> = bound_method %int.or, %.loc4_18.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_18.3: <specific function> = specific_function %.loc4_18.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_18.4: %i32 = value_of_initializer %int.or [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_18.5: %i32 = converted %int.or, %.loc4_18.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_18: init Core.IntLiteral = call %.loc4_18.3(%.loc4_18.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_18.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_18 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_18.7: Core.IntLiteral = converted %int.or, %.loc4_18.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_26: type = array_type %.loc4_18.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 14 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 14 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_20: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_21: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_20: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_21: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -181,9 +181,9 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/builtins/int/right_shift.carbon

@@ -79,22 +79,22 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 22 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 22 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 5 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 5 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 5 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -149,39 +149,39 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %RightShift.ref: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift]
 // CHECK:STDOUT:   %.loc4_27.1: Core.IntLiteral = int_value 22 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_31.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_27.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_27.3: <bound method> = bound_method %.loc4_27.1, %.loc4_27.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_27.4: <specific function> = specific_function %.loc4_27.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_27: init %i32 = call %.loc4_27.4(%.loc4_27.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_27.5: %i32 = value_of_initializer %int.convert_checked.loc4_27 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_27.6: %i32 = converted %.loc4_27.1, %.loc4_27.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_31.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_31.3: <bound method> = bound_method %.loc4_31.1, %.loc4_31.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_31.4: <specific function> = specific_function %.loc4_31.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_31: init %i32 = call %.loc4_31.4(%.loc4_31.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_31.5: %i32 = value_of_initializer %int.convert_checked.loc4_31 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_31.6: %i32 = converted %.loc4_31.1, %.loc4_31.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.right_shift: init %i32 = call %RightShift.ref(%.loc4_27.6, %.loc4_31.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_27.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_27.3: <bound method> = bound_method %.loc4_27.1, %.loc4_27.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_27.4: <specific function> = specific_function %.loc4_27.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_27: init %i32 = call %.loc4_27.4(%.loc4_27.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_27.5: %i32 = value_of_initializer %int.convert_checked.loc4_27 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_27.6: %i32 = converted %.loc4_27.1, %.loc4_27.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_31.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_31.3: <bound method> = bound_method %.loc4_31.1, %.loc4_31.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_31.4: <specific function> = specific_function %.loc4_31.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_31: init %i32 = call %.loc4_31.4(%.loc4_31.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_31.5: %i32 = value_of_initializer %int.convert_checked.loc4_31 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_31.6: %i32 = converted %.loc4_31.1, %.loc4_31.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.right_shift: init %i32 = call %RightShift.ref(%.loc4_27.6, %.loc4_31.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_26.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_26.2: <bound method> = bound_method %int.right_shift, %.loc4_26.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_26.3: <specific function> = specific_function %.loc4_26.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_26.4: %i32 = value_of_initializer %int.right_shift [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_26.5: %i32 = converted %int.right_shift, %.loc4_26.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_26: init Core.IntLiteral = call %.loc4_26.3(%.loc4_26.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_26.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_26 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_26.7: Core.IntLiteral = converted %int.right_shift, %.loc4_26.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_33: type = array_type %.loc4_26.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_26.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_26.2: <bound method> = bound_method %int.right_shift, %.loc4_26.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_26.3: <specific function> = specific_function %.loc4_26.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_26.4: %i32 = value_of_initializer %int.right_shift [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_26.5: %i32 = converted %int.right_shift, %.loc4_26.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_26: init Core.IntLiteral = call %.loc4_26.3(%.loc4_26.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_26.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_26 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_26.7: Core.IntLiteral = converted %int.right_shift, %.loc4_26.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_33: type = array_type %.loc4_26.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 5 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 5 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -226,9 +226,9 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -248,34 +248,34 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.25, %Convert.15 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.30: type = array_type %.2, %i32 [template]
-// CHECK:STDOUT:   %.31: type = ptr_type %.30 [template]
-// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 10 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.32, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 10 [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value -10 [template]
-// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.38: <bound method> = bound_method %.37, %Convert.14 [template]
-// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.40: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.41: %i32 = int_value -3 [template]
-// CHECK:STDOUT:   %.42: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.43: <bound method> = bound_method %.42, %Convert.15 [template]
-// CHECK:STDOUT:   %.44: <specific function> = specific_function %.43, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.45: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.46: type = array_type %.45, %i32 [template]
-// CHECK:STDOUT:   %.47: type = ptr_type %.46 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.29, %Convert.15 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.34: type = array_type %.2, %i32 [template]
+// CHECK:STDOUT:   %.35: type = ptr_type %.34 [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 10 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.36, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 10 [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value -10 [template]
+// CHECK:STDOUT:   %.41: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.42: <bound method> = bound_method %.41, %Convert.14 [template]
+// CHECK:STDOUT:   %.43: <specific function> = specific_function %.42, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.44: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.45: %i32 = int_value -3 [template]
+// CHECK:STDOUT:   %.46: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.47: <bound method> = bound_method %.46, %Convert.15 [template]
+// CHECK:STDOUT:   %.48: <specific function> = specific_function %.47, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.49: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.50: type = array_type %.49, %i32 [template]
+// CHECK:STDOUT:   %.51: type = ptr_type %.50 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -350,92 +350,92 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %RightShift.ref.loc10: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift]
 // CHECK:STDOUT:   %Negate.ref.loc10_35: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc10_42.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc10_42.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_42.3: <bound method> = bound_method %.loc10_42.1, %.loc10_42.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc10_42.4: <specific function> = specific_function %.loc10_42.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc10_42: init %i32 = call %.loc10_42.4(%.loc10_42.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_42.5: %i32 = value_of_initializer %int.convert_checked.loc10_42 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_42.6: %i32 = converted %.loc10_42.1, %.loc10_42.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc10_41: init %i32 = call %Negate.ref.loc10_35(%.loc10_42.6) [template = constants.%.26]
+// CHECK:STDOUT:   %.loc10_42.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_42.3: <bound method> = bound_method %.loc10_42.1, %.loc10_42.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc10_42.4: <specific function> = specific_function %.loc10_42.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc10_42: init %i32 = call %.loc10_42.4(%.loc10_42.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_42.5: %i32 = value_of_initializer %int.convert_checked.loc10_42 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_42.6: %i32 = converted %.loc10_42.1, %.loc10_42.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc10_41: init %i32 = call %Negate.ref.loc10_35(%.loc10_42.6) [template = constants.%.30]
 // CHECK:STDOUT:   %.loc10_46.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc10_41.1: %i32 = value_of_initializer %int.snegate.loc10_41 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_41.2: %i32 = converted %int.snegate.loc10_41, %.loc10_41.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_46.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_46.3: <bound method> = bound_method %.loc10_46.1, %.loc10_46.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc10_46.4: <specific function> = specific_function %.loc10_46.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc10_46: init %i32 = call %.loc10_46.4(%.loc10_46.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_46.5: %i32 = value_of_initializer %int.convert_checked.loc10_46 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_46.6: %i32 = converted %.loc10_46.1, %.loc10_46.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.right_shift.loc10: init %i32 = call %RightShift.ref.loc10(%.loc10_41.2, %.loc10_46.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_34.1: %i32 = value_of_initializer %int.right_shift.loc10 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_34.2: %i32 = converted %int.right_shift.loc10, %.loc10_34.1 [template = constants.%.26]
-// CHECK:STDOUT:   %int.snegate.loc10_23: init %i32 = call %Negate.ref.loc10_17(%.loc10_34.2) [template = constants.%.25]
+// CHECK:STDOUT:   %.loc10_41.1: %i32 = value_of_initializer %int.snegate.loc10_41 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_41.2: %i32 = converted %int.snegate.loc10_41, %.loc10_41.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_46.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_46.3: <bound method> = bound_method %.loc10_46.1, %.loc10_46.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc10_46.4: <specific function> = specific_function %.loc10_46.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc10_46: init %i32 = call %.loc10_46.4(%.loc10_46.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_46.5: %i32 = value_of_initializer %int.convert_checked.loc10_46 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_46.6: %i32 = converted %.loc10_46.1, %.loc10_46.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.right_shift.loc10: init %i32 = call %RightShift.ref.loc10(%.loc10_41.2, %.loc10_46.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_34.1: %i32 = value_of_initializer %int.right_shift.loc10 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_34.2: %i32 = converted %int.right_shift.loc10, %.loc10_34.1 [template = constants.%.30]
+// CHECK:STDOUT:   %int.snegate.loc10_23: init %i32 = call %Negate.ref.loc10_17(%.loc10_34.2) [template = constants.%.29]
 // CHECK:STDOUT:   %.loc10_12.2: type = value_of_initializer %int.make_type_signed.loc10 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc10_12.3: type = converted %int.make_type_signed.loc10, %.loc10_12.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc10_23.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc10_23.2: <bound method> = bound_method %int.snegate.loc10_23, %.loc10_23.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc10_23.3: <specific function> = specific_function %.loc10_23.2, @Convert.4(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_23.4: %i32 = value_of_initializer %int.snegate.loc10_23 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_23.5: %i32 = converted %int.snegate.loc10_23, %.loc10_23.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc10_23.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc10_23.2: <bound method> = bound_method %int.snegate.loc10_23, %.loc10_23.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc10_23.3: <specific function> = specific_function %.loc10_23.2, @Convert.4(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_23.4: %i32 = value_of_initializer %int.snegate.loc10_23 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_23.5: %i32 = converted %int.snegate.loc10_23, %.loc10_23.4 [template = constants.%.29]
 // CHECK:STDOUT:   %int.convert_checked.loc10_23: init Core.IntLiteral = call %.loc10_23.3(%.loc10_23.5) [template = constants.%.2]
 // CHECK:STDOUT:   %.loc10_23.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_23 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc10_23.7: Core.IntLiteral = converted %int.snegate.loc10_23, %.loc10_23.6 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc10_49: type = array_type %.loc10_23.7, %i32 [template = constants.%.30]
-// CHECK:STDOUT:   %arr1.var: ref %.30 = var arr1
-// CHECK:STDOUT:   %arr1: ref %.30 = bind_name arr1, %arr1.var
+// CHECK:STDOUT:   %.loc10_49: type = array_type %.loc10_23.7, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %arr1.var: ref %.34 = var arr1
+// CHECK:STDOUT:   %arr1: ref %.34 = bind_name arr1, %arr1.var
 // CHECK:STDOUT:   %.loc11_14.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc11: init type = call constants.%Int(%.loc11_14.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc11_19: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_14.2: type = value_of_initializer %int.make_type_signed.loc11 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc11_14.3: type = converted %int.make_type_signed.loc11, %.loc11_14.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc11_20: type = array_type %.loc11_19, %i32 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_21: type = ptr_type %.30 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_20: type = array_type %.loc11_19, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_21: type = ptr_type %.34 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc14_12.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc14: init type = call constants.%Int(%.loc14_12.1) [template = constants.%i32]
 // CHECK:STDOUT:   %Negate.ref.loc14_17: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %RightShift.ref.loc14: %RightShift.type = name_ref RightShift, %RightShift.decl [template = constants.%RightShift]
 // CHECK:STDOUT:   %Negate.ref.loc14_35: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc14_42.1: Core.IntLiteral = int_value 10 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc14_42.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_42.3: <bound method> = bound_method %.loc14_42.1, %.loc14_42.2 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc14_42.4: <specific function> = specific_function %.loc14_42.3, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc14_42: init %i32 = call %.loc14_42.4(%.loc14_42.1) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc14_42.5: %i32 = value_of_initializer %int.convert_checked.loc14_42 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc14_42.6: %i32 = converted %.loc14_42.1, %.loc14_42.5 [template = constants.%.35]
-// CHECK:STDOUT:   %int.snegate.loc14_41: init %i32 = call %Negate.ref.loc14_35(%.loc14_42.6) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc14_47.1: Core.IntLiteral = int_value 2 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc14_41.1: %i32 = value_of_initializer %int.snegate.loc14_41 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc14_41.2: %i32 = converted %int.snegate.loc14_41, %.loc14_41.1 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc14_47.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_47.3: <bound method> = bound_method %.loc14_47.1, %.loc14_47.2 [template = constants.%.38]
-// CHECK:STDOUT:   %.loc14_47.4: <specific function> = specific_function %.loc14_47.3, @Convert.2(constants.%.1) [template = constants.%.39]
-// CHECK:STDOUT:   %int.convert_checked.loc14_47: init %i32 = call %.loc14_47.4(%.loc14_47.1) [template = constants.%.40]
-// CHECK:STDOUT:   %.loc14_47.5: %i32 = value_of_initializer %int.convert_checked.loc14_47 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc14_47.6: %i32 = converted %.loc14_47.1, %.loc14_47.5 [template = constants.%.40]
-// CHECK:STDOUT:   %int.right_shift.loc14: init %i32 = call %RightShift.ref.loc14(%.loc14_41.2, %.loc14_47.6) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc14_34.1: %i32 = value_of_initializer %int.right_shift.loc14 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc14_34.2: %i32 = converted %int.right_shift.loc14, %.loc14_34.1 [template = constants.%.41]
-// CHECK:STDOUT:   %int.snegate.loc14_23: init %i32 = call %Negate.ref.loc14_17(%.loc14_34.2) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc14_42.1: Core.IntLiteral = int_value 10 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc14_42.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_42.3: <bound method> = bound_method %.loc14_42.1, %.loc14_42.2 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc14_42.4: <specific function> = specific_function %.loc14_42.3, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc14_42: init %i32 = call %.loc14_42.4(%.loc14_42.1) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc14_42.5: %i32 = value_of_initializer %int.convert_checked.loc14_42 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc14_42.6: %i32 = converted %.loc14_42.1, %.loc14_42.5 [template = constants.%.39]
+// CHECK:STDOUT:   %int.snegate.loc14_41: init %i32 = call %Negate.ref.loc14_35(%.loc14_42.6) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc14_47.1: Core.IntLiteral = int_value 2 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc14_41.1: %i32 = value_of_initializer %int.snegate.loc14_41 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc14_41.2: %i32 = converted %int.snegate.loc14_41, %.loc14_41.1 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc14_47.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_47.3: <bound method> = bound_method %.loc14_47.1, %.loc14_47.2 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc14_47.4: <specific function> = specific_function %.loc14_47.3, @Convert.2(constants.%.1) [template = constants.%.43]
+// CHECK:STDOUT:   %int.convert_checked.loc14_47: init %i32 = call %.loc14_47.4(%.loc14_47.1) [template = constants.%.44]
+// CHECK:STDOUT:   %.loc14_47.5: %i32 = value_of_initializer %int.convert_checked.loc14_47 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc14_47.6: %i32 = converted %.loc14_47.1, %.loc14_47.5 [template = constants.%.44]
+// CHECK:STDOUT:   %int.right_shift.loc14: init %i32 = call %RightShift.ref.loc14(%.loc14_41.2, %.loc14_47.6) [template = constants.%.45]
+// CHECK:STDOUT:   %.loc14_34.1: %i32 = value_of_initializer %int.right_shift.loc14 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc14_34.2: %i32 = converted %int.right_shift.loc14, %.loc14_34.1 [template = constants.%.45]
+// CHECK:STDOUT:   %int.snegate.loc14_23: init %i32 = call %Negate.ref.loc14_17(%.loc14_34.2) [template = constants.%.46]
 // CHECK:STDOUT:   %.loc14_12.2: type = value_of_initializer %int.make_type_signed.loc14 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc14_12.3: type = converted %int.make_type_signed.loc14, %.loc14_12.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc14_23.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc14_23.2: <bound method> = bound_method %int.snegate.loc14_23, %.loc14_23.1 [template = constants.%.43]
-// CHECK:STDOUT:   %.loc14_23.3: <specific function> = specific_function %.loc14_23.2, @Convert.4(constants.%.1) [template = constants.%.44]
-// CHECK:STDOUT:   %.loc14_23.4: %i32 = value_of_initializer %int.snegate.loc14_23 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc14_23.5: %i32 = converted %int.snegate.loc14_23, %.loc14_23.4 [template = constants.%.42]
-// CHECK:STDOUT:   %int.convert_checked.loc14_23: init Core.IntLiteral = call %.loc14_23.3(%.loc14_23.5) [template = constants.%.45]
-// CHECK:STDOUT:   %.loc14_23.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_23 [template = constants.%.45]
-// CHECK:STDOUT:   %.loc14_23.7: Core.IntLiteral = converted %int.snegate.loc14_23, %.loc14_23.6 [template = constants.%.45]
-// CHECK:STDOUT:   %.loc14_50: type = array_type %.loc14_23.7, %i32 [template = constants.%.46]
-// CHECK:STDOUT:   %arr2.var: ref %.46 = var arr2
-// CHECK:STDOUT:   %arr2: ref %.46 = bind_name arr2, %arr2.var
+// CHECK:STDOUT:   %.loc14_23.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc14_23.2: <bound method> = bound_method %int.snegate.loc14_23, %.loc14_23.1 [template = constants.%.47]
+// CHECK:STDOUT:   %.loc14_23.3: <specific function> = specific_function %.loc14_23.2, @Convert.4(constants.%.1) [template = constants.%.48]
+// CHECK:STDOUT:   %.loc14_23.4: %i32 = value_of_initializer %int.snegate.loc14_23 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc14_23.5: %i32 = converted %int.snegate.loc14_23, %.loc14_23.4 [template = constants.%.46]
+// CHECK:STDOUT:   %int.convert_checked.loc14_23: init Core.IntLiteral = call %.loc14_23.3(%.loc14_23.5) [template = constants.%.49]
+// CHECK:STDOUT:   %.loc14_23.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_23 [template = constants.%.49]
+// CHECK:STDOUT:   %.loc14_23.7: Core.IntLiteral = converted %int.snegate.loc14_23, %.loc14_23.6 [template = constants.%.49]
+// CHECK:STDOUT:   %.loc14_50: type = array_type %.loc14_23.7, %i32 [template = constants.%.50]
+// CHECK:STDOUT:   %arr2.var: ref %.50 = var arr2
+// CHECK:STDOUT:   %arr2: ref %.50 = bind_name arr2, %arr2.var
 // CHECK:STDOUT:   %.loc15_14.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc15: init type = call constants.%Int(%.loc15_14.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_19: Core.IntLiteral = int_value 3 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc15_19: Core.IntLiteral = int_value 3 [template = constants.%.49]
 // CHECK:STDOUT:   %.loc15_14.2: type = value_of_initializer %int.make_type_signed.loc15 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc15_14.3: type = converted %int.make_type_signed.loc15, %.loc15_14.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_20: type = array_type %.loc15_19, %i32 [template = constants.%.46]
-// CHECK:STDOUT:   %.loc15_21: type = ptr_type %.46 [template = constants.%.47]
+// CHECK:STDOUT:   %.loc15_20: type = array_type %.loc15_19, %i32 [template = constants.%.50]
+// CHECK:STDOUT:   %.loc15_21: type = ptr_type %.50 [template = constants.%.51]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @RightShift(%a.param_patt: %i32, %b.param_patt: %i32) -> %i32 = "int.right_shift";
@@ -444,12 +444,12 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr1.ref: ref %.30 = name_ref arr1, file.%arr1
-// CHECK:STDOUT:   %.loc11: %.31 = addr_of %arr1.ref
-// CHECK:STDOUT:   %arr1_p: %.31 = bind_name arr1_p, %.loc11
-// CHECK:STDOUT:   %arr2.ref: ref %.46 = name_ref arr2, file.%arr2
-// CHECK:STDOUT:   %.loc15: %.47 = addr_of %arr2.ref
-// CHECK:STDOUT:   %arr2_p: %.47 = bind_name arr2_p, %.loc15
+// CHECK:STDOUT:   %arr1.ref: ref %.34 = name_ref arr1, file.%arr1
+// CHECK:STDOUT:   %.loc11: %.35 = addr_of %arr1.ref
+// CHECK:STDOUT:   %arr1_p: %.35 = bind_name arr1_p, %.loc11
+// CHECK:STDOUT:   %arr2.ref: ref %.50 = name_ref arr2, file.%arr2
+// CHECK:STDOUT:   %.loc15: %.51 = addr_of %arr2.ref
+// CHECK:STDOUT:   %arr2_p: %.51 = bind_name arr2_p, %.loc15
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -469,22 +469,22 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 31 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.1, %Convert.14 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
 // CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 32 [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 33 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 31 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.1, %Convert.14 [template]
 // CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 33 [template]
-// CHECK:STDOUT:   %.38: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 32 [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 33 [template]
+// CHECK:STDOUT:   %.39: <bound method> = bound_method %.38, %Convert.14 [template]
+// CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 33 [template]
+// CHECK:STDOUT:   %.42: %i32 = int_value -1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -580,56 +580,56 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %RightShift.ref.loc8: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift]
 // CHECK:STDOUT:   %.loc8_30.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc8_33.1: Core.IntLiteral = int_value 31 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc8_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_30.3: <bound method> = bound_method %.loc8_30.1, %.loc8_30.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc8_30.4: <specific function> = specific_function %.loc8_30.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc8_30: init %i32 = call %.loc8_30.4(%.loc8_30.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_30.5: %i32 = value_of_initializer %int.convert_checked.loc8_30 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_30.6: %i32 = converted %.loc8_30.1, %.loc8_30.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_33.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_33.3: <bound method> = bound_method %.loc8_33.1, %.loc8_33.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc8_33.4: <specific function> = specific_function %.loc8_33.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc8_33: init %i32 = call %.loc8_33.4(%.loc8_33.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_33.5: %i32 = value_of_initializer %int.convert_checked.loc8_33 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_33.6: %i32 = converted %.loc8_33.1, %.loc8_33.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.right_shift.loc8: init %i32 = call %RightShift.ref.loc8(%.loc8_30.6, %.loc8_33.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_36.1: %i32 = value_of_initializer %int.right_shift.loc8 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_36.2: %i32 = converted %int.right_shift.loc8, %.loc8_36.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_30.3: <bound method> = bound_method %.loc8_30.1, %.loc8_30.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc8_30.4: <specific function> = specific_function %.loc8_30.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc8_30: init %i32 = call %.loc8_30.4(%.loc8_30.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_30.5: %i32 = value_of_initializer %int.convert_checked.loc8_30 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_30.6: %i32 = converted %.loc8_30.1, %.loc8_30.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_33.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_33.3: <bound method> = bound_method %.loc8_33.1, %.loc8_33.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc8_33.4: <specific function> = specific_function %.loc8_33.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc8_33: init %i32 = call %.loc8_33.4(%.loc8_33.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_33.5: %i32 = value_of_initializer %int.convert_checked.loc8_33 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_33.6: %i32 = converted %.loc8_33.1, %.loc8_33.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.right_shift.loc8: init %i32 = call %RightShift.ref.loc8(%.loc8_30.6, %.loc8_33.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_36.1: %i32 = value_of_initializer %int.right_shift.loc8 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_36.2: %i32 = converted %int.right_shift.loc8, %.loc8_36.1 [template = constants.%.34]
 // CHECK:STDOUT:   %size_1: %i32 = bind_name size_1, %.loc8_36.2
 // CHECK:STDOUT:   %RightShift.ref.loc13: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift]
 // CHECK:STDOUT:   %.loc13_30.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc13_33.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
-// CHECK:STDOUT:   %.loc13_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_30.3: <bound method> = bound_method %.loc13_30.1, %.loc13_30.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc13_30.4: <specific function> = specific_function %.loc13_30.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc13_30: init %i32 = call %.loc13_30.4(%.loc13_30.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_30.5: %i32 = value_of_initializer %int.convert_checked.loc13_30 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_30.6: %i32 = converted %.loc13_30.1, %.loc13_30.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_33.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_33.3: <bound method> = bound_method %.loc13_33.1, %.loc13_33.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc13_33.4: <specific function> = specific_function %.loc13_33.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc13_33: init %i32 = call %.loc13_33.4(%.loc13_33.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_33.5: %i32 = value_of_initializer %int.convert_checked.loc13_33 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_33.6: %i32 = converted %.loc13_33.1, %.loc13_33.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_30.3: <bound method> = bound_method %.loc13_30.1, %.loc13_30.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_30.4: <specific function> = specific_function %.loc13_30.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc13_30: init %i32 = call %.loc13_30.4(%.loc13_30.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_30.5: %i32 = value_of_initializer %int.convert_checked.loc13_30 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_30.6: %i32 = converted %.loc13_30.1, %.loc13_30.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_33.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_33.3: <bound method> = bound_method %.loc13_33.1, %.loc13_33.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_33.4: <specific function> = specific_function %.loc13_33.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc13_33: init %i32 = call %.loc13_33.4(%.loc13_33.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_33.5: %i32 = value_of_initializer %int.convert_checked.loc13_33 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_33.6: %i32 = converted %.loc13_33.1, %.loc13_33.5 [template = constants.%.37]
 // CHECK:STDOUT:   %int.right_shift.loc13: init %i32 = call %RightShift.ref.loc13(%.loc13_30.6, %.loc13_33.6) [template = <error>]
 // CHECK:STDOUT:   %.loc13_36.1: %i32 = value_of_initializer %int.right_shift.loc13 [template = <error>]
 // CHECK:STDOUT:   %.loc13_36.2: %i32 = converted %int.right_shift.loc13, %.loc13_36.1 [template = <error>]
 // CHECK:STDOUT:   %size_2: %i32 = bind_name size_2, %.loc13_36.2
 // CHECK:STDOUT:   %RightShift.ref.loc18: %RightShift.type = name_ref RightShift, file.%RightShift.decl [template = constants.%RightShift]
 // CHECK:STDOUT:   %.loc18_30.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc18_33.1: Core.IntLiteral = int_value 33 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc18_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_30.3: <bound method> = bound_method %.loc18_30.1, %.loc18_30.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc18_30.4: <specific function> = specific_function %.loc18_30.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc18_30: init %i32 = call %.loc18_30.4(%.loc18_30.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc18_30.5: %i32 = value_of_initializer %int.convert_checked.loc18_30 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc18_30.6: %i32 = converted %.loc18_30.1, %.loc18_30.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc18_33.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_33.3: <bound method> = bound_method %.loc18_33.1, %.loc18_33.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc18_33.4: <specific function> = specific_function %.loc18_33.3, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc18_33: init %i32 = call %.loc18_33.4(%.loc18_33.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc18_33.5: %i32 = value_of_initializer %int.convert_checked.loc18_33 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc18_33.6: %i32 = converted %.loc18_33.1, %.loc18_33.5 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc18_33.1: Core.IntLiteral = int_value 33 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc18_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_30.3: <bound method> = bound_method %.loc18_30.1, %.loc18_30.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc18_30.4: <specific function> = specific_function %.loc18_30.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc18_30: init %i32 = call %.loc18_30.4(%.loc18_30.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_30.5: %i32 = value_of_initializer %int.convert_checked.loc18_30 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_30.6: %i32 = converted %.loc18_30.1, %.loc18_30.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_33.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_33.3: <bound method> = bound_method %.loc18_33.1, %.loc18_33.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc18_33.4: <specific function> = specific_function %.loc18_33.3, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc18_33: init %i32 = call %.loc18_33.4(%.loc18_33.1) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc18_33.5: %i32 = value_of_initializer %int.convert_checked.loc18_33 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc18_33.6: %i32 = converted %.loc18_33.1, %.loc18_33.5 [template = constants.%.41]
 // CHECK:STDOUT:   %int.right_shift.loc18: init %i32 = call %RightShift.ref.loc18(%.loc18_30.6, %.loc18_33.6) [template = <error>]
 // CHECK:STDOUT:   %.loc18_36.1: %i32 = value_of_initializer %int.right_shift.loc18 [template = <error>]
 // CHECK:STDOUT:   %.loc18_36.2: %i32 = converted %int.right_shift.loc18, %.loc18_36.1 [template = <error>]
@@ -638,21 +638,21 @@ let negative: i32 = RightShift(1, Negate(1));
 // CHECK:STDOUT:   %.loc24_32.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc24_42.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc24_42.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc24_42.3: <bound method> = bound_method %.loc24_42.1, %.loc24_42.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc24_42.4: <specific function> = specific_function %.loc24_42.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc24_42: init %i32 = call %.loc24_42.4(%.loc24_42.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc24_42.5: %i32 = value_of_initializer %int.convert_checked.loc24_42 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc24_42.6: %i32 = converted %.loc24_42.1, %.loc24_42.5 [template = constants.%.26]
-// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc24_42.6) [template = constants.%.38]
-// CHECK:STDOUT:   %.loc24_32.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc24_32.3: <bound method> = bound_method %.loc24_32.1, %.loc24_32.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc24_32.4: <specific function> = specific_function %.loc24_32.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc24_32: init %i32 = call %.loc24_32.4(%.loc24_32.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc24_32.5: %i32 = value_of_initializer %int.convert_checked.loc24_32 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc24_32.6: %i32 = converted %.loc24_32.1, %.loc24_32.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc24_41.1: %i32 = value_of_initializer %int.snegate [template = constants.%.38]
-// CHECK:STDOUT:   %.loc24_41.2: %i32 = converted %int.snegate, %.loc24_41.1 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc24_42.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc24_42.3: <bound method> = bound_method %.loc24_42.1, %.loc24_42.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc24_42.4: <specific function> = specific_function %.loc24_42.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc24_42: init %i32 = call %.loc24_42.4(%.loc24_42.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc24_42.5: %i32 = value_of_initializer %int.convert_checked.loc24_42 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc24_42.6: %i32 = converted %.loc24_42.1, %.loc24_42.5 [template = constants.%.30]
+// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc24_42.6) [template = constants.%.42]
+// CHECK:STDOUT:   %.loc24_32.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc24_32.3: <bound method> = bound_method %.loc24_32.1, %.loc24_32.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc24_32.4: <specific function> = specific_function %.loc24_32.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc24_32: init %i32 = call %.loc24_32.4(%.loc24_32.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc24_32.5: %i32 = value_of_initializer %int.convert_checked.loc24_32 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc24_32.6: %i32 = converted %.loc24_32.1, %.loc24_32.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc24_41.1: %i32 = value_of_initializer %int.snegate [template = constants.%.42]
+// CHECK:STDOUT:   %.loc24_41.2: %i32 = converted %int.snegate, %.loc24_41.1 [template = constants.%.42]
 // CHECK:STDOUT:   %int.right_shift.loc24: init %i32 = call %RightShift.ref.loc24(%.loc24_32.6, %.loc24_41.2) [template = <error>]
 // CHECK:STDOUT:   %.loc24_45.1: %i32 = value_of_initializer %int.right_shift.loc24 [template = <error>]
 // CHECK:STDOUT:   %.loc24_45.2: %i32 = converted %int.right_shift.loc24, %.loc24_45.1 [template = <error>]

toolchain/check/testdata/builtins/int/sadd.carbon

@@ -104,22 +104,22 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 3 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -174,39 +174,39 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Add.ref: %Add.type = name_ref Add, %Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.sadd: init %i32 = call %Add.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.sadd: init %i32 = call %Add.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.sadd, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.sadd [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.sadd, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.sadd, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.sadd, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.sadd [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.sadd, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.sadd, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 3 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 3 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -251,9 +251,9 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -278,18 +278,18 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.26, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 3 [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template]
 // CHECK:STDOUT:   %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template]
@@ -435,12 +435,12 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc25: init type = call constants.%Int(%.loc25_15.1) [template = constants.%i32]
 // CHECK:STDOUT:   %TooFew.ref: %TooFew.type = name_ref TooFew, %TooFew.decl [template = constants.%TooFew]
 // CHECK:STDOUT:   %.loc25_27.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc25_27.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc25_27.3: <bound method> = bound_method %.loc25_27.1, %.loc25_27.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc25_27.4: <specific function> = specific_function %.loc25_27.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc25: init %i32 = call %.loc25_27.4(%.loc25_27.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc25_27.5: %i32 = value_of_initializer %int.convert_checked.loc25 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc25_27.6: %i32 = converted %.loc25_27.1, %.loc25_27.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc25_27.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc25_27.3: <bound method> = bound_method %.loc25_27.1, %.loc25_27.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc25_27.4: <specific function> = specific_function %.loc25_27.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc25: init %i32 = call %.loc25_27.4(%.loc25_27.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc25_27.5: %i32 = value_of_initializer %int.convert_checked.loc25 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc25_27.6: %i32 = converted %.loc25_27.1, %.loc25_27.5 [template = constants.%.29]
 // CHECK:STDOUT:   %TooFew.call: init %i32 = call %TooFew.ref(%.loc25_27.6)
 // CHECK:STDOUT:   %.loc25_15.2: type = value_of_initializer %int.make_type_signed.loc25 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc25_15.3: type = converted %int.make_type_signed.loc25, %.loc25_15.2 [template = constants.%i32]
@@ -450,26 +450,26 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc30: init type = call constants.%Int(%.loc30_16.1) [template = constants.%i32]
 // CHECK:STDOUT:   %TooMany.ref: %TooMany.type = name_ref TooMany, %TooMany.decl [template = constants.%TooMany]
 // CHECK:STDOUT:   %.loc30_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc30_32.1: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_35.1: Core.IntLiteral = int_value 3 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc30_35.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_35.3: <bound method> = bound_method %.loc30_35.1, %.loc30_35.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc30_35.4: <specific function> = specific_function %.loc30_35.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc30_35: init %i32 = call %.loc30_35.4(%.loc30_35.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc30_35.5: %i32 = value_of_initializer %int.convert_checked.loc30_35 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc30_35.6: %i32 = converted %.loc30_35.1, %.loc30_35.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc30_32.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_35.1: Core.IntLiteral = int_value 3 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc30_35.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_35.3: <bound method> = bound_method %.loc30_35.1, %.loc30_35.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc30_35.4: <specific function> = specific_function %.loc30_35.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc30_35: init %i32 = call %.loc30_35.4(%.loc30_35.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc30_35.5: %i32 = value_of_initializer %int.convert_checked.loc30_35 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc30_35.6: %i32 = converted %.loc30_35.1, %.loc30_35.5 [template = constants.%.37]
 // CHECK:STDOUT:   %TooMany.call: init %i32 = call %TooMany.ref(%.loc30_29.6, %.loc30_32.6, %.loc30_35.6)
 // CHECK:STDOUT:   %.loc30_16.2: type = value_of_initializer %int.make_type_signed.loc30 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc30_16.3: type = converted %int.make_type_signed.loc30, %.loc30_16.2 [template = constants.%i32]
@@ -479,19 +479,19 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc35: init type = call constants.%Int(%.loc35_23.1) [template = constants.%i32]
 // CHECK:STDOUT:   %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, %BadReturnType.decl [template = constants.%BadReturnType]
 // CHECK:STDOUT:   %.loc35_42.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc35_45.1: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc35_42: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35_42 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc35_45.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_45.3: <bound method> = bound_method %.loc35_45.1, %.loc35_45.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc35_45.4: <specific function> = specific_function %.loc35_45.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc35_45: init %i32 = call %.loc35_45.4(%.loc35_45.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc35_45.5: %i32 = value_of_initializer %int.convert_checked.loc35_45 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc35_45.6: %i32 = converted %.loc35_45.1, %.loc35_45.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_45.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc35_42: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35_42 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc35_45.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_45.3: <bound method> = bound_method %.loc35_45.1, %.loc35_45.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc35_45.4: <specific function> = specific_function %.loc35_45.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc35_45: init %i32 = call %.loc35_45.4(%.loc35_45.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc35_45.5: %i32 = value_of_initializer %int.convert_checked.loc35_45 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc35_45.6: %i32 = converted %.loc35_45.1, %.loc35_45.5 [template = constants.%.34]
 // CHECK:STDOUT:   %BadReturnType.call: init bool = call %BadReturnType.ref(%.loc35_42.6, %.loc35_45.6)
 // CHECK:STDOUT:   %.loc35_23.2: type = value_of_initializer %int.make_type_signed.loc35 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc35_23.3: type = converted %int.make_type_signed.loc35, %.loc35_23.2 [template = constants.%i32]
@@ -501,8 +501,8 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc44: init type = call constants.%Int(%.loc44_16.1) [template = constants.%i32]
 // CHECK:STDOUT:   %JustRight.ref: %JustRight.type = name_ref JustRight, %JustRight.decl [template = constants.%JustRight]
 // CHECK:STDOUT:   %.loc44_31: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc44_34: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc44_37: Core.IntLiteral = int_value 3 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc44_34: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc44_37: Core.IntLiteral = int_value 3 [template = constants.%.31]
 // CHECK:STDOUT:   %.loc44_16.2: type = value_of_initializer %int.make_type_signed.loc44 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc44_16.3: type = converted %int.make_type_signed.loc44, %.loc44_16.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc44_39: type = array_type <error>, %i32 [template = <error>]
@@ -645,18 +645,18 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
 // CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -720,40 +720,40 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Add.ref.loc6: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc6_18.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_30.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_30.3: <bound method> = bound_method %.loc6_30.1, %.loc6_30.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc6_30.4: <specific function> = specific_function %.loc6_30.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc6_30: init %i32 = call %.loc6_30.4(%.loc6_30.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_30.5: %i32 = value_of_initializer %int.convert_checked.loc6_30 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_30.6: %i32 = converted %.loc6_30.1, %.loc6_30.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.sadd.loc6: init %i32 = call %Add.ref.loc6(%.loc6_18.6, %.loc6_30.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_32.1: %i32 = value_of_initializer %int.sadd.loc6 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_32.2: %i32 = converted %int.sadd.loc6, %.loc6_32.1 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_30.3: <bound method> = bound_method %.loc6_30.1, %.loc6_30.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc6_30.4: <specific function> = specific_function %.loc6_30.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc6_30: init %i32 = call %.loc6_30.4(%.loc6_30.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_30.5: %i32 = value_of_initializer %int.convert_checked.loc6_30 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_30.6: %i32 = converted %.loc6_30.1, %.loc6_30.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.sadd.loc6: init %i32 = call %Add.ref.loc6(%.loc6_18.6, %.loc6_30.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_32.1: %i32 = value_of_initializer %int.sadd.loc6 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_32.2: %i32 = converted %int.sadd.loc6, %.loc6_32.1 [template = constants.%.30]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc6_32.2
 // CHECK:STDOUT:   %Add.ref.loc10: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc10_18.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc10_30.1: Core.IntLiteral = int_value 1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_30.3: <bound method> = bound_method %.loc10_30.1, %.loc10_30.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc10_30.4: <specific function> = specific_function %.loc10_30.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc10_30: init %i32 = call %.loc10_30.4(%.loc10_30.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc10_30.5: %i32 = value_of_initializer %int.convert_checked.loc10_30 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc10_30.6: %i32 = converted %.loc10_30.1, %.loc10_30.5 [template = constants.%.33]
-// CHECK:STDOUT:   %int.sadd.loc10: init %i32 = call %Add.ref.loc10(%.loc10_18.6, %.loc10_30.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_32.1: %i32 = value_of_initializer %int.sadd.loc10 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_32.2: %i32 = converted %int.sadd.loc10, %.loc10_32.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc10_30.1: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_30.3: <bound method> = bound_method %.loc10_30.1, %.loc10_30.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc10_30.4: <specific function> = specific_function %.loc10_30.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc10_30: init %i32 = call %.loc10_30.4(%.loc10_30.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_30.5: %i32 = value_of_initializer %int.convert_checked.loc10_30 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_30.6: %i32 = converted %.loc10_30.1, %.loc10_30.5 [template = constants.%.37]
+// CHECK:STDOUT:   %int.sadd.loc10: init %i32 = call %Add.ref.loc10(%.loc10_18.6, %.loc10_30.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_32.1: %i32 = value_of_initializer %int.sadd.loc10 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_32.2: %i32 = converted %int.sadd.loc10, %.loc10_32.1 [template = constants.%.38]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc10_32.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/sdiv.carbon

@@ -72,22 +72,22 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -142,39 +142,39 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref: %Div.type = name_ref Div, %Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.sdiv: init %i32 = call %Div.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.sdiv: init %i32 = call %Div.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.sdiv, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.sdiv [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.sdiv, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.sdiv, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.sdiv, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.sdiv [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.sdiv, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.sdiv, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -219,9 +219,9 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -242,17 +242,17 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value -1 [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -373,101 +373,101 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref.loc9: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc9_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.26]
+// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.30]
 // CHECK:STDOUT:   %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.snegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.snegate.loc9_24 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.snegate.loc9_24, %.loc9_24.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.snegate.loc9_45 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.snegate.loc9_45, %.loc9_45.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.sdiv.loc9: init %i32 = call %Div.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.sdiv.loc9 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.sdiv.loc9, %.loc9_49.1 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.snegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.snegate.loc9_24 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.snegate.loc9_24, %.loc9_24.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.snegate.loc9_45 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.snegate.loc9_45, %.loc9_45.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.sdiv.loc9: init %i32 = call %Div.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.sdiv.loc9 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.sdiv.loc9, %.loc9_49.1 [template = constants.%.29]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc9_49.2
 // CHECK:STDOUT:   %Div.ref.loc12: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.snegate.loc12, %.loc12_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.ssub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.ssub.loc12 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.ssub.loc12, %.loc12_21.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.sdiv.loc12: init %i32 = call %Div.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.sdiv.loc12 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.sdiv.loc12, %.loc12_49.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.snegate.loc12, %.loc12_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.ssub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.ssub.loc12 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.ssub.loc12, %.loc12_21.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.sdiv.loc12: init %i32 = call %Div.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.sdiv.loc12 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.sdiv.loc12, %.loc12_49.1 [template = constants.%.36]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc12_49.2
 // CHECK:STDOUT:   %Div.ref.loc19: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %Sub.ref.loc19: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc19_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc19_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc19_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc19_29.3: <bound method> = bound_method %.loc19_29.1, %.loc19_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc19_29.4: <specific function> = specific_function %.loc19_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc19_29: init %i32 = call %.loc19_29.4(%.loc19_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc19_29.5: %i32 = value_of_initializer %int.convert_checked.loc19_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc19_29.6: %i32 = converted %.loc19_29.1, %.loc19_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc19_28: init %i32 = call %Negate.ref.loc19_22(%.loc19_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc19_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc19_28.1: %i32 = value_of_initializer %int.snegate.loc19_28 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc19_28.2: %i32 = converted %int.snegate.loc19_28, %.loc19_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc19_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc19_43.3: <bound method> = bound_method %.loc19_43.1, %.loc19_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc19_43.4: <specific function> = specific_function %.loc19_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc19_43: init %i32 = call %.loc19_43.4(%.loc19_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_43.5: %i32 = value_of_initializer %int.convert_checked.loc19_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_43.6: %i32 = converted %.loc19_43.1, %.loc19_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.ssub.loc19: init %i32 = call %Sub.ref.loc19(%.loc19_28.2, %.loc19_43.6) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc19_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc19_29.3: <bound method> = bound_method %.loc19_29.1, %.loc19_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc19_29.4: <specific function> = specific_function %.loc19_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc19_29: init %i32 = call %.loc19_29.4(%.loc19_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc19_29.5: %i32 = value_of_initializer %int.convert_checked.loc19_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc19_29.6: %i32 = converted %.loc19_29.1, %.loc19_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc19_28: init %i32 = call %Negate.ref.loc19_22(%.loc19_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc19_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc19_28.1: %i32 = value_of_initializer %int.snegate.loc19_28 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc19_28.2: %i32 = converted %int.snegate.loc19_28, %.loc19_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc19_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc19_43.3: <bound method> = bound_method %.loc19_43.1, %.loc19_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc19_43.4: <specific function> = specific_function %.loc19_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc19_43: init %i32 = call %.loc19_43.4(%.loc19_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_43.5: %i32 = value_of_initializer %int.convert_checked.loc19_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_43.6: %i32 = converted %.loc19_43.1, %.loc19_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.ssub.loc19: init %i32 = call %Sub.ref.loc19(%.loc19_28.2, %.loc19_43.6) [template = constants.%.36]
 // CHECK:STDOUT:   %Negate.ref.loc19_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc19_54.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc19_54.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc19_54.3: <bound method> = bound_method %.loc19_54.1, %.loc19_54.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc19_54.4: <specific function> = specific_function %.loc19_54.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc19_54: init %i32 = call %.loc19_54.4(%.loc19_54.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_54.5: %i32 = value_of_initializer %int.convert_checked.loc19_54 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_54.6: %i32 = converted %.loc19_54.1, %.loc19_54.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.snegate.loc19_53: init %i32 = call %Negate.ref.loc19_47(%.loc19_54.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc19_21.1: %i32 = value_of_initializer %int.ssub.loc19 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc19_21.2: %i32 = converted %int.ssub.loc19, %.loc19_21.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc19_53.1: %i32 = value_of_initializer %int.snegate.loc19_53 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc19_53.2: %i32 = converted %int.snegate.loc19_53, %.loc19_53.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.sdiv.loc19: init %i32 = call %Div.ref.loc19(%.loc19_21.2, %.loc19_53.2) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc19_57.1: %i32 = value_of_initializer %int.sdiv.loc19 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc19_57.2: %i32 = converted %int.sdiv.loc19, %.loc19_57.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc19_54.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc19_54.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc19_54.3: <bound method> = bound_method %.loc19_54.1, %.loc19_54.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc19_54.4: <specific function> = specific_function %.loc19_54.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc19_54: init %i32 = call %.loc19_54.4(%.loc19_54.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_54.5: %i32 = value_of_initializer %int.convert_checked.loc19_54 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_54.6: %i32 = converted %.loc19_54.1, %.loc19_54.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.snegate.loc19_53: init %i32 = call %Negate.ref.loc19_47(%.loc19_54.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc19_21.1: %i32 = value_of_initializer %int.ssub.loc19 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc19_21.2: %i32 = converted %int.ssub.loc19, %.loc19_21.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc19_53.1: %i32 = value_of_initializer %int.snegate.loc19_53 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc19_53.2: %i32 = converted %int.snegate.loc19_53, %.loc19_53.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.sdiv.loc19: init %i32 = call %Div.ref.loc19(%.loc19_21.2, %.loc19_53.2) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc19_57.1: %i32 = value_of_initializer %int.sdiv.loc19 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc19_57.2: %i32 = converted %int.sdiv.loc19, %.loc19_57.1 [template = constants.%.36]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc19_57.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -486,13 +486,13 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -556,18 +556,18 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref.loc10: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %.loc10_18.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc10_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_21.3: <bound method> = bound_method %.loc10_21.1, %.loc10_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_21.4: <specific function> = specific_function %.loc10_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_21: init %i32 = call %.loc10_21.4(%.loc10_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_21.5: %i32 = value_of_initializer %int.convert_checked.loc10_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_21.6: %i32 = converted %.loc10_21.1, %.loc10_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_21.3: <bound method> = bound_method %.loc10_21.1, %.loc10_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_21.4: <specific function> = specific_function %.loc10_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_21: init %i32 = call %.loc10_21.4(%.loc10_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_21.5: %i32 = value_of_initializer %int.convert_checked.loc10_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_21.6: %i32 = converted %.loc10_21.1, %.loc10_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.sdiv.loc10: init %i32 = call %Div.ref.loc10(%.loc10_18.6, %.loc10_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc10_23.1: %i32 = value_of_initializer %int.sdiv.loc10 [template = <error>]
 // CHECK:STDOUT:   %.loc10_23.2: %i32 = converted %int.sdiv.loc10, %.loc10_23.1 [template = <error>]
@@ -575,18 +575,18 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref.loc15: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %.loc15_18.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc15_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc15_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_18.3: <bound method> = bound_method %.loc15_18.1, %.loc15_18.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_18.4: <specific function> = specific_function %.loc15_18.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc15_18: init %i32 = call %.loc15_18.4(%.loc15_18.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_18.5: %i32 = value_of_initializer %int.convert_checked.loc15_18 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_18.6: %i32 = converted %.loc15_18.1, %.loc15_18.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_21.3: <bound method> = bound_method %.loc15_21.1, %.loc15_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_21.4: <specific function> = specific_function %.loc15_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc15_21: init %i32 = call %.loc15_21.4(%.loc15_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_21.5: %i32 = value_of_initializer %int.convert_checked.loc15_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_21.6: %i32 = converted %.loc15_21.1, %.loc15_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_18.3: <bound method> = bound_method %.loc15_18.1, %.loc15_18.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_18.4: <specific function> = specific_function %.loc15_18.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc15_18: init %i32 = call %.loc15_18.4(%.loc15_18.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_18.5: %i32 = value_of_initializer %int.convert_checked.loc15_18 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_18.6: %i32 = converted %.loc15_18.1, %.loc15_18.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_21.3: <bound method> = bound_method %.loc15_21.1, %.loc15_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_21.4: <specific function> = specific_function %.loc15_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc15_21: init %i32 = call %.loc15_21.4(%.loc15_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_21.5: %i32 = value_of_initializer %int.convert_checked.loc15_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_21.6: %i32 = converted %.loc15_21.1, %.loc15_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.sdiv.loc15: init %i32 = call %Div.ref.loc15(%.loc15_18.6, %.loc15_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc15_23.1: %i32 = value_of_initializer %int.sdiv.loc15 [template = <error>]
 // CHECK:STDOUT:   %.loc15_23.2: %i32 = converted %int.sdiv.loc15, %.loc15_23.1 [template = <error>]

toolchain/check/testdata/builtins/int/smod.carbon

@@ -75,22 +75,22 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -145,39 +145,39 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 5 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 3 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.smod: init %i32 = call %Mod.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.smod: init %i32 = call %Mod.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.smod, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.smod [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.smod, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.smod, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.smod, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.smod [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.smod, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.smod, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 2 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -222,9 +222,9 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -245,18 +245,18 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value -1 [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -377,101 +377,101 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref.loc9: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc9_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.26]
+// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.30]
 // CHECK:STDOUT:   %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.snegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.snegate.loc9_24 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.snegate.loc9_24, %.loc9_24.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.snegate.loc9_45 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.snegate.loc9_45, %.loc9_45.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.smod.loc9: init %i32 = call %Mod.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.smod.loc9 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.smod.loc9, %.loc9_49.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.snegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.snegate.loc9_24 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.snegate.loc9_24, %.loc9_24.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.snegate.loc9_45 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.snegate.loc9_45, %.loc9_45.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.smod.loc9: init %i32 = call %Mod.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.smod.loc9 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.smod.loc9, %.loc9_49.1 [template = constants.%.36]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc9_49.2
 // CHECK:STDOUT:   %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.snegate.loc12, %.loc12_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.ssub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.ssub.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.ssub.loc12, %.loc12_21.1 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.smod.loc12: init %i32 = call %Mod.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.smod.loc12 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.smod.loc12, %.loc12_49.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.snegate.loc12 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.snegate.loc12, %.loc12_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.ssub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.ssub.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.ssub.loc12, %.loc12_21.1 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.smod.loc12: init %i32 = call %Mod.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.smod.loc12 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.smod.loc12, %.loc12_49.1 [template = constants.%.36]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc12_49.2
 // CHECK:STDOUT:   %Mod.ref.loc20: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %Sub.ref.loc20: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc20_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc20_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc20_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc20_29.3: <bound method> = bound_method %.loc20_29.1, %.loc20_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc20_29.4: <specific function> = specific_function %.loc20_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc20_29: init %i32 = call %.loc20_29.4(%.loc20_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc20_29.5: %i32 = value_of_initializer %int.convert_checked.loc20_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc20_29.6: %i32 = converted %.loc20_29.1, %.loc20_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc20_28: init %i32 = call %Negate.ref.loc20_22(%.loc20_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc20_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc20_28.1: %i32 = value_of_initializer %int.snegate.loc20_28 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc20_28.2: %i32 = converted %int.snegate.loc20_28, %.loc20_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc20_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc20_43.3: <bound method> = bound_method %.loc20_43.1, %.loc20_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc20_43.4: <specific function> = specific_function %.loc20_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc20_43: init %i32 = call %.loc20_43.4(%.loc20_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc20_43.5: %i32 = value_of_initializer %int.convert_checked.loc20_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc20_43.6: %i32 = converted %.loc20_43.1, %.loc20_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.ssub.loc20: init %i32 = call %Sub.ref.loc20(%.loc20_28.2, %.loc20_43.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc20_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc20_29.3: <bound method> = bound_method %.loc20_29.1, %.loc20_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc20_29.4: <specific function> = specific_function %.loc20_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc20_29: init %i32 = call %.loc20_29.4(%.loc20_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc20_29.5: %i32 = value_of_initializer %int.convert_checked.loc20_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc20_29.6: %i32 = converted %.loc20_29.1, %.loc20_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc20_28: init %i32 = call %Negate.ref.loc20_22(%.loc20_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc20_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc20_28.1: %i32 = value_of_initializer %int.snegate.loc20_28 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc20_28.2: %i32 = converted %int.snegate.loc20_28, %.loc20_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc20_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc20_43.3: <bound method> = bound_method %.loc20_43.1, %.loc20_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc20_43.4: <specific function> = specific_function %.loc20_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc20_43: init %i32 = call %.loc20_43.4(%.loc20_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc20_43.5: %i32 = value_of_initializer %int.convert_checked.loc20_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc20_43.6: %i32 = converted %.loc20_43.1, %.loc20_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.ssub.loc20: init %i32 = call %Sub.ref.loc20(%.loc20_28.2, %.loc20_43.6) [template = constants.%.37]
 // CHECK:STDOUT:   %Negate.ref.loc20_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc20_54.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc20_54.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc20_54.3: <bound method> = bound_method %.loc20_54.1, %.loc20_54.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc20_54.4: <specific function> = specific_function %.loc20_54.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc20_54: init %i32 = call %.loc20_54.4(%.loc20_54.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc20_54.5: %i32 = value_of_initializer %int.convert_checked.loc20_54 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc20_54.6: %i32 = converted %.loc20_54.1, %.loc20_54.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.snegate.loc20_53: init %i32 = call %Negate.ref.loc20_47(%.loc20_54.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc20_21.1: %i32 = value_of_initializer %int.ssub.loc20 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc20_21.2: %i32 = converted %int.ssub.loc20, %.loc20_21.1 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc20_53.1: %i32 = value_of_initializer %int.snegate.loc20_53 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc20_53.2: %i32 = converted %int.snegate.loc20_53, %.loc20_53.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.smod.loc20: init %i32 = call %Mod.ref.loc20(%.loc20_21.2, %.loc20_53.2) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc20_57.1: %i32 = value_of_initializer %int.smod.loc20 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc20_57.2: %i32 = converted %int.smod.loc20, %.loc20_57.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc20_54.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc20_54.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc20_54.3: <bound method> = bound_method %.loc20_54.1, %.loc20_54.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc20_54.4: <specific function> = specific_function %.loc20_54.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc20_54: init %i32 = call %.loc20_54.4(%.loc20_54.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc20_54.5: %i32 = value_of_initializer %int.convert_checked.loc20_54 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc20_54.6: %i32 = converted %.loc20_54.1, %.loc20_54.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.snegate.loc20_53: init %i32 = call %Negate.ref.loc20_47(%.loc20_54.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc20_21.1: %i32 = value_of_initializer %int.ssub.loc20 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc20_21.2: %i32 = converted %int.ssub.loc20, %.loc20_21.1 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc20_53.1: %i32 = value_of_initializer %int.snegate.loc20_53 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc20_53.2: %i32 = converted %int.snegate.loc20_53, %.loc20_53.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.smod.loc20: init %i32 = call %Mod.ref.loc20(%.loc20_21.2, %.loc20_53.2) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc20_57.1: %i32 = value_of_initializer %int.smod.loc20 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc20_57.2: %i32 = converted %int.smod.loc20, %.loc20_57.1 [template = constants.%.36]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc20_57.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -490,13 +490,13 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -560,18 +560,18 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %.loc12_18.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc12_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc12_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_18.3: <bound method> = bound_method %.loc12_18.1, %.loc12_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc12_18.4: <specific function> = specific_function %.loc12_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc12_18: init %i32 = call %.loc12_18.4(%.loc12_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_18.5: %i32 = value_of_initializer %int.convert_checked.loc12_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_18.6: %i32 = converted %.loc12_18.1, %.loc12_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_21.3: <bound method> = bound_method %.loc12_21.1, %.loc12_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_21.4: <specific function> = specific_function %.loc12_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12_21: init %i32 = call %.loc12_21.4(%.loc12_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_21.5: %i32 = value_of_initializer %int.convert_checked.loc12_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_21.6: %i32 = converted %.loc12_21.1, %.loc12_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_18.3: <bound method> = bound_method %.loc12_18.1, %.loc12_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc12_18.4: <specific function> = specific_function %.loc12_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc12_18: init %i32 = call %.loc12_18.4(%.loc12_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_18.5: %i32 = value_of_initializer %int.convert_checked.loc12_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_18.6: %i32 = converted %.loc12_18.1, %.loc12_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_21.3: <bound method> = bound_method %.loc12_21.1, %.loc12_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_21.4: <specific function> = specific_function %.loc12_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12_21: init %i32 = call %.loc12_21.4(%.loc12_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_21.5: %i32 = value_of_initializer %int.convert_checked.loc12_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_21.6: %i32 = converted %.loc12_21.1, %.loc12_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.smod.loc12: init %i32 = call %Mod.ref.loc12(%.loc12_18.6, %.loc12_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc12_23.1: %i32 = value_of_initializer %int.smod.loc12 [template = <error>]
 // CHECK:STDOUT:   %.loc12_23.2: %i32 = converted %int.smod.loc12, %.loc12_23.1 [template = <error>]
@@ -579,18 +579,18 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref.loc17: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %.loc17_18.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc17_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc17_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_18.3: <bound method> = bound_method %.loc17_18.1, %.loc17_18.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc17_18.4: <specific function> = specific_function %.loc17_18.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc17_18: init %i32 = call %.loc17_18.4(%.loc17_18.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_18.5: %i32 = value_of_initializer %int.convert_checked.loc17_18 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_18.6: %i32 = converted %.loc17_18.1, %.loc17_18.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_21.3: <bound method> = bound_method %.loc17_21.1, %.loc17_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc17_21.4: <specific function> = specific_function %.loc17_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc17_21: init %i32 = call %.loc17_21.4(%.loc17_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_21.5: %i32 = value_of_initializer %int.convert_checked.loc17_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_21.6: %i32 = converted %.loc17_21.1, %.loc17_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc17_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_18.3: <bound method> = bound_method %.loc17_18.1, %.loc17_18.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc17_18.4: <specific function> = specific_function %.loc17_18.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc17_18: init %i32 = call %.loc17_18.4(%.loc17_18.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_18.5: %i32 = value_of_initializer %int.convert_checked.loc17_18 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_18.6: %i32 = converted %.loc17_18.1, %.loc17_18.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_21.3: <bound method> = bound_method %.loc17_21.1, %.loc17_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc17_21.4: <specific function> = specific_function %.loc17_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc17_21: init %i32 = call %.loc17_21.4(%.loc17_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_21.5: %i32 = value_of_initializer %int.convert_checked.loc17_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_21.6: %i32 = converted %.loc17_21.1, %.loc17_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.smod.loc17: init %i32 = call %Mod.ref.loc17(%.loc17_18.6, %.loc17_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc17_23.1: %i32 = value_of_initializer %int.smod.loc17 [template = <error>]
 // CHECK:STDOUT:   %.loc17_23.2: %i32 = converted %int.smod.loc17, %.loc17_23.1 [template = <error>]

toolchain/check/testdata/builtins/int/smul.carbon

@@ -46,22 +46,22 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 6 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 6 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 6 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 6 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -116,39 +116,39 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Mul.ref: %Mul.type = name_ref Mul, %Mul.decl [template = constants.%Mul]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.smul: init %i32 = call %Mul.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.smul: init %i32 = call %Mul.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.smul, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.smul [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.smul, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.smul, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.smul, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.smul [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.smul, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.smul, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 6 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -193,9 +193,9 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -213,19 +213,19 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 32767 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 65536 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2147418112 [template]
-// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 32768 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 32768 [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 32767 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 65536 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2147418112 [template]
+// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 32768 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.35, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 32768 [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -289,40 +289,40 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Mul.ref.loc6: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul]
 // CHECK:STDOUT:   %.loc6_18.1: Core.IntLiteral = int_value 32767 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_26.1: Core.IntLiteral = int_value 65536 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_26.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_26.3: <bound method> = bound_method %.loc6_26.1, %.loc6_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc6_26.4: <specific function> = specific_function %.loc6_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc6_26: init %i32 = call %.loc6_26.4(%.loc6_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_26.5: %i32 = value_of_initializer %int.convert_checked.loc6_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_26.6: %i32 = converted %.loc6_26.1, %.loc6_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.smul.loc6: init %i32 = call %Mul.ref.loc6(%.loc6_18.6, %.loc6_26.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_34.1: %i32 = value_of_initializer %int.smul.loc6 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_34.2: %i32 = converted %int.smul.loc6, %.loc6_34.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_26.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_26.3: <bound method> = bound_method %.loc6_26.1, %.loc6_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc6_26.4: <specific function> = specific_function %.loc6_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc6_26: init %i32 = call %.loc6_26.4(%.loc6_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_26.5: %i32 = value_of_initializer %int.convert_checked.loc6_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_26.6: %i32 = converted %.loc6_26.1, %.loc6_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.smul.loc6: init %i32 = call %Mul.ref.loc6(%.loc6_18.6, %.loc6_26.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_34.1: %i32 = value_of_initializer %int.smul.loc6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_34.2: %i32 = converted %int.smul.loc6, %.loc6_34.1 [template = constants.%.34]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc6_34.2
 // CHECK:STDOUT:   %Mul.ref.loc10: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul]
-// CHECK:STDOUT:   %.loc10_18.1: Core.IntLiteral = int_value 32768 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_18.1: Core.IntLiteral = int_value 32768 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc10_26.1: Core.IntLiteral = int_value 65536 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_26: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked.loc10_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.smul.loc10: init %i32 = call %Mul.ref.loc10(%.loc10_18.6, %.loc10_26.6) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc10_34.1: %i32 = value_of_initializer %int.smul.loc10 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc10_34.2: %i32 = converted %int.smul.loc10, %.loc10_34.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_26.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_26.3: <bound method> = bound_method %.loc10_26.1, %.loc10_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_26.4: <specific function> = specific_function %.loc10_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_26: init %i32 = call %.loc10_26.4(%.loc10_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.5: %i32 = value_of_initializer %int.convert_checked.loc10_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_26.6: %i32 = converted %.loc10_26.1, %.loc10_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.smul.loc10: init %i32 = call %Mul.ref.loc10(%.loc10_18.6, %.loc10_26.6) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc10_34.1: %i32 = value_of_initializer %int.smul.loc10 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc10_34.2: %i32 = converted %int.smul.loc10, %.loc10_34.1 [template = constants.%.39]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc10_34.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/snegate.carbon

@@ -130,23 +130,23 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 123 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -123 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 123 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -123 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.25, %Convert.15 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.30: type = array_type %.2, %i32 [template]
-// CHECK:STDOUT:   %.31: type = ptr_type %.30 [template]
-// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.32, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.29, %Convert.15 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.34: type = array_type %.2, %i32 [template]
+// CHECK:STDOUT:   %.35: type = ptr_type %.34 [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.36, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -194,36 +194,36 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Negate.ref.loc4_16: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %Negate.ref.loc4_23: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc4_30.1: Core.IntLiteral = int_value 123 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc4_30.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_30.3: <bound method> = bound_method %.loc4_30.1, %.loc4_30.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc4_30.4: <specific function> = specific_function %.loc4_30.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc4_30: init %i32 = call %.loc4_30.4(%.loc4_30.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc4_30.5: %i32 = value_of_initializer %int.convert_checked.loc4_30 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc4_30.6: %i32 = converted %.loc4_30.1, %.loc4_30.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc4_29: init %i32 = call %Negate.ref.loc4_23(%.loc4_30.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_29.1: %i32 = value_of_initializer %int.snegate.loc4_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_29.2: %i32 = converted %int.snegate.loc4_29, %.loc4_29.1 [template = constants.%.26]
-// CHECK:STDOUT:   %int.snegate.loc4_22: init %i32 = call %Negate.ref.loc4_16(%.loc4_29.2) [template = constants.%.25]
+// CHECK:STDOUT:   %.loc4_30.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_30.3: <bound method> = bound_method %.loc4_30.1, %.loc4_30.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc4_30.4: <specific function> = specific_function %.loc4_30.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc4_30: init %i32 = call %.loc4_30.4(%.loc4_30.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_30.5: %i32 = value_of_initializer %int.convert_checked.loc4_30 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_30.6: %i32 = converted %.loc4_30.1, %.loc4_30.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc4_29: init %i32 = call %Negate.ref.loc4_23(%.loc4_30.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_29.1: %i32 = value_of_initializer %int.snegate.loc4_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_29.2: %i32 = converted %int.snegate.loc4_29, %.loc4_29.1 [template = constants.%.30]
+// CHECK:STDOUT:   %int.snegate.loc4_22: init %i32 = call %Negate.ref.loc4_16(%.loc4_29.2) [template = constants.%.29]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_22.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_22.2: <bound method> = bound_method %int.snegate.loc4_22, %.loc4_22.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc4_22.3: <specific function> = specific_function %.loc4_22.2, @Convert.4(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_22.4: %i32 = value_of_initializer %int.snegate.loc4_22 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc4_22.5: %i32 = converted %int.snegate.loc4_22, %.loc4_22.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc4_22.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_22.2: <bound method> = bound_method %int.snegate.loc4_22, %.loc4_22.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc4_22.3: <specific function> = specific_function %.loc4_22.2, @Convert.4(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_22.4: %i32 = value_of_initializer %int.snegate.loc4_22 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_22.5: %i32 = converted %int.snegate.loc4_22, %.loc4_22.4 [template = constants.%.29]
 // CHECK:STDOUT:   %int.convert_checked.loc4_22: init Core.IntLiteral = call %.loc4_22.3(%.loc4_22.5) [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_22.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_22 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_22.7: Core.IntLiteral = converted %int.snegate.loc4_22, %.loc4_22.6 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc4_35: type = array_type %.loc4_22.7, %i32 [template = constants.%.30]
-// CHECK:STDOUT:   %arr.var: ref %.30 = var arr
-// CHECK:STDOUT:   %arr: ref %.30 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_35: type = array_type %.loc4_22.7, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %arr.var: ref %.34 = var arr
+// CHECK:STDOUT:   %arr: ref %.34 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 123 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_21: type = array_type %.loc5_18, %i32 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc5_22: type = ptr_type %.30 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc5_21: type = array_type %.loc5_18, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_22: type = ptr_type %.34 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc7_8.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc7: init type = call constants.%Int(%.loc7_8.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc7_8.2: type = value_of_initializer %int.make_type_signed.loc7 [template = constants.%i32]
@@ -271,20 +271,20 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.30 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.31 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.31 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.34 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.35 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.35 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc7_21.1: Core.IntLiteral = int_value 1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc7_21.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_21.3: <bound method> = bound_method %.loc7_21.1, %.loc7_21.2 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc7_21.4: <specific function> = specific_function %.loc7_21.3, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc7_21.4(%.loc7_21.1) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_21.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_21.6: %i32 = converted %.loc7_21.1, %.loc7_21.5 [template = constants.%.35]
-// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc7_21.6) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc7_23.1: %i32 = value_of_initializer %int.snegate [template = constants.%.36]
-// CHECK:STDOUT:   %.loc7_23.2: %i32 = converted %int.snegate, %.loc7_23.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_21.1: Core.IntLiteral = int_value 1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_21.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_21.3: <bound method> = bound_method %.loc7_21.1, %.loc7_21.2 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc7_21.4: <specific function> = specific_function %.loc7_21.3, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc7_21.4(%.loc7_21.1) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_21.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_21.6: %i32 = converted %.loc7_21.1, %.loc7_21.5 [template = constants.%.39]
+// CHECK:STDOUT:   %int.snegate: init %i32 = call %Negate.ref(%.loc7_21.6) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc7_23.1: %i32 = value_of_initializer %int.snegate [template = constants.%.40]
+// CHECK:STDOUT:   %.loc7_23.2: %i32 = converted %int.snegate, %.loc7_23.1 [template = constants.%.40]
 // CHECK:STDOUT:   %n: %i32 = bind_name n, %.loc7_23.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -311,13 +311,13 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template]
 // CHECK:STDOUT:   %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template]
@@ -440,18 +440,18 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %TooMany.ref: %TooMany.type = name_ref TooMany, %TooMany.decl [template = constants.%TooMany]
 // CHECK:STDOUT:   %.loc30_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc30_32.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.33]
 // CHECK:STDOUT:   %TooMany.call: init %i32 = call %TooMany.ref(%.loc30_29.6, %.loc30_32.6)
 // CHECK:STDOUT:   %.loc30_16.2: type = value_of_initializer %int.make_type_signed.loc30 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc30_16.3: type = converted %int.make_type_signed.loc30, %.loc30_16.2 [template = constants.%i32]
@@ -461,12 +461,12 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %int.make_type_signed.loc35: init type = call constants.%Int(%.loc35_23.1) [template = constants.%i32]
 // CHECK:STDOUT:   %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, %BadReturnType.decl [template = constants.%BadReturnType]
 // CHECK:STDOUT:   %.loc35_42.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc35: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc35: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.30]
 // CHECK:STDOUT:   %BadReturnType.call: init bool = call %BadReturnType.ref(%.loc35_42.6)
 // CHECK:STDOUT:   %.loc35_23.2: type = value_of_initializer %int.make_type_signed.loc35 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc35_23.3: type = converted %int.make_type_signed.loc35, %.loc35_23.2 [template = constants.%i32]
@@ -611,16 +611,16 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -706,45 +706,45 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Negate.ref.loc8_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %Negate.ref.loc8_21: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc8_28.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc8_28.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_28.3: <bound method> = bound_method %.loc8_28.1, %.loc8_28.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc8_28.4: <specific function> = specific_function %.loc8_28.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_28.4(%.loc8_28.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_28.5: %i32 = value_of_initializer %int.convert_checked.loc8 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_28.6: %i32 = converted %.loc8_28.1, %.loc8_28.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc8_27: init %i32 = call %Negate.ref.loc8_21(%.loc8_28.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_27.1: %i32 = value_of_initializer %int.snegate.loc8_27 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_27.2: %i32 = converted %int.snegate.loc8_27, %.loc8_27.1 [template = constants.%.26]
-// CHECK:STDOUT:   %int.snegate.loc8_20: init %i32 = call %Negate.ref.loc8_14(%.loc8_27.2) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_40.1: %i32 = value_of_initializer %int.snegate.loc8_20 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_40.2: %i32 = converted %int.snegate.loc8_20, %.loc8_40.1 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc8_28.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_28.3: <bound method> = bound_method %.loc8_28.1, %.loc8_28.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc8_28.4: <specific function> = specific_function %.loc8_28.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_28.4(%.loc8_28.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_28.5: %i32 = value_of_initializer %int.convert_checked.loc8 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_28.6: %i32 = converted %.loc8_28.1, %.loc8_28.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc8_27: init %i32 = call %Negate.ref.loc8_21(%.loc8_28.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_27.1: %i32 = value_of_initializer %int.snegate.loc8_27 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_27.2: %i32 = converted %int.snegate.loc8_27, %.loc8_27.1 [template = constants.%.30]
+// CHECK:STDOUT:   %int.snegate.loc8_20: init %i32 = call %Negate.ref.loc8_14(%.loc8_27.2) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_40.1: %i32 = value_of_initializer %int.snegate.loc8_20 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_40.2: %i32 = converted %int.snegate.loc8_20, %.loc8_40.1 [template = constants.%.29]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc8_40.2
 // CHECK:STDOUT:   %Negate.ref.loc14_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %Sub.ref: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc14_25: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc14_32.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc14_32.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_32.3: <bound method> = bound_method %.loc14_32.1, %.loc14_32.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc14_32.4: <specific function> = specific_function %.loc14_32.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc14_32: init %i32 = call %.loc14_32.4(%.loc14_32.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_32.5: %i32 = value_of_initializer %int.convert_checked.loc14_32 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_32.6: %i32 = converted %.loc14_32.1, %.loc14_32.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.snegate.loc14_31: init %i32 = call %Negate.ref.loc14_25(%.loc14_32.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_45.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc14_31.1: %i32 = value_of_initializer %int.snegate.loc14_31 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_31.2: %i32 = converted %int.snegate.loc14_31, %.loc14_31.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_45.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_45.3: <bound method> = bound_method %.loc14_45.1, %.loc14_45.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc14_45.4: <specific function> = specific_function %.loc14_45.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc14_45: init %i32 = call %.loc14_45.4(%.loc14_45.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_45.5: %i32 = value_of_initializer %int.convert_checked.loc14_45 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc14_45.6: %i32 = converted %.loc14_45.1, %.loc14_45.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.ssub: init %i32 = call %Sub.ref(%.loc14_31.2, %.loc14_45.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc14_24.1: %i32 = value_of_initializer %int.ssub [template = constants.%.31]
-// CHECK:STDOUT:   %.loc14_24.2: %i32 = converted %int.ssub, %.loc14_24.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.snegate.loc14_20: init %i32 = call %Negate.ref.loc14_14(%.loc14_24.2) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc14_48.1: %i32 = value_of_initializer %int.snegate.loc14_20 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc14_48.2: %i32 = converted %int.snegate.loc14_20, %.loc14_48.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc14_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_32.3: <bound method> = bound_method %.loc14_32.1, %.loc14_32.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc14_32.4: <specific function> = specific_function %.loc14_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc14_32: init %i32 = call %.loc14_32.4(%.loc14_32.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_32.5: %i32 = value_of_initializer %int.convert_checked.loc14_32 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_32.6: %i32 = converted %.loc14_32.1, %.loc14_32.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.snegate.loc14_31: init %i32 = call %Negate.ref.loc14_25(%.loc14_32.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_45.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc14_31.1: %i32 = value_of_initializer %int.snegate.loc14_31 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_31.2: %i32 = converted %int.snegate.loc14_31, %.loc14_31.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_45.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_45.3: <bound method> = bound_method %.loc14_45.1, %.loc14_45.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc14_45.4: <specific function> = specific_function %.loc14_45.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc14_45: init %i32 = call %.loc14_45.4(%.loc14_45.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_45.5: %i32 = value_of_initializer %int.convert_checked.loc14_45 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc14_45.6: %i32 = converted %.loc14_45.1, %.loc14_45.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.ssub: init %i32 = call %Sub.ref(%.loc14_31.2, %.loc14_45.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc14_24.1: %i32 = value_of_initializer %int.ssub [template = constants.%.35]
+// CHECK:STDOUT:   %.loc14_24.2: %i32 = converted %int.ssub, %.loc14_24.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.snegate.loc14_20: init %i32 = call %Negate.ref.loc14_14(%.loc14_24.2) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc14_48.1: %i32 = value_of_initializer %int.snegate.loc14_20 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc14_48.2: %i32 = converted %int.snegate.loc14_20, %.loc14_48.1 [template = constants.%.35]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc14_48.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/ssub.carbon

@@ -47,22 +47,22 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -117,39 +117,39 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Sub.ref: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.ssub: init %i32 = call %Sub.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.ssub: init %i32 = call %Sub.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.ssub, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.ssub [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.ssub, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.ssub, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.ssub, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.ssub [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.ssub, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.ssub, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -194,9 +194,9 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -214,23 +214,23 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value -2147483648 [template]
-// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.36, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.35, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.40: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.40, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -299,81 +299,81 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Sub.ref.loc6: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc6_18.1: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_21.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_21.3: <bound method> = bound_method %.loc6_21.1, %.loc6_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc6_21.4: <specific function> = specific_function %.loc6_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc6_21: init %i32 = call %.loc6_21.4(%.loc6_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_21.5: %i32 = value_of_initializer %int.convert_checked.loc6_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_21.6: %i32 = converted %.loc6_21.1, %.loc6_21.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.ssub.loc6: init %i32 = call %Sub.ref.loc6(%.loc6_18.6, %.loc6_21.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_32.1: %i32 = value_of_initializer %int.ssub.loc6 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_32.2: %i32 = converted %int.ssub.loc6, %.loc6_32.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_21.3: <bound method> = bound_method %.loc6_21.1, %.loc6_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc6_21.4: <specific function> = specific_function %.loc6_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc6_21: init %i32 = call %.loc6_21.4(%.loc6_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_21.5: %i32 = value_of_initializer %int.convert_checked.loc6_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_21.6: %i32 = converted %.loc6_21.1, %.loc6_21.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.ssub.loc6: init %i32 = call %Sub.ref.loc6(%.loc6_18.6, %.loc6_21.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_32.1: %i32 = value_of_initializer %int.ssub.loc6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_32.2: %i32 = converted %int.ssub.loc6, %.loc6_32.1 [template = constants.%.34]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc6_32.2
 // CHECK:STDOUT:   %Sub.ref.loc7_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Sub.ref.loc7_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc7_22.1: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc7_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_22.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_22.3: <bound method> = bound_method %.loc7_22.1, %.loc7_22.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc7_22.4: <specific function> = specific_function %.loc7_22.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc7_22: init %i32 = call %.loc7_22.4(%.loc7_22.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_22.5: %i32 = value_of_initializer %int.convert_checked.loc7_22 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_22.6: %i32 = converted %.loc7_22.1, %.loc7_22.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_25.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_25.3: <bound method> = bound_method %.loc7_25.1, %.loc7_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc7_25.4: <specific function> = specific_function %.loc7_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc7_25: init %i32 = call %.loc7_25.4(%.loc7_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_25.5: %i32 = value_of_initializer %int.convert_checked.loc7_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_25.6: %i32 = converted %.loc7_25.1, %.loc7_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.ssub.loc7_21: init %i32 = call %Sub.ref.loc7_18(%.loc7_22.6, %.loc7_25.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc7_38.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc7_21.1: %i32 = value_of_initializer %int.ssub.loc7_21 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc7_21.2: %i32 = converted %int.ssub.loc7_21, %.loc7_21.1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc7_38.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_38.3: <bound method> = bound_method %.loc7_38.1, %.loc7_38.2 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc7_38.4: <specific function> = specific_function %.loc7_38.3, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc7_38: init %i32 = call %.loc7_38.4(%.loc7_38.1) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_38.5: %i32 = value_of_initializer %int.convert_checked.loc7_38 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_38.6: %i32 = converted %.loc7_38.1, %.loc7_38.5 [template = constants.%.34]
-// CHECK:STDOUT:   %int.ssub.loc7_17: init %i32 = call %Sub.ref.loc7_14(%.loc7_21.2, %.loc7_38.6) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_40.1: %i32 = value_of_initializer %int.ssub.loc7_17 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_40.2: %i32 = converted %int.ssub.loc7_17, %.loc7_40.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc7_22.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_22.3: <bound method> = bound_method %.loc7_22.1, %.loc7_22.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc7_22.4: <specific function> = specific_function %.loc7_22.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc7_22: init %i32 = call %.loc7_22.4(%.loc7_22.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_22.5: %i32 = value_of_initializer %int.convert_checked.loc7_22 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_22.6: %i32 = converted %.loc7_22.1, %.loc7_22.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_25.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_25.3: <bound method> = bound_method %.loc7_25.1, %.loc7_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc7_25.4: <specific function> = specific_function %.loc7_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc7_25: init %i32 = call %.loc7_25.4(%.loc7_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_25.5: %i32 = value_of_initializer %int.convert_checked.loc7_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_25.6: %i32 = converted %.loc7_25.1, %.loc7_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.ssub.loc7_21: init %i32 = call %Sub.ref.loc7_18(%.loc7_22.6, %.loc7_25.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc7_38.1: Core.IntLiteral = int_value 1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc7_21.1: %i32 = value_of_initializer %int.ssub.loc7_21 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc7_21.2: %i32 = converted %int.ssub.loc7_21, %.loc7_21.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc7_38.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_38.3: <bound method> = bound_method %.loc7_38.1, %.loc7_38.2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_38.4: <specific function> = specific_function %.loc7_38.3, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc7_38: init %i32 = call %.loc7_38.4(%.loc7_38.1) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_38.5: %i32 = value_of_initializer %int.convert_checked.loc7_38 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_38.6: %i32 = converted %.loc7_38.1, %.loc7_38.5 [template = constants.%.38]
+// CHECK:STDOUT:   %int.ssub.loc7_17: init %i32 = call %Sub.ref.loc7_14(%.loc7_21.2, %.loc7_38.6) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_40.1: %i32 = value_of_initializer %int.ssub.loc7_17 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_40.2: %i32 = converted %int.ssub.loc7_17, %.loc7_40.1 [template = constants.%.39]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc7_40.2
 // CHECK:STDOUT:   %Sub.ref.loc11_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Sub.ref.loc11_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc11_22.1: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc11_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc11_22.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_22.3: <bound method> = bound_method %.loc11_22.1, %.loc11_22.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc11_22.4: <specific function> = specific_function %.loc11_22.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc11_22: init %i32 = call %.loc11_22.4(%.loc11_22.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_22.5: %i32 = value_of_initializer %int.convert_checked.loc11_22 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_22.6: %i32 = converted %.loc11_22.1, %.loc11_22.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_25.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_25.3: <bound method> = bound_method %.loc11_25.1, %.loc11_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_25.4: <specific function> = specific_function %.loc11_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc11_25: init %i32 = call %.loc11_25.4(%.loc11_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_25.5: %i32 = value_of_initializer %int.convert_checked.loc11_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_25.6: %i32 = converted %.loc11_25.1, %.loc11_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.ssub.loc11_21: init %i32 = call %Sub.ref.loc11_18(%.loc11_22.6, %.loc11_25.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_38.1: Core.IntLiteral = int_value 2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc11_21.1: %i32 = value_of_initializer %int.ssub.loc11_21 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_21.2: %i32 = converted %int.ssub.loc11_21, %.loc11_21.1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_38.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_38.3: <bound method> = bound_method %.loc11_38.1, %.loc11_38.2 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc11_38.4: <specific function> = specific_function %.loc11_38.3, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc11_38: init %i32 = call %.loc11_38.4(%.loc11_38.1) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc11_38.5: %i32 = value_of_initializer %int.convert_checked.loc11_38 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc11_38.6: %i32 = converted %.loc11_38.1, %.loc11_38.5 [template = constants.%.39]
-// CHECK:STDOUT:   %int.ssub.loc11_17: init %i32 = call %Sub.ref.loc11_14(%.loc11_21.2, %.loc11_38.6) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_40.1: %i32 = value_of_initializer %int.ssub.loc11_17 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc11_40.2: %i32 = converted %int.ssub.loc11_17, %.loc11_40.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_22.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_22.3: <bound method> = bound_method %.loc11_22.1, %.loc11_22.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc11_22.4: <specific function> = specific_function %.loc11_22.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc11_22: init %i32 = call %.loc11_22.4(%.loc11_22.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_22.5: %i32 = value_of_initializer %int.convert_checked.loc11_22 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_22.6: %i32 = converted %.loc11_22.1, %.loc11_22.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_25.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_25.3: <bound method> = bound_method %.loc11_25.1, %.loc11_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_25.4: <specific function> = specific_function %.loc11_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc11_25: init %i32 = call %.loc11_25.4(%.loc11_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_25.5: %i32 = value_of_initializer %int.convert_checked.loc11_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_25.6: %i32 = converted %.loc11_25.1, %.loc11_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.ssub.loc11_21: init %i32 = call %Sub.ref.loc11_18(%.loc11_22.6, %.loc11_25.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_38.1: Core.IntLiteral = int_value 2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc11_21.1: %i32 = value_of_initializer %int.ssub.loc11_21 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_21.2: %i32 = converted %int.ssub.loc11_21, %.loc11_21.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_38.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_38.3: <bound method> = bound_method %.loc11_38.1, %.loc11_38.2 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc11_38.4: <specific function> = specific_function %.loc11_38.3, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc11_38: init %i32 = call %.loc11_38.4(%.loc11_38.1) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc11_38.5: %i32 = value_of_initializer %int.convert_checked.loc11_38 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc11_38.6: %i32 = converted %.loc11_38.1, %.loc11_38.5 [template = constants.%.43]
+// CHECK:STDOUT:   %int.ssub.loc11_17: init %i32 = call %Sub.ref.loc11_14(%.loc11_21.2, %.loc11_38.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_40.1: %i32 = value_of_initializer %int.ssub.loc11_17 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc11_40.2: %i32 = converted %int.ssub.loc11_17, %.loc11_40.1 [template = constants.%.33]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc11_40.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/uadd.carbon

@@ -101,22 +101,22 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 3 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -171,39 +171,39 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Add.ref: %Add.type = name_ref Add, %Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.uadd: init %i32 = call %Add.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.uadd: init %i32 = call %Add.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.uadd, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.uadd [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.uadd, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.uadd, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.uadd, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.uadd [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.uadd, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.uadd, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 3 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 3 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -248,9 +248,9 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -275,18 +275,18 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.26, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 3 [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template]
 // CHECK:STDOUT:   %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template]
@@ -432,12 +432,12 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc25: init type = call constants.%Int(%.loc25_15.1) [template = constants.%i32]
 // CHECK:STDOUT:   %TooFew.ref: %TooFew.type = name_ref TooFew, %TooFew.decl [template = constants.%TooFew]
 // CHECK:STDOUT:   %.loc25_27.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc25_27.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc25_27.3: <bound method> = bound_method %.loc25_27.1, %.loc25_27.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc25_27.4: <specific function> = specific_function %.loc25_27.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc25: init %i32 = call %.loc25_27.4(%.loc25_27.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc25_27.5: %i32 = value_of_initializer %int.convert_checked.loc25 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc25_27.6: %i32 = converted %.loc25_27.1, %.loc25_27.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc25_27.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc25_27.3: <bound method> = bound_method %.loc25_27.1, %.loc25_27.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc25_27.4: <specific function> = specific_function %.loc25_27.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc25: init %i32 = call %.loc25_27.4(%.loc25_27.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc25_27.5: %i32 = value_of_initializer %int.convert_checked.loc25 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc25_27.6: %i32 = converted %.loc25_27.1, %.loc25_27.5 [template = constants.%.29]
 // CHECK:STDOUT:   %TooFew.call: init %i32 = call %TooFew.ref(%.loc25_27.6)
 // CHECK:STDOUT:   %.loc25_15.2: type = value_of_initializer %int.make_type_signed.loc25 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc25_15.3: type = converted %int.make_type_signed.loc25, %.loc25_15.2 [template = constants.%i32]
@@ -447,26 +447,26 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc30: init type = call constants.%Int(%.loc30_16.1) [template = constants.%i32]
 // CHECK:STDOUT:   %TooMany.ref: %TooMany.type = name_ref TooMany, %TooMany.decl [template = constants.%TooMany]
 // CHECK:STDOUT:   %.loc30_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc30_32.1: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_35.1: Core.IntLiteral = int_value 3 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc30_35.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_35.3: <bound method> = bound_method %.loc30_35.1, %.loc30_35.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc30_35.4: <specific function> = specific_function %.loc30_35.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc30_35: init %i32 = call %.loc30_35.4(%.loc30_35.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc30_35.5: %i32 = value_of_initializer %int.convert_checked.loc30_35 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc30_35.6: %i32 = converted %.loc30_35.1, %.loc30_35.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc30_32.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_35.1: Core.IntLiteral = int_value 3 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc30_35.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_35.3: <bound method> = bound_method %.loc30_35.1, %.loc30_35.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc30_35.4: <specific function> = specific_function %.loc30_35.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc30_35: init %i32 = call %.loc30_35.4(%.loc30_35.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc30_35.5: %i32 = value_of_initializer %int.convert_checked.loc30_35 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc30_35.6: %i32 = converted %.loc30_35.1, %.loc30_35.5 [template = constants.%.37]
 // CHECK:STDOUT:   %TooMany.call: init %i32 = call %TooMany.ref(%.loc30_29.6, %.loc30_32.6, %.loc30_35.6)
 // CHECK:STDOUT:   %.loc30_16.2: type = value_of_initializer %int.make_type_signed.loc30 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc30_16.3: type = converted %int.make_type_signed.loc30, %.loc30_16.2 [template = constants.%i32]
@@ -476,19 +476,19 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc35: init type = call constants.%Int(%.loc35_23.1) [template = constants.%i32]
 // CHECK:STDOUT:   %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, %BadReturnType.decl [template = constants.%BadReturnType]
 // CHECK:STDOUT:   %.loc35_42.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc35_45.1: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc35_42: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35_42 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc35_45.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_45.3: <bound method> = bound_method %.loc35_45.1, %.loc35_45.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc35_45.4: <specific function> = specific_function %.loc35_45.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc35_45: init %i32 = call %.loc35_45.4(%.loc35_45.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc35_45.5: %i32 = value_of_initializer %int.convert_checked.loc35_45 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc35_45.6: %i32 = converted %.loc35_45.1, %.loc35_45.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_45.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc35_42: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35_42 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc35_45.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_45.3: <bound method> = bound_method %.loc35_45.1, %.loc35_45.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc35_45.4: <specific function> = specific_function %.loc35_45.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc35_45: init %i32 = call %.loc35_45.4(%.loc35_45.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc35_45.5: %i32 = value_of_initializer %int.convert_checked.loc35_45 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc35_45.6: %i32 = converted %.loc35_45.1, %.loc35_45.5 [template = constants.%.34]
 // CHECK:STDOUT:   %BadReturnType.call: init bool = call %BadReturnType.ref(%.loc35_42.6, %.loc35_45.6)
 // CHECK:STDOUT:   %.loc35_23.2: type = value_of_initializer %int.make_type_signed.loc35 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc35_23.3: type = converted %int.make_type_signed.loc35, %.loc35_23.2 [template = constants.%i32]
@@ -498,8 +498,8 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %int.make_type_signed.loc43: init type = call constants.%Int(%.loc43_16.1) [template = constants.%i32]
 // CHECK:STDOUT:   %JustRight.ref: %JustRight.type = name_ref JustRight, %JustRight.decl [template = constants.%JustRight]
 // CHECK:STDOUT:   %.loc43_31: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc43_34: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc43_37: Core.IntLiteral = int_value 3 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc43_34: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc43_37: Core.IntLiteral = int_value 3 [template = constants.%.31]
 // CHECK:STDOUT:   %.loc43_16.2: type = value_of_initializer %int.make_type_signed.loc43 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc43_16.3: type = converted %int.make_type_signed.loc43, %.loc43_16.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc43_39: type = array_type <error>, %i32 [template = <error>]
@@ -642,18 +642,18 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
 // CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -717,40 +717,40 @@ let b: i32 = Add(0x7FFFFFFF, 1);
 // CHECK:STDOUT:   %Add.ref.loc7: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc7_18.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc7_30.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_18.3: <bound method> = bound_method %.loc7_18.1, %.loc7_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc7_18.4: <specific function> = specific_function %.loc7_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc7_18: init %i32 = call %.loc7_18.4(%.loc7_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_18.5: %i32 = value_of_initializer %int.convert_checked.loc7_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_18.6: %i32 = converted %.loc7_18.1, %.loc7_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_30.3: <bound method> = bound_method %.loc7_30.1, %.loc7_30.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc7_30.4: <specific function> = specific_function %.loc7_30.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc7_30: init %i32 = call %.loc7_30.4(%.loc7_30.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_30.5: %i32 = value_of_initializer %int.convert_checked.loc7_30 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_30.6: %i32 = converted %.loc7_30.1, %.loc7_30.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.uadd.loc7: init %i32 = call %Add.ref.loc7(%.loc7_18.6, %.loc7_30.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_32.1: %i32 = value_of_initializer %int.uadd.loc7 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_32.2: %i32 = converted %int.uadd.loc7, %.loc7_32.1 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc7_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_18.3: <bound method> = bound_method %.loc7_18.1, %.loc7_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc7_18.4: <specific function> = specific_function %.loc7_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc7_18: init %i32 = call %.loc7_18.4(%.loc7_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_18.5: %i32 = value_of_initializer %int.convert_checked.loc7_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_18.6: %i32 = converted %.loc7_18.1, %.loc7_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_30.3: <bound method> = bound_method %.loc7_30.1, %.loc7_30.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc7_30.4: <specific function> = specific_function %.loc7_30.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc7_30: init %i32 = call %.loc7_30.4(%.loc7_30.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_30.5: %i32 = value_of_initializer %int.convert_checked.loc7_30 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_30.6: %i32 = converted %.loc7_30.1, %.loc7_30.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.uadd.loc7: init %i32 = call %Add.ref.loc7(%.loc7_18.6, %.loc7_30.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_32.1: %i32 = value_of_initializer %int.uadd.loc7 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_32.2: %i32 = converted %int.uadd.loc7, %.loc7_32.1 [template = constants.%.30]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc7_32.2
 // CHECK:STDOUT:   %Add.ref.loc8: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc8_18.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc8_30.1: Core.IntLiteral = int_value 1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_18.3: <bound method> = bound_method %.loc8_18.1, %.loc8_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc8_18.4: <specific function> = specific_function %.loc8_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc8_18: init %i32 = call %.loc8_18.4(%.loc8_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_18.5: %i32 = value_of_initializer %int.convert_checked.loc8_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_18.6: %i32 = converted %.loc8_18.1, %.loc8_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_30.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_30.3: <bound method> = bound_method %.loc8_30.1, %.loc8_30.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc8_30.4: <specific function> = specific_function %.loc8_30.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc8_30: init %i32 = call %.loc8_30.4(%.loc8_30.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc8_30.5: %i32 = value_of_initializer %int.convert_checked.loc8_30 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc8_30.6: %i32 = converted %.loc8_30.1, %.loc8_30.5 [template = constants.%.33]
-// CHECK:STDOUT:   %int.uadd.loc8: init %i32 = call %Add.ref.loc8(%.loc8_18.6, %.loc8_30.6) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc8_32.1: %i32 = value_of_initializer %int.uadd.loc8 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc8_32.2: %i32 = converted %int.uadd.loc8, %.loc8_32.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_30.1: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_18.3: <bound method> = bound_method %.loc8_18.1, %.loc8_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc8_18.4: <specific function> = specific_function %.loc8_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc8_18: init %i32 = call %.loc8_18.4(%.loc8_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_18.5: %i32 = value_of_initializer %int.convert_checked.loc8_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_18.6: %i32 = converted %.loc8_18.1, %.loc8_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_30.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_30.3: <bound method> = bound_method %.loc8_30.1, %.loc8_30.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc8_30.4: <specific function> = specific_function %.loc8_30.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc8_30: init %i32 = call %.loc8_30.4(%.loc8_30.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc8_30.5: %i32 = value_of_initializer %int.convert_checked.loc8_30 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc8_30.6: %i32 = converted %.loc8_30.1, %.loc8_30.5 [template = constants.%.37]
+// CHECK:STDOUT:   %int.uadd.loc8: init %i32 = call %Add.ref.loc8(%.loc8_18.6, %.loc8_30.6) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc8_32.1: %i32 = value_of_initializer %int.uadd.loc8 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc8_32.2: %i32 = converted %int.uadd.loc8, %.loc8_32.1 [template = constants.%.38]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc8_32.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/udiv.carbon

@@ -68,22 +68,22 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -138,39 +138,39 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref: %Div.type = name_ref Div, %Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.udiv: init %i32 = call %Div.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.udiv: init %i32 = call %Div.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.udiv, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.udiv [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.udiv, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.udiv, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.udiv, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.udiv [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.udiv, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.udiv, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -215,9 +215,9 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -238,18 +238,18 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value -1 [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -370,101 +370,101 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref.loc9: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc9_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.26]
+// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.30]
 // CHECK:STDOUT:   %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.unegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.unegate.loc9_24 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.unegate.loc9_24, %.loc9_24.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.unegate.loc9_45 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.unegate.loc9_45, %.loc9_45.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.udiv.loc9: init %i32 = call %Div.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.udiv.loc9 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.udiv.loc9, %.loc9_49.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.unegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.unegate.loc9_24 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.unegate.loc9_24, %.loc9_24.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.unegate.loc9_45 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.unegate.loc9_45, %.loc9_45.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.udiv.loc9: init %i32 = call %Div.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.udiv.loc9 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.udiv.loc9, %.loc9_49.1 [template = constants.%.36]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc9_49.2
 // CHECK:STDOUT:   %Div.ref.loc12: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.unegate.loc12 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.unegate.loc12, %.loc12_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.usub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.usub.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.usub.loc12, %.loc12_21.1 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.udiv.loc12: init %i32 = call %Div.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.udiv.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.udiv.loc12, %.loc12_49.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.unegate.loc12 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.unegate.loc12, %.loc12_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.usub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.usub.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.usub.loc12, %.loc12_21.1 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.udiv.loc12: init %i32 = call %Div.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.udiv.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.udiv.loc12, %.loc12_49.1 [template = constants.%.37]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc12_49.2
 // CHECK:STDOUT:   %Div.ref.loc15: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %Sub.ref.loc15: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc15_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc15_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc15_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_29.3: <bound method> = bound_method %.loc15_29.1, %.loc15_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc15_29.4: <specific function> = specific_function %.loc15_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc15_29: init %i32 = call %.loc15_29.4(%.loc15_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_29.5: %i32 = value_of_initializer %int.convert_checked.loc15_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_29.6: %i32 = converted %.loc15_29.1, %.loc15_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc15_28: init %i32 = call %Negate.ref.loc15_22(%.loc15_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_28.1: %i32 = value_of_initializer %int.unegate.loc15_28 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_28.2: %i32 = converted %int.unegate.loc15_28, %.loc15_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_43.3: <bound method> = bound_method %.loc15_43.1, %.loc15_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc15_43.4: <specific function> = specific_function %.loc15_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc15_43: init %i32 = call %.loc15_43.4(%.loc15_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_43.5: %i32 = value_of_initializer %int.convert_checked.loc15_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_43.6: %i32 = converted %.loc15_43.1, %.loc15_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.usub.loc15: init %i32 = call %Sub.ref.loc15(%.loc15_28.2, %.loc15_43.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_29.3: <bound method> = bound_method %.loc15_29.1, %.loc15_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc15_29.4: <specific function> = specific_function %.loc15_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc15_29: init %i32 = call %.loc15_29.4(%.loc15_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_29.5: %i32 = value_of_initializer %int.convert_checked.loc15_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_29.6: %i32 = converted %.loc15_29.1, %.loc15_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc15_28: init %i32 = call %Negate.ref.loc15_22(%.loc15_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_28.1: %i32 = value_of_initializer %int.unegate.loc15_28 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_28.2: %i32 = converted %int.unegate.loc15_28, %.loc15_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_43.3: <bound method> = bound_method %.loc15_43.1, %.loc15_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_43.4: <specific function> = specific_function %.loc15_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc15_43: init %i32 = call %.loc15_43.4(%.loc15_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_43.5: %i32 = value_of_initializer %int.convert_checked.loc15_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_43.6: %i32 = converted %.loc15_43.1, %.loc15_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.usub.loc15: init %i32 = call %Sub.ref.loc15(%.loc15_28.2, %.loc15_43.6) [template = constants.%.37]
 // CHECK:STDOUT:   %Negate.ref.loc15_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc15_54.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_54.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_54.3: <bound method> = bound_method %.loc15_54.1, %.loc15_54.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc15_54.4: <specific function> = specific_function %.loc15_54.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc15_54: init %i32 = call %.loc15_54.4(%.loc15_54.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_54.5: %i32 = value_of_initializer %int.convert_checked.loc15_54 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_54.6: %i32 = converted %.loc15_54.1, %.loc15_54.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.unegate.loc15_53: init %i32 = call %Negate.ref.loc15_47(%.loc15_54.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc15_21.1: %i32 = value_of_initializer %int.usub.loc15 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc15_21.2: %i32 = converted %int.usub.loc15, %.loc15_21.1 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc15_53.1: %i32 = value_of_initializer %int.unegate.loc15_53 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc15_53.2: %i32 = converted %int.unegate.loc15_53, %.loc15_53.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.udiv.loc15: init %i32 = call %Div.ref.loc15(%.loc15_21.2, %.loc15_53.2) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc15_57.1: %i32 = value_of_initializer %int.udiv.loc15 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc15_57.2: %i32 = converted %int.udiv.loc15, %.loc15_57.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_54.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_54.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_54.3: <bound method> = bound_method %.loc15_54.1, %.loc15_54.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_54.4: <specific function> = specific_function %.loc15_54.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc15_54: init %i32 = call %.loc15_54.4(%.loc15_54.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_54.5: %i32 = value_of_initializer %int.convert_checked.loc15_54 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_54.6: %i32 = converted %.loc15_54.1, %.loc15_54.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.unegate.loc15_53: init %i32 = call %Negate.ref.loc15_47(%.loc15_54.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc15_21.1: %i32 = value_of_initializer %int.usub.loc15 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc15_21.2: %i32 = converted %int.usub.loc15, %.loc15_21.1 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc15_53.1: %i32 = value_of_initializer %int.unegate.loc15_53 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc15_53.2: %i32 = converted %int.unegate.loc15_53, %.loc15_53.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.udiv.loc15: init %i32 = call %Div.ref.loc15(%.loc15_21.2, %.loc15_53.2) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_57.1: %i32 = value_of_initializer %int.udiv.loc15 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_57.2: %i32 = converted %int.udiv.loc15, %.loc15_57.1 [template = constants.%.36]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc15_57.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -483,13 +483,13 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -553,18 +553,18 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref.loc10: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %.loc10_18.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc10_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc10_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_21.3: <bound method> = bound_method %.loc10_21.1, %.loc10_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc10_21.4: <specific function> = specific_function %.loc10_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc10_21: init %i32 = call %.loc10_21.4(%.loc10_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_21.5: %i32 = value_of_initializer %int.convert_checked.loc10_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc10_21.6: %i32 = converted %.loc10_21.1, %.loc10_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_18.3: <bound method> = bound_method %.loc10_18.1, %.loc10_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc10_18.4: <specific function> = specific_function %.loc10_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc10_18: init %i32 = call %.loc10_18.4(%.loc10_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_18.5: %i32 = value_of_initializer %int.convert_checked.loc10_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_18.6: %i32 = converted %.loc10_18.1, %.loc10_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc10_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_21.3: <bound method> = bound_method %.loc10_21.1, %.loc10_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc10_21.4: <specific function> = specific_function %.loc10_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc10_21: init %i32 = call %.loc10_21.4(%.loc10_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_21.5: %i32 = value_of_initializer %int.convert_checked.loc10_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc10_21.6: %i32 = converted %.loc10_21.1, %.loc10_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.udiv.loc10: init %i32 = call %Div.ref.loc10(%.loc10_18.6, %.loc10_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc10_23.1: %i32 = value_of_initializer %int.udiv.loc10 [template = <error>]
 // CHECK:STDOUT:   %.loc10_23.2: %i32 = converted %int.udiv.loc10, %.loc10_23.1 [template = <error>]
@@ -572,18 +572,18 @@ let b: i32 = Div(0, 0);
 // CHECK:STDOUT:   %Div.ref.loc15: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div]
 // CHECK:STDOUT:   %.loc15_18.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc15_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc15_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_18.3: <bound method> = bound_method %.loc15_18.1, %.loc15_18.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_18.4: <specific function> = specific_function %.loc15_18.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc15_18: init %i32 = call %.loc15_18.4(%.loc15_18.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_18.5: %i32 = value_of_initializer %int.convert_checked.loc15_18 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_18.6: %i32 = converted %.loc15_18.1, %.loc15_18.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_21.3: <bound method> = bound_method %.loc15_21.1, %.loc15_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_21.4: <specific function> = specific_function %.loc15_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc15_21: init %i32 = call %.loc15_21.4(%.loc15_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_21.5: %i32 = value_of_initializer %int.convert_checked.loc15_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_21.6: %i32 = converted %.loc15_21.1, %.loc15_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_18.3: <bound method> = bound_method %.loc15_18.1, %.loc15_18.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_18.4: <specific function> = specific_function %.loc15_18.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc15_18: init %i32 = call %.loc15_18.4(%.loc15_18.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_18.5: %i32 = value_of_initializer %int.convert_checked.loc15_18 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_18.6: %i32 = converted %.loc15_18.1, %.loc15_18.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_21.3: <bound method> = bound_method %.loc15_21.1, %.loc15_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_21.4: <specific function> = specific_function %.loc15_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc15_21: init %i32 = call %.loc15_21.4(%.loc15_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_21.5: %i32 = value_of_initializer %int.convert_checked.loc15_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_21.6: %i32 = converted %.loc15_21.1, %.loc15_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.udiv.loc15: init %i32 = call %Div.ref.loc15(%.loc15_18.6, %.loc15_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc15_23.1: %i32 = value_of_initializer %int.udiv.loc15 [template = <error>]
 // CHECK:STDOUT:   %.loc15_23.2: %i32 = converted %int.udiv.loc15, %.loc15_23.1 [template = <error>]

toolchain/check/testdata/builtins/int/umod.carbon

@@ -70,22 +70,22 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -140,39 +140,39 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref: %Mod.type = name_ref Mod, %Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 5 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 3 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.umod: init %i32 = call %Mod.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.umod: init %i32 = call %Mod.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.umod, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.umod [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.umod, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.umod, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.umod, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.umod [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.umod, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.umod, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 2 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -217,9 +217,9 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -240,18 +240,18 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value -1 [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value -2147483648 [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -372,101 +372,101 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref.loc9: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %Negate.ref.loc9_18: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc9_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.26]
+// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_25.1, %.loc9_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc9_25: init %i32 = call %.loc9_25.4(%.loc9_25.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.5: %i32 = value_of_initializer %int.convert_checked.loc9_25 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_25.6: %i32 = converted %.loc9_25.1, %.loc9_25.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc9_24: init %i32 = call %Negate.ref.loc9_18(%.loc9_25.6) [template = constants.%.30]
 // CHECK:STDOUT:   %Negate.ref.loc9_39: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.unegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.unegate.loc9_24 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.unegate.loc9_24, %.loc9_24.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.unegate.loc9_45 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.unegate.loc9_45, %.loc9_45.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.umod.loc9: init %i32 = call %Mod.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.umod.loc9 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.umod.loc9, %.loc9_49.1 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc9_46.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc9_46.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_46.3: <bound method> = bound_method %.loc9_46.1, %.loc9_46.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_46.4: <specific function> = specific_function %.loc9_46.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc9_46: init %i32 = call %.loc9_46.4(%.loc9_46.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.5: %i32 = value_of_initializer %int.convert_checked.loc9_46 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_46.6: %i32 = converted %.loc9_46.1, %.loc9_46.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.unegate.loc9_45: init %i32 = call %Negate.ref.loc9_39(%.loc9_46.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_24.1: %i32 = value_of_initializer %int.unegate.loc9_24 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_24.2: %i32 = converted %int.unegate.loc9_24, %.loc9_24.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_45.1: %i32 = value_of_initializer %int.unegate.loc9_45 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_45.2: %i32 = converted %int.unegate.loc9_45, %.loc9_45.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.umod.loc9: init %i32 = call %Mod.ref.loc9(%.loc9_24.2, %.loc9_45.2) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_49.1: %i32 = value_of_initializer %int.umod.loc9 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_49.2: %i32 = converted %int.umod.loc9, %.loc9_49.1 [template = constants.%.30]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc9_49.2
 // CHECK:STDOUT:   %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %Sub.ref.loc12: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc12: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc12_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.unegate.loc12 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.unegate.loc12, %.loc12_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.usub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.usub.loc12 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.usub.loc12, %.loc12_21.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.umod.loc12: init %i32 = call %Mod.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.umod.loc12 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.umod.loc12, %.loc12_49.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_29.3: <bound method> = bound_method %.loc12_29.1, %.loc12_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc12_29.4: <specific function> = specific_function %.loc12_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc12_29: init %i32 = call %.loc12_29.4(%.loc12_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.5: %i32 = value_of_initializer %int.convert_checked.loc12_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_29.6: %i32 = converted %.loc12_29.1, %.loc12_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc12: init %i32 = call %Negate.ref.loc12(%.loc12_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_28.1: %i32 = value_of_initializer %int.unegate.loc12 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_28.2: %i32 = converted %int.unegate.loc12, %.loc12_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_43.3: <bound method> = bound_method %.loc12_43.1, %.loc12_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_43.4: <specific function> = specific_function %.loc12_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_43: init %i32 = call %.loc12_43.4(%.loc12_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.5: %i32 = value_of_initializer %int.convert_checked.loc12_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_43.6: %i32 = converted %.loc12_43.1, %.loc12_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.usub.loc12: init %i32 = call %Sub.ref.loc12(%.loc12_28.2, %.loc12_43.6) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_47.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_21.1: %i32 = value_of_initializer %int.usub.loc12 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_21.2: %i32 = converted %int.usub.loc12, %.loc12_21.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc12_47.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_47.3: <bound method> = bound_method %.loc12_47.1, %.loc12_47.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc12_47.4: <specific function> = specific_function %.loc12_47.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc12_47: init %i32 = call %.loc12_47.4(%.loc12_47.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.5: %i32 = value_of_initializer %int.convert_checked.loc12_47 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc12_47.6: %i32 = converted %.loc12_47.1, %.loc12_47.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.umod.loc12: init %i32 = call %Mod.ref.loc12(%.loc12_21.2, %.loc12_47.6) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_49.1: %i32 = value_of_initializer %int.umod.loc12 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc12_49.2: %i32 = converted %int.umod.loc12, %.loc12_49.1 [template = constants.%.37]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc12_49.2
 // CHECK:STDOUT:   %Mod.ref.loc15: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %Sub.ref.loc15: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc15_22: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc15_29.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc15_29.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_29.3: <bound method> = bound_method %.loc15_29.1, %.loc15_29.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc15_29.4: <specific function> = specific_function %.loc15_29.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc15_29: init %i32 = call %.loc15_29.4(%.loc15_29.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_29.5: %i32 = value_of_initializer %int.convert_checked.loc15_29 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_29.6: %i32 = converted %.loc15_29.1, %.loc15_29.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc15_28: init %i32 = call %Negate.ref.loc15_22(%.loc15_29.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_43.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_28.1: %i32 = value_of_initializer %int.unegate.loc15_28 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_28.2: %i32 = converted %int.unegate.loc15_28, %.loc15_28.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_43.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_43.3: <bound method> = bound_method %.loc15_43.1, %.loc15_43.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc15_43.4: <specific function> = specific_function %.loc15_43.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc15_43: init %i32 = call %.loc15_43.4(%.loc15_43.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_43.5: %i32 = value_of_initializer %int.convert_checked.loc15_43 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_43.6: %i32 = converted %.loc15_43.1, %.loc15_43.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.usub.loc15: init %i32 = call %Sub.ref.loc15(%.loc15_28.2, %.loc15_43.6) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_29.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_29.3: <bound method> = bound_method %.loc15_29.1, %.loc15_29.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc15_29.4: <specific function> = specific_function %.loc15_29.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc15_29: init %i32 = call %.loc15_29.4(%.loc15_29.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_29.5: %i32 = value_of_initializer %int.convert_checked.loc15_29 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_29.6: %i32 = converted %.loc15_29.1, %.loc15_29.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc15_28: init %i32 = call %Negate.ref.loc15_22(%.loc15_29.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_43.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_28.1: %i32 = value_of_initializer %int.unegate.loc15_28 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_28.2: %i32 = converted %int.unegate.loc15_28, %.loc15_28.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_43.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_43.3: <bound method> = bound_method %.loc15_43.1, %.loc15_43.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_43.4: <specific function> = specific_function %.loc15_43.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc15_43: init %i32 = call %.loc15_43.4(%.loc15_43.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_43.5: %i32 = value_of_initializer %int.convert_checked.loc15_43 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_43.6: %i32 = converted %.loc15_43.1, %.loc15_43.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.usub.loc15: init %i32 = call %Sub.ref.loc15(%.loc15_28.2, %.loc15_43.6) [template = constants.%.36]
 // CHECK:STDOUT:   %Negate.ref.loc15_47: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc15_54.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_54.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_54.3: <bound method> = bound_method %.loc15_54.1, %.loc15_54.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc15_54.4: <specific function> = specific_function %.loc15_54.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc15_54: init %i32 = call %.loc15_54.4(%.loc15_54.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_54.5: %i32 = value_of_initializer %int.convert_checked.loc15_54 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc15_54.6: %i32 = converted %.loc15_54.1, %.loc15_54.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.unegate.loc15_53: init %i32 = call %Negate.ref.loc15_47(%.loc15_54.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc15_21.1: %i32 = value_of_initializer %int.usub.loc15 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc15_21.2: %i32 = converted %int.usub.loc15, %.loc15_21.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc15_53.1: %i32 = value_of_initializer %int.unegate.loc15_53 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc15_53.2: %i32 = converted %int.unegate.loc15_53, %.loc15_53.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.umod.loc15: init %i32 = call %Mod.ref.loc15(%.loc15_21.2, %.loc15_53.2) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc15_57.1: %i32 = value_of_initializer %int.umod.loc15 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc15_57.2: %i32 = converted %int.umod.loc15, %.loc15_57.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_54.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_54.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_54.3: <bound method> = bound_method %.loc15_54.1, %.loc15_54.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc15_54.4: <specific function> = specific_function %.loc15_54.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc15_54: init %i32 = call %.loc15_54.4(%.loc15_54.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_54.5: %i32 = value_of_initializer %int.convert_checked.loc15_54 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc15_54.6: %i32 = converted %.loc15_54.1, %.loc15_54.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.unegate.loc15_53: init %i32 = call %Negate.ref.loc15_47(%.loc15_54.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc15_21.1: %i32 = value_of_initializer %int.usub.loc15 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_21.2: %i32 = converted %int.usub.loc15, %.loc15_21.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_53.1: %i32 = value_of_initializer %int.unegate.loc15_53 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc15_53.2: %i32 = converted %int.unegate.loc15_53, %.loc15_53.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.umod.loc15: init %i32 = call %Mod.ref.loc15(%.loc15_21.2, %.loc15_53.2) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_57.1: %i32 = value_of_initializer %int.umod.loc15 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc15_57.2: %i32 = converted %int.umod.loc15, %.loc15_57.1 [template = constants.%.36]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc15_57.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -485,13 +485,13 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -555,18 +555,18 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref.loc12: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %.loc12_18.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc12_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc12_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_18.3: <bound method> = bound_method %.loc12_18.1, %.loc12_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc12_18.4: <specific function> = specific_function %.loc12_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc12_18: init %i32 = call %.loc12_18.4(%.loc12_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_18.5: %i32 = value_of_initializer %int.convert_checked.loc12_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_18.6: %i32 = converted %.loc12_18.1, %.loc12_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc12_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_21.3: <bound method> = bound_method %.loc12_21.1, %.loc12_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_21.4: <specific function> = specific_function %.loc12_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc12_21: init %i32 = call %.loc12_21.4(%.loc12_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_21.5: %i32 = value_of_initializer %int.convert_checked.loc12_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_21.6: %i32 = converted %.loc12_21.1, %.loc12_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_18.3: <bound method> = bound_method %.loc12_18.1, %.loc12_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc12_18.4: <specific function> = specific_function %.loc12_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc12_18: init %i32 = call %.loc12_18.4(%.loc12_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_18.5: %i32 = value_of_initializer %int.convert_checked.loc12_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_18.6: %i32 = converted %.loc12_18.1, %.loc12_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc12_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_21.3: <bound method> = bound_method %.loc12_21.1, %.loc12_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_21.4: <specific function> = specific_function %.loc12_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc12_21: init %i32 = call %.loc12_21.4(%.loc12_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_21.5: %i32 = value_of_initializer %int.convert_checked.loc12_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_21.6: %i32 = converted %.loc12_21.1, %.loc12_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.umod.loc12: init %i32 = call %Mod.ref.loc12(%.loc12_18.6, %.loc12_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc12_23.1: %i32 = value_of_initializer %int.umod.loc12 [template = <error>]
 // CHECK:STDOUT:   %.loc12_23.2: %i32 = converted %int.umod.loc12, %.loc12_23.1 [template = <error>]
@@ -574,18 +574,18 @@ let b: i32 = Mod(0, 0);
 // CHECK:STDOUT:   %Mod.ref.loc17: %Mod.type = name_ref Mod, file.%Mod.decl [template = constants.%Mod]
 // CHECK:STDOUT:   %.loc17_18.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc17_21.1: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc17_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_18.3: <bound method> = bound_method %.loc17_18.1, %.loc17_18.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc17_18.4: <specific function> = specific_function %.loc17_18.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc17_18: init %i32 = call %.loc17_18.4(%.loc17_18.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_18.5: %i32 = value_of_initializer %int.convert_checked.loc17_18 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_18.6: %i32 = converted %.loc17_18.1, %.loc17_18.5 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_21.3: <bound method> = bound_method %.loc17_21.1, %.loc17_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc17_21.4: <specific function> = specific_function %.loc17_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc17_21: init %i32 = call %.loc17_21.4(%.loc17_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_21.5: %i32 = value_of_initializer %int.convert_checked.loc17_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_21.6: %i32 = converted %.loc17_21.1, %.loc17_21.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc17_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_18.3: <bound method> = bound_method %.loc17_18.1, %.loc17_18.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc17_18.4: <specific function> = specific_function %.loc17_18.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc17_18: init %i32 = call %.loc17_18.4(%.loc17_18.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_18.5: %i32 = value_of_initializer %int.convert_checked.loc17_18 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_18.6: %i32 = converted %.loc17_18.1, %.loc17_18.5 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_21.3: <bound method> = bound_method %.loc17_21.1, %.loc17_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc17_21.4: <specific function> = specific_function %.loc17_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc17_21: init %i32 = call %.loc17_21.4(%.loc17_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_21.5: %i32 = value_of_initializer %int.convert_checked.loc17_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_21.6: %i32 = converted %.loc17_21.1, %.loc17_21.5 [template = constants.%.33]
 // CHECK:STDOUT:   %int.umod.loc17: init %i32 = call %Mod.ref.loc17(%.loc17_18.6, %.loc17_21.6) [template = <error>]
 // CHECK:STDOUT:   %.loc17_23.1: %i32 = value_of_initializer %int.umod.loc17 [template = <error>]
 // CHECK:STDOUT:   %.loc17_23.2: %i32 = converted %int.umod.loc17, %.loc17_23.1 [template = <error>]

toolchain/check/testdata/builtins/int/umul.carbon

@@ -43,22 +43,22 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 6 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 6 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 6 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 6 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -113,39 +113,39 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Mul.ref: %Mul.type = name_ref Mul, %Mul.decl [template = constants.%Mul]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.umul: init %i32 = call %Mul.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.umul: init %i32 = call %Mul.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.umul, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.umul [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.umul, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.umul, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.umul, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.umul [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.umul, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.umul, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 6 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -190,9 +190,9 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -210,19 +210,19 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 32767 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 65536 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2147418112 [template]
-// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 32768 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 32768 [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 32767 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 65536 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2147418112 [template]
+// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 32768 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.35, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 32768 [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -286,40 +286,40 @@ let b: i32 = Mul(0x8000, 0x10000);
 // CHECK:STDOUT:   %Mul.ref.loc6: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul]
 // CHECK:STDOUT:   %.loc6_18.1: Core.IntLiteral = int_value 32767 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_26.1: Core.IntLiteral = int_value 65536 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_26.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_26.3: <bound method> = bound_method %.loc6_26.1, %.loc6_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc6_26.4: <specific function> = specific_function %.loc6_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc6_26: init %i32 = call %.loc6_26.4(%.loc6_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_26.5: %i32 = value_of_initializer %int.convert_checked.loc6_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_26.6: %i32 = converted %.loc6_26.1, %.loc6_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.umul.loc6: init %i32 = call %Mul.ref.loc6(%.loc6_18.6, %.loc6_26.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_34.1: %i32 = value_of_initializer %int.umul.loc6 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_34.2: %i32 = converted %int.umul.loc6, %.loc6_34.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_26.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_26.3: <bound method> = bound_method %.loc6_26.1, %.loc6_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc6_26.4: <specific function> = specific_function %.loc6_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc6_26: init %i32 = call %.loc6_26.4(%.loc6_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_26.5: %i32 = value_of_initializer %int.convert_checked.loc6_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_26.6: %i32 = converted %.loc6_26.1, %.loc6_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.umul.loc6: init %i32 = call %Mul.ref.loc6(%.loc6_18.6, %.loc6_26.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_34.1: %i32 = value_of_initializer %int.umul.loc6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_34.2: %i32 = converted %int.umul.loc6, %.loc6_34.1 [template = constants.%.34]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc6_34.2
 // CHECK:STDOUT:   %Mul.ref.loc7: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul]
-// CHECK:STDOUT:   %.loc7_18.1: Core.IntLiteral = int_value 32768 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc7_18.1: Core.IntLiteral = int_value 32768 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc7_26.1: Core.IntLiteral = int_value 65536 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_18.3: <bound method> = bound_method %.loc7_18.1, %.loc7_18.2 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc7_18.4: <specific function> = specific_function %.loc7_18.3, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc7_18: init %i32 = call %.loc7_18.4(%.loc7_18.1) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_18.5: %i32 = value_of_initializer %int.convert_checked.loc7_18 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_18.6: %i32 = converted %.loc7_18.1, %.loc7_18.5 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_26.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_26.3: <bound method> = bound_method %.loc7_26.1, %.loc7_26.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc7_26.4: <specific function> = specific_function %.loc7_26.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc7_26: init %i32 = call %.loc7_26.4(%.loc7_26.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_26.5: %i32 = value_of_initializer %int.convert_checked.loc7_26 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_26.6: %i32 = converted %.loc7_26.1, %.loc7_26.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.umul.loc7: init %i32 = call %Mul.ref.loc7(%.loc7_18.6, %.loc7_26.6) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_34.1: %i32 = value_of_initializer %int.umul.loc7 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_34.2: %i32 = converted %int.umul.loc7, %.loc7_34.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc7_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_18.3: <bound method> = bound_method %.loc7_18.1, %.loc7_18.2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_18.4: <specific function> = specific_function %.loc7_18.3, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc7_18: init %i32 = call %.loc7_18.4(%.loc7_18.1) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_18.5: %i32 = value_of_initializer %int.convert_checked.loc7_18 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_18.6: %i32 = converted %.loc7_18.1, %.loc7_18.5 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_26.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_26.3: <bound method> = bound_method %.loc7_26.1, %.loc7_26.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc7_26.4: <specific function> = specific_function %.loc7_26.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc7_26: init %i32 = call %.loc7_26.4(%.loc7_26.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_26.5: %i32 = value_of_initializer %int.convert_checked.loc7_26 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_26.6: %i32 = converted %.loc7_26.1, %.loc7_26.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.umul.loc7: init %i32 = call %Mul.ref.loc7(%.loc7_18.6, %.loc7_26.6) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_34.1: %i32 = value_of_initializer %int.umul.loc7 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_34.2: %i32 = converted %int.umul.loc7, %.loc7_34.1 [template = constants.%.39]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc7_34.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/unegate.carbon

@@ -126,23 +126,23 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 123 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -123 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 123 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -123 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.25, %Convert.15 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.30: type = array_type %.2, %i32 [template]
-// CHECK:STDOUT:   %.31: type = ptr_type %.30 [template]
-// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.32, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value -1 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.29, %Convert.15 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.34: type = array_type %.2, %i32 [template]
+// CHECK:STDOUT:   %.35: type = ptr_type %.34 [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.36, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value -1 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -190,36 +190,36 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Negate.ref.loc4_16: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %Negate.ref.loc4_23: %Negate.type = name_ref Negate, %Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc4_30.1: Core.IntLiteral = int_value 123 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc4_30.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_30.3: <bound method> = bound_method %.loc4_30.1, %.loc4_30.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc4_30.4: <specific function> = specific_function %.loc4_30.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc4_30: init %i32 = call %.loc4_30.4(%.loc4_30.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc4_30.5: %i32 = value_of_initializer %int.convert_checked.loc4_30 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc4_30.6: %i32 = converted %.loc4_30.1, %.loc4_30.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc4_29: init %i32 = call %Negate.ref.loc4_23(%.loc4_30.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_29.1: %i32 = value_of_initializer %int.unegate.loc4_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_29.2: %i32 = converted %int.unegate.loc4_29, %.loc4_29.1 [template = constants.%.26]
-// CHECK:STDOUT:   %int.unegate.loc4_22: init %i32 = call %Negate.ref.loc4_16(%.loc4_29.2) [template = constants.%.25]
+// CHECK:STDOUT:   %.loc4_30.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_30.3: <bound method> = bound_method %.loc4_30.1, %.loc4_30.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc4_30.4: <specific function> = specific_function %.loc4_30.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc4_30: init %i32 = call %.loc4_30.4(%.loc4_30.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_30.5: %i32 = value_of_initializer %int.convert_checked.loc4_30 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_30.6: %i32 = converted %.loc4_30.1, %.loc4_30.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc4_29: init %i32 = call %Negate.ref.loc4_23(%.loc4_30.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_29.1: %i32 = value_of_initializer %int.unegate.loc4_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_29.2: %i32 = converted %int.unegate.loc4_29, %.loc4_29.1 [template = constants.%.30]
+// CHECK:STDOUT:   %int.unegate.loc4_22: init %i32 = call %Negate.ref.loc4_16(%.loc4_29.2) [template = constants.%.29]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_22.1: %Convert.type.6 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_22.2: <bound method> = bound_method %int.unegate.loc4_22, %.loc4_22.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc4_22.3: <specific function> = specific_function %.loc4_22.2, @Convert.4(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_22.4: %i32 = value_of_initializer %int.unegate.loc4_22 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc4_22.5: %i32 = converted %int.unegate.loc4_22, %.loc4_22.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc4_22.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_22.2: <bound method> = bound_method %int.unegate.loc4_22, %.loc4_22.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc4_22.3: <specific function> = specific_function %.loc4_22.2, @Convert.4(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_22.4: %i32 = value_of_initializer %int.unegate.loc4_22 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_22.5: %i32 = converted %int.unegate.loc4_22, %.loc4_22.4 [template = constants.%.29]
 // CHECK:STDOUT:   %int.convert_checked.loc4_22: init Core.IntLiteral = call %.loc4_22.3(%.loc4_22.5) [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_22.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_22 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_22.7: Core.IntLiteral = converted %int.unegate.loc4_22, %.loc4_22.6 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc4_35: type = array_type %.loc4_22.7, %i32 [template = constants.%.30]
-// CHECK:STDOUT:   %arr.var: ref %.30 = var arr
-// CHECK:STDOUT:   %arr: ref %.30 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_35: type = array_type %.loc4_22.7, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %arr.var: ref %.34 = var arr
+// CHECK:STDOUT:   %arr: ref %.34 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 123 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_21: type = array_type %.loc5_18, %i32 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc5_22: type = ptr_type %.30 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc5_21: type = array_type %.loc5_18, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_22: type = ptr_type %.34 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc7_8.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc7: init type = call constants.%Int(%.loc7_8.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc7_8.2: type = value_of_initializer %int.make_type_signed.loc7 [template = constants.%i32]
@@ -267,20 +267,20 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.30 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.31 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.31 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.34 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.35 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.35 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
-// CHECK:STDOUT:   %.loc7_21.1: Core.IntLiteral = int_value 1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc7_21.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_21.3: <bound method> = bound_method %.loc7_21.1, %.loc7_21.2 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc7_21.4: <specific function> = specific_function %.loc7_21.3, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc7_21.4(%.loc7_21.1) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_21.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_21.6: %i32 = converted %.loc7_21.1, %.loc7_21.5 [template = constants.%.35]
-// CHECK:STDOUT:   %int.unegate: init %i32 = call %Negate.ref(%.loc7_21.6) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc7_23.1: %i32 = value_of_initializer %int.unegate [template = constants.%.36]
-// CHECK:STDOUT:   %.loc7_23.2: %i32 = converted %int.unegate, %.loc7_23.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_21.1: Core.IntLiteral = int_value 1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_21.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_21.3: <bound method> = bound_method %.loc7_21.1, %.loc7_21.2 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc7_21.4: <specific function> = specific_function %.loc7_21.3, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc7_21.4(%.loc7_21.1) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_21.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_21.6: %i32 = converted %.loc7_21.1, %.loc7_21.5 [template = constants.%.39]
+// CHECK:STDOUT:   %int.unegate: init %i32 = call %Negate.ref(%.loc7_21.6) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc7_23.1: %i32 = value_of_initializer %int.unegate [template = constants.%.40]
+// CHECK:STDOUT:   %.loc7_23.2: %i32 = converted %int.unegate, %.loc7_23.1 [template = constants.%.40]
 // CHECK:STDOUT:   %n: %i32 = bind_name n, %.loc7_23.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -307,13 +307,13 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template]
 // CHECK:STDOUT:   %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template]
 // CHECK:STDOUT:   %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template]
@@ -436,18 +436,18 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %TooMany.ref: %TooMany.type = name_ref TooMany, %TooMany.decl [template = constants.%TooMany]
 // CHECK:STDOUT:   %.loc30_29.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc30_32.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc30_29.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_29.3: <bound method> = bound_method %.loc30_29.1, %.loc30_29.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc30_29.4: <specific function> = specific_function %.loc30_29.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc30_29: init %i32 = call %.loc30_29.4(%.loc30_29.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_29.5: %i32 = value_of_initializer %int.convert_checked.loc30_29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_29.6: %i32 = converted %.loc30_29.1, %.loc30_29.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc30_32.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_32.3: <bound method> = bound_method %.loc30_32.1, %.loc30_32.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc30_32.4: <specific function> = specific_function %.loc30_32.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc30_32: init %i32 = call %.loc30_32.4(%.loc30_32.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc30_32.5: %i32 = value_of_initializer %int.convert_checked.loc30_32 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc30_32.6: %i32 = converted %.loc30_32.1, %.loc30_32.5 [template = constants.%.33]
 // CHECK:STDOUT:   %TooMany.call: init %i32 = call %TooMany.ref(%.loc30_29.6, %.loc30_32.6)
 // CHECK:STDOUT:   %.loc30_16.2: type = value_of_initializer %int.make_type_signed.loc30 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc30_16.3: type = converted %int.make_type_signed.loc30, %.loc30_16.2 [template = constants.%i32]
@@ -457,12 +457,12 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %int.make_type_signed.loc35: init type = call constants.%Int(%.loc35_23.1) [template = constants.%i32]
 // CHECK:STDOUT:   %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, %BadReturnType.decl [template = constants.%BadReturnType]
 // CHECK:STDOUT:   %.loc35_42.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc35: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc35_42.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_42.3: <bound method> = bound_method %.loc35_42.1, %.loc35_42.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc35_42.4: <specific function> = specific_function %.loc35_42.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc35: init %i32 = call %.loc35_42.4(%.loc35_42.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_42.5: %i32 = value_of_initializer %int.convert_checked.loc35 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc35_42.6: %i32 = converted %.loc35_42.1, %.loc35_42.5 [template = constants.%.30]
 // CHECK:STDOUT:   %BadReturnType.call: init bool = call %BadReturnType.ref(%.loc35_42.6)
 // CHECK:STDOUT:   %.loc35_23.2: type = value_of_initializer %int.make_type_signed.loc35 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc35_23.3: type = converted %int.make_type_signed.loc35, %.loc35_23.2 [template = constants.%i32]
@@ -607,16 +607,16 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value -2147483648 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -702,45 +702,45 @@ let b: i32 = Negate(Sub(Negate(0x7FFFFFFF), 1));
 // CHECK:STDOUT:   %Negate.ref.loc8_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %Negate.ref.loc8_21: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc8_28.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc8_28.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_28.3: <bound method> = bound_method %.loc8_28.1, %.loc8_28.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc8_28.4: <specific function> = specific_function %.loc8_28.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_28.4(%.loc8_28.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_28.5: %i32 = value_of_initializer %int.convert_checked.loc8 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_28.6: %i32 = converted %.loc8_28.1, %.loc8_28.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc8_27: init %i32 = call %Negate.ref.loc8_21(%.loc8_28.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_27.1: %i32 = value_of_initializer %int.unegate.loc8_27 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_27.2: %i32 = converted %int.unegate.loc8_27, %.loc8_27.1 [template = constants.%.26]
-// CHECK:STDOUT:   %int.unegate.loc8_20: init %i32 = call %Negate.ref.loc8_14(%.loc8_27.2) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_40.1: %i32 = value_of_initializer %int.unegate.loc8_20 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_40.2: %i32 = converted %int.unegate.loc8_20, %.loc8_40.1 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc8_28.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_28.3: <bound method> = bound_method %.loc8_28.1, %.loc8_28.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc8_28.4: <specific function> = specific_function %.loc8_28.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_28.4(%.loc8_28.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_28.5: %i32 = value_of_initializer %int.convert_checked.loc8 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_28.6: %i32 = converted %.loc8_28.1, %.loc8_28.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc8_27: init %i32 = call %Negate.ref.loc8_21(%.loc8_28.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_27.1: %i32 = value_of_initializer %int.unegate.loc8_27 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_27.2: %i32 = converted %int.unegate.loc8_27, %.loc8_27.1 [template = constants.%.30]
+// CHECK:STDOUT:   %int.unegate.loc8_20: init %i32 = call %Negate.ref.loc8_14(%.loc8_27.2) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_40.1: %i32 = value_of_initializer %int.unegate.loc8_20 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_40.2: %i32 = converted %int.unegate.loc8_20, %.loc8_40.1 [template = constants.%.29]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc8_40.2
 // CHECK:STDOUT:   %Negate.ref.loc11_14: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %Sub.ref: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Negate.ref.loc11_25: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate]
 // CHECK:STDOUT:   %.loc11_32.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc11_32.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_32.3: <bound method> = bound_method %.loc11_32.1, %.loc11_32.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc11_32.4: <specific function> = specific_function %.loc11_32.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc11_32: init %i32 = call %.loc11_32.4(%.loc11_32.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_32.5: %i32 = value_of_initializer %int.convert_checked.loc11_32 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_32.6: %i32 = converted %.loc11_32.1, %.loc11_32.5 [template = constants.%.25]
-// CHECK:STDOUT:   %int.unegate.loc11_31: init %i32 = call %Negate.ref.loc11_25(%.loc11_32.6) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_45.1: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_31.1: %i32 = value_of_initializer %int.unegate.loc11_31 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_31.2: %i32 = converted %int.unegate.loc11_31, %.loc11_31.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc11_45.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_45.3: <bound method> = bound_method %.loc11_45.1, %.loc11_45.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_45.4: <specific function> = specific_function %.loc11_45.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc11_45: init %i32 = call %.loc11_45.4(%.loc11_45.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_45.5: %i32 = value_of_initializer %int.convert_checked.loc11_45 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_45.6: %i32 = converted %.loc11_45.1, %.loc11_45.5 [template = constants.%.30]
-// CHECK:STDOUT:   %int.usub: init %i32 = call %Sub.ref(%.loc11_31.2, %.loc11_45.6) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_24.1: %i32 = value_of_initializer %int.usub [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_24.2: %i32 = converted %int.usub, %.loc11_24.1 [template = constants.%.31]
-// CHECK:STDOUT:   %int.unegate.loc11_20: init %i32 = call %Negate.ref.loc11_14(%.loc11_24.2) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_48.1: %i32 = value_of_initializer %int.unegate.loc11_20 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc11_48.2: %i32 = converted %int.unegate.loc11_20, %.loc11_48.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_32.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_32.3: <bound method> = bound_method %.loc11_32.1, %.loc11_32.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11_32.4: <specific function> = specific_function %.loc11_32.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc11_32: init %i32 = call %.loc11_32.4(%.loc11_32.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_32.5: %i32 = value_of_initializer %int.convert_checked.loc11_32 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_32.6: %i32 = converted %.loc11_32.1, %.loc11_32.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.unegate.loc11_31: init %i32 = call %Negate.ref.loc11_25(%.loc11_32.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_45.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_31.1: %i32 = value_of_initializer %int.unegate.loc11_31 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_31.2: %i32 = converted %int.unegate.loc11_31, %.loc11_31.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_45.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_45.3: <bound method> = bound_method %.loc11_45.1, %.loc11_45.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_45.4: <specific function> = specific_function %.loc11_45.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc11_45: init %i32 = call %.loc11_45.4(%.loc11_45.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_45.5: %i32 = value_of_initializer %int.convert_checked.loc11_45 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_45.6: %i32 = converted %.loc11_45.1, %.loc11_45.5 [template = constants.%.34]
+// CHECK:STDOUT:   %int.usub: init %i32 = call %Sub.ref(%.loc11_31.2, %.loc11_45.6) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_24.1: %i32 = value_of_initializer %int.usub [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_24.2: %i32 = converted %int.usub, %.loc11_24.1 [template = constants.%.35]
+// CHECK:STDOUT:   %int.unegate.loc11_20: init %i32 = call %Negate.ref.loc11_14(%.loc11_24.2) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_48.1: %i32 = value_of_initializer %int.unegate.loc11_20 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc11_48.2: %i32 = converted %int.unegate.loc11_20, %.loc11_48.1 [template = constants.%.35]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc11_48.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/usub.carbon

@@ -44,22 +44,22 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -114,39 +114,39 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Sub.ref: %Sub.type = name_ref Sub, %Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 3 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.usub: init %i32 = call %Sub.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_23.3: <bound method> = bound_method %.loc4_23.1, %.loc4_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_23.4: <specific function> = specific_function %.loc4_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_23: init %i32 = call %.loc4_23.4(%.loc4_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.5: %i32 = value_of_initializer %int.convert_checked.loc4_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_23.6: %i32 = converted %.loc4_23.1, %.loc4_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.usub: init %i32 = call %Sub.ref(%.loc4_20.6, %.loc4_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.usub, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.usub [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.usub, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.usub, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.usub, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.usub [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.usub, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.usub, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_25: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 1 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -191,9 +191,9 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -211,23 +211,23 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2147483647 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value -2147483647 [template]
-// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value -2147483648 [template]
-// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.36, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2147483647 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value -2147483647 [template]
+// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.35, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value -2147483648 [template]
+// CHECK:STDOUT:   %.40: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.40, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -296,81 +296,81 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2);
 // CHECK:STDOUT:   %Sub.ref.loc6: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc6_18.1: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc6_21.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_21.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_21.3: <bound method> = bound_method %.loc6_21.1, %.loc6_21.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc6_21.4: <specific function> = specific_function %.loc6_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc6_21: init %i32 = call %.loc6_21.4(%.loc6_21.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_21.5: %i32 = value_of_initializer %int.convert_checked.loc6_21 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc6_21.6: %i32 = converted %.loc6_21.1, %.loc6_21.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.usub.loc6: init %i32 = call %Sub.ref.loc6(%.loc6_18.6, %.loc6_21.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_32.1: %i32 = value_of_initializer %int.usub.loc6 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc6_32.2: %i32 = converted %int.usub.loc6, %.loc6_32.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_18.3: <bound method> = bound_method %.loc6_18.1, %.loc6_18.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc6_18.4: <specific function> = specific_function %.loc6_18.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc6_18: init %i32 = call %.loc6_18.4(%.loc6_18.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.5: %i32 = value_of_initializer %int.convert_checked.loc6_18 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_18.6: %i32 = converted %.loc6_18.1, %.loc6_18.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_21.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_21.3: <bound method> = bound_method %.loc6_21.1, %.loc6_21.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc6_21.4: <specific function> = specific_function %.loc6_21.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc6_21: init %i32 = call %.loc6_21.4(%.loc6_21.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_21.5: %i32 = value_of_initializer %int.convert_checked.loc6_21 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc6_21.6: %i32 = converted %.loc6_21.1, %.loc6_21.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.usub.loc6: init %i32 = call %Sub.ref.loc6(%.loc6_18.6, %.loc6_21.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_32.1: %i32 = value_of_initializer %int.usub.loc6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc6_32.2: %i32 = converted %int.usub.loc6, %.loc6_32.1 [template = constants.%.34]
 // CHECK:STDOUT:   %a: %i32 = bind_name a, %.loc6_32.2
 // CHECK:STDOUT:   %Sub.ref.loc7_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Sub.ref.loc7_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc7_22.1: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc7_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc7_22.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_22.3: <bound method> = bound_method %.loc7_22.1, %.loc7_22.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc7_22.4: <specific function> = specific_function %.loc7_22.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc7_22: init %i32 = call %.loc7_22.4(%.loc7_22.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_22.5: %i32 = value_of_initializer %int.convert_checked.loc7_22 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_22.6: %i32 = converted %.loc7_22.1, %.loc7_22.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc7_25.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_25.3: <bound method> = bound_method %.loc7_25.1, %.loc7_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc7_25.4: <specific function> = specific_function %.loc7_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc7_25: init %i32 = call %.loc7_25.4(%.loc7_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_25.5: %i32 = value_of_initializer %int.convert_checked.loc7_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc7_25.6: %i32 = converted %.loc7_25.1, %.loc7_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.usub.loc7_21: init %i32 = call %Sub.ref.loc7_18(%.loc7_22.6, %.loc7_25.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc7_38.1: Core.IntLiteral = int_value 1 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc7_21.1: %i32 = value_of_initializer %int.usub.loc7_21 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc7_21.2: %i32 = converted %int.usub.loc7_21, %.loc7_21.1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc7_38.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_38.3: <bound method> = bound_method %.loc7_38.1, %.loc7_38.2 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc7_38.4: <specific function> = specific_function %.loc7_38.3, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc7_38: init %i32 = call %.loc7_38.4(%.loc7_38.1) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_38.5: %i32 = value_of_initializer %int.convert_checked.loc7_38 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_38.6: %i32 = converted %.loc7_38.1, %.loc7_38.5 [template = constants.%.34]
-// CHECK:STDOUT:   %int.usub.loc7_17: init %i32 = call %Sub.ref.loc7_14(%.loc7_21.2, %.loc7_38.6) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_40.1: %i32 = value_of_initializer %int.usub.loc7_17 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc7_40.2: %i32 = converted %int.usub.loc7_17, %.loc7_40.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc7_22.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_22.3: <bound method> = bound_method %.loc7_22.1, %.loc7_22.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc7_22.4: <specific function> = specific_function %.loc7_22.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc7_22: init %i32 = call %.loc7_22.4(%.loc7_22.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_22.5: %i32 = value_of_initializer %int.convert_checked.loc7_22 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_22.6: %i32 = converted %.loc7_22.1, %.loc7_22.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc7_25.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_25.3: <bound method> = bound_method %.loc7_25.1, %.loc7_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc7_25.4: <specific function> = specific_function %.loc7_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc7_25: init %i32 = call %.loc7_25.4(%.loc7_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_25.5: %i32 = value_of_initializer %int.convert_checked.loc7_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc7_25.6: %i32 = converted %.loc7_25.1, %.loc7_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.usub.loc7_21: init %i32 = call %Sub.ref.loc7_18(%.loc7_22.6, %.loc7_25.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc7_38.1: Core.IntLiteral = int_value 1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc7_21.1: %i32 = value_of_initializer %int.usub.loc7_21 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc7_21.2: %i32 = converted %int.usub.loc7_21, %.loc7_21.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc7_38.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_38.3: <bound method> = bound_method %.loc7_38.1, %.loc7_38.2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_38.4: <specific function> = specific_function %.loc7_38.3, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc7_38: init %i32 = call %.loc7_38.4(%.loc7_38.1) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_38.5: %i32 = value_of_initializer %int.convert_checked.loc7_38 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_38.6: %i32 = converted %.loc7_38.1, %.loc7_38.5 [template = constants.%.38]
+// CHECK:STDOUT:   %int.usub.loc7_17: init %i32 = call %Sub.ref.loc7_14(%.loc7_21.2, %.loc7_38.6) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_40.1: %i32 = value_of_initializer %int.usub.loc7_17 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_40.2: %i32 = converted %int.usub.loc7_17, %.loc7_40.1 [template = constants.%.39]
 // CHECK:STDOUT:   %b: %i32 = bind_name b, %.loc7_40.2
 // CHECK:STDOUT:   %Sub.ref.loc8_14: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %Sub.ref.loc8_18: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub]
 // CHECK:STDOUT:   %.loc8_22.1: Core.IntLiteral = int_value 0 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc8_25.1: Core.IntLiteral = int_value 2147483647 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc8_22.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_22.3: <bound method> = bound_method %.loc8_22.1, %.loc8_22.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc8_22.4: <specific function> = specific_function %.loc8_22.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc8_22: init %i32 = call %.loc8_22.4(%.loc8_22.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_22.5: %i32 = value_of_initializer %int.convert_checked.loc8_22 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_22.6: %i32 = converted %.loc8_22.1, %.loc8_22.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc8_25.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_25.3: <bound method> = bound_method %.loc8_25.1, %.loc8_25.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc8_25.4: <specific function> = specific_function %.loc8_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc8_25: init %i32 = call %.loc8_25.4(%.loc8_25.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_25.5: %i32 = value_of_initializer %int.convert_checked.loc8_25 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_25.6: %i32 = converted %.loc8_25.1, %.loc8_25.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.usub.loc8_21: init %i32 = call %Sub.ref.loc8_18(%.loc8_22.6, %.loc8_25.6) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_38.1: Core.IntLiteral = int_value 2 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc8_21.1: %i32 = value_of_initializer %int.usub.loc8_21 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_21.2: %i32 = converted %int.usub.loc8_21, %.loc8_21.1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc8_38.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_38.3: <bound method> = bound_method %.loc8_38.1, %.loc8_38.2 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc8_38.4: <specific function> = specific_function %.loc8_38.3, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc8_38: init %i32 = call %.loc8_38.4(%.loc8_38.1) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc8_38.5: %i32 = value_of_initializer %int.convert_checked.loc8_38 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc8_38.6: %i32 = converted %.loc8_38.1, %.loc8_38.5 [template = constants.%.39]
-// CHECK:STDOUT:   %int.usub.loc8_17: init %i32 = call %Sub.ref.loc8_14(%.loc8_21.2, %.loc8_38.6) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_40.1: %i32 = value_of_initializer %int.usub.loc8_17 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc8_40.2: %i32 = converted %int.usub.loc8_17, %.loc8_40.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_22.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_22.3: <bound method> = bound_method %.loc8_22.1, %.loc8_22.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc8_22.4: <specific function> = specific_function %.loc8_22.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc8_22: init %i32 = call %.loc8_22.4(%.loc8_22.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_22.5: %i32 = value_of_initializer %int.convert_checked.loc8_22 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_22.6: %i32 = converted %.loc8_22.1, %.loc8_22.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc8_25.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_25.3: <bound method> = bound_method %.loc8_25.1, %.loc8_25.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc8_25.4: <specific function> = specific_function %.loc8_25.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc8_25: init %i32 = call %.loc8_25.4(%.loc8_25.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_25.5: %i32 = value_of_initializer %int.convert_checked.loc8_25 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_25.6: %i32 = converted %.loc8_25.1, %.loc8_25.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.usub.loc8_21: init %i32 = call %Sub.ref.loc8_18(%.loc8_22.6, %.loc8_25.6) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_38.1: Core.IntLiteral = int_value 2 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc8_21.1: %i32 = value_of_initializer %int.usub.loc8_21 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_21.2: %i32 = converted %int.usub.loc8_21, %.loc8_21.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc8_38.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_38.3: <bound method> = bound_method %.loc8_38.1, %.loc8_38.2 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc8_38.4: <specific function> = specific_function %.loc8_38.3, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc8_38: init %i32 = call %.loc8_38.4(%.loc8_38.1) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc8_38.5: %i32 = value_of_initializer %int.convert_checked.loc8_38 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc8_38.6: %i32 = converted %.loc8_38.1, %.loc8_38.5 [template = constants.%.43]
+// CHECK:STDOUT:   %int.usub.loc8_17: init %i32 = call %Sub.ref.loc8_14(%.loc8_21.2, %.loc8_38.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_40.1: %i32 = value_of_initializer %int.usub.loc8_17 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc8_40.2: %i32 = converted %int.usub.loc8_17, %.loc8_40.1 [template = constants.%.33]
 // CHECK:STDOUT:   %c: %i32 = bind_name c, %.loc8_40.2
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/builtins/int/xor.carbon

@@ -34,22 +34,22 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 12 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 10 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 6 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 12 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 10 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 6 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 6 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %.35 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 6 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %.39 [template]
 // CHECK:STDOUT:   %RuntimeCall.type: type = fn_type @RuntimeCall [template]
 // CHECK:STDOUT:   %RuntimeCall: %RuntimeCall.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -104,39 +104,39 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:   %Xor.ref: %Xor.type = name_ref Xor, %Xor.decl [template = constants.%Xor]
 // CHECK:STDOUT:   %.loc4_20.1: Core.IntLiteral = int_value 12 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_24.1: Core.IntLiteral = int_value 10 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc4_24.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc4_24.3: <bound method> = bound_method %.loc4_24.1, %.loc4_24.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_24.4: <specific function> = specific_function %.loc4_24.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc4_24: init %i32 = call %.loc4_24.4(%.loc4_24.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_24.5: %i32 = value_of_initializer %int.convert_checked.loc4_24 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc4_24.6: %i32 = converted %.loc4_24.1, %.loc4_24.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.xor: init %i32 = call %Xor.ref(%.loc4_20.6, %.loc4_24.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_20.3: <bound method> = bound_method %.loc4_20.1, %.loc4_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_20.4: <specific function> = specific_function %.loc4_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_20: init %i32 = call %.loc4_20.4(%.loc4_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.5: %i32 = value_of_initializer %int.convert_checked.loc4_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_20.6: %i32 = converted %.loc4_20.1, %.loc4_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc4_24.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc4_24.3: <bound method> = bound_method %.loc4_24.1, %.loc4_24.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_24.4: <specific function> = specific_function %.loc4_24.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc4_24: init %i32 = call %.loc4_24.4(%.loc4_24.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_24.5: %i32 = value_of_initializer %int.convert_checked.loc4_24 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_24.6: %i32 = converted %.loc4_24.1, %.loc4_24.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.xor: init %i32 = call %Xor.ref(%.loc4_20.6, %.loc4_24.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.xor, %.loc4_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.xor [template = constants.%.30]
-// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.xor, %.loc4_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.xor, %.loc4_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_27: type = array_type %.loc4_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %int.xor, %.loc4_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_19.3: <specific function> = specific_function %.loc4_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = value_of_initializer %int.xor [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_19.5: %i32 = converted %int.xor, %.loc4_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init Core.IntLiteral = call %.loc4_19.3(%.loc4_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_19.7: Core.IntLiteral = converted %int.xor, %.loc4_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc4_27: type = array_type %.loc4_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT:   %.loc5_13.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_13.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc5_18: Core.IntLiteral = int_value 6 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc5_13.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_13.3: type = converted %int.make_type_signed.loc5, %.loc5_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.35 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc5_19: type = array_type %.loc5_18, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc5_20: type = ptr_type %.39 [template = constants.%.40]
 // CHECK:STDOUT:   %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] {
 // CHECK:STDOUT:     %a.patt: %i32 = binding_pattern a
 // CHECK:STDOUT:     %a.param_patt: %i32 = value_param_pattern %a.patt, runtime_param0
@@ -181,9 +181,9 @@ fn RuntimeCall(a: i32, b: i32) -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %arr.ref: ref %.35 = name_ref arr, file.%arr
-// CHECK:STDOUT:   %.loc5: %.36 = addr_of %arr.ref
-// CHECK:STDOUT:   %arr_p: %.36 = bind_name arr_p, %.loc5
+// CHECK:STDOUT:   %arr.ref: ref %.39 = name_ref arr, file.%arr
+// CHECK:STDOUT:   %.loc5: %.40 = addr_of %arr.ref
+// CHECK:STDOUT:   %arr_p: %.40 = bind_name arr_p, %.loc5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/builtins/print.carbon

@@ -32,16 +32,16 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %Print.type.2: type = fn_type @Print.2 [template]
 // CHECK:STDOUT:   %Print.2: %Print.type.2 = struct_value () [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.26, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -82,22 +82,22 @@ fn Main() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %Print.ref.loc14: %Print.type.1 = name_ref Print, file.%Print.decl [template = constants.%Print.1]
 // CHECK:STDOUT:   %.loc14_9.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc14_9.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_9.3: <bound method> = bound_method %.loc14_9.1, %.loc14_9.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc14_9.4: <specific function> = specific_function %.loc14_9.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_9.4(%.loc14_9.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_9.5: %i32 = value_of_initializer %int.convert_checked.loc14 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_9.6: %i32 = converted %.loc14_9.1, %.loc14_9.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc14_9.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_9.3: <bound method> = bound_method %.loc14_9.1, %.loc14_9.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc14_9.4: <specific function> = specific_function %.loc14_9.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_9.4(%.loc14_9.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_9.5: %i32 = value_of_initializer %int.convert_checked.loc14 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_9.6: %i32 = converted %.loc14_9.1, %.loc14_9.5 [template = constants.%.29]
 // CHECK:STDOUT:   %print.int.loc14: init %empty_tuple.type = call %Print.ref.loc14(%.loc14_9.6)
 // CHECK:STDOUT:   %Core.ref: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
 // CHECK:STDOUT:   %Print.ref.loc16: %Print.type.2 = name_ref Print, imports.%import_ref.38 [template = constants.%Print.2]
-// CHECK:STDOUT:   %.loc16_14.1: Core.IntLiteral = int_value 2 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc16_14.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_14.3: <bound method> = bound_method %.loc16_14.1, %.loc16_14.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc16_14.4: <specific function> = specific_function %.loc16_14.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc16: init %i32 = call %.loc16_14.4(%.loc16_14.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc16_14.5: %i32 = value_of_initializer %int.convert_checked.loc16 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc16_14.6: %i32 = converted %.loc16_14.1, %.loc16_14.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc16_14.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc16_14.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_14.3: <bound method> = bound_method %.loc16_14.1, %.loc16_14.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc16_14.4: <specific function> = specific_function %.loc16_14.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc16: init %i32 = call %.loc16_14.4(%.loc16_14.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc16_14.5: %i32 = value_of_initializer %int.convert_checked.loc16 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc16_14.6: %i32 = converted %.loc16_14.1, %.loc16_14.5 [template = constants.%.33]
 // CHECK:STDOUT:   %print.int.loc16: init %empty_tuple.type = call %Print.ref.loc16(%.loc16_14.6)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/class/access_modifers.carbon

@@ -158,22 +158,22 @@ class A {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 5 [template]
 // CHECK:STDOUT:   %SomeInternalFunction.type: type = fn_type @SomeInternalFunction [template]
 // CHECK:STDOUT:   %SomeInternalFunction: %SomeInternalFunction.type = struct_value () [template]
 // CHECK:STDOUT:   %Make.type: type = fn_type @Make [template]
 // CHECK:STDOUT:   %Make: %Make.type = struct_value () [template]
-// CHECK:STDOUT:   %.27: type = struct_type {.radius: %i32} [template]
-// CHECK:STDOUT:   %.28: <witness> = complete_type_witness %.27 [template]
-// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.29, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.34: type = struct_type {.radius: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %struct: %Circle = struct_value (%.26) [template]
+// CHECK:STDOUT:   %.31: type = struct_type {.radius: %i32} [template]
+// CHECK:STDOUT:   %.32: <witness> = complete_type_witness %.31 [template]
+// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.33, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.38: type = struct_type {.radius: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %struct: %Circle = struct_value (%.30) [template]
 // CHECK:STDOUT:   %Run.type: type = fn_type @Run [template]
 // CHECK:STDOUT:   %Run: %Run.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -209,12 +209,12 @@ class A {
 // CHECK:STDOUT:   %.loc6_39.2: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_39.3: type = converted %int.make_type_signed.loc6, %.loc6_39.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_45: Core.IntLiteral = int_value 5 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc6_46.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_46.2: <bound method> = bound_method %.loc6_45, %.loc6_46.1 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc6_46.3: <specific function> = specific_function %.loc6_46.2, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc6_46.3(%.loc6_45) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_46.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_46.5: %i32 = converted %.loc6_45, %.loc6_46.4 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc6_46.1: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_46.2: <bound method> = bound_method %.loc6_45, %.loc6_46.1 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc6_46.3: <specific function> = specific_function %.loc6_46.2, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc6_46.3(%.loc6_45) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_46.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_46.5: %i32 = converted %.loc6_45, %.loc6_46.4 [template = constants.%.30]
 // CHECK:STDOUT:   %SOME_INTERNAL_CONSTANT: %i32 = bind_name SOME_INTERNAL_CONSTANT, %.loc6_46.5
 // CHECK:STDOUT:   %SomeInternalFunction.decl: %SomeInternalFunction.type = fn_decl @SomeInternalFunction [template = constants.%SomeInternalFunction] {
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
@@ -235,7 +235,7 @@ class A {
 // CHECK:STDOUT:     %return.param: ref %Circle = out_param runtime_param0
 // CHECK:STDOUT:     %return: ref %Circle = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc15: <witness> = complete_type_witness %.27 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc15: <witness> = complete_type_witness %.31 [template = constants.%.32]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%Circle
@@ -247,27 +247,27 @@ class A {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @SomeInternalFunction() -> %i32 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc9_12: Core.IntLiteral = int_value 0 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc9_13.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_13.2: <bound method> = bound_method %.loc9_12, %.loc9_13.1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_13.3: <specific function> = specific_function %.loc9_13.2, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc9_13.3(%.loc9_12) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_13.5: %i32 = converted %.loc9_12, %.loc9_13.4 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_12: Core.IntLiteral = int_value 0 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc9_13.1: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_13.2: <bound method> = bound_method %.loc9_12, %.loc9_13.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_13.3: <specific function> = specific_function %.loc9_13.2, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc9_13.3(%.loc9_12) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_13.5: %i32 = converted %.loc9_12, %.loc9_13.4 [template = constants.%.36]
 // CHECK:STDOUT:   return %.loc9_13.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Make() -> %return: %Circle {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc13_23: Core.IntLiteral = int_value 5 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc13_24.1: %.34 = struct_literal (%.loc13_23)
-// CHECK:STDOUT:   %.loc13_24.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_24.3: <bound method> = bound_method %.loc13_23, %.loc13_24.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc13_24.4: <specific function> = specific_function %.loc13_24.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc13_24.4(%.loc13_23) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_24.5: init %i32 = converted %.loc13_23, %int.convert_checked [template = constants.%.26]
+// CHECK:STDOUT:   %.loc13_24.1: %.38 = struct_literal (%.loc13_23)
+// CHECK:STDOUT:   %.loc13_24.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_24.3: <bound method> = bound_method %.loc13_23, %.loc13_24.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_24.4: <specific function> = specific_function %.loc13_24.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc13_24.4(%.loc13_23) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_24.5: init %i32 = converted %.loc13_23, %int.convert_checked [template = constants.%.30]
 // CHECK:STDOUT:   %.loc13_24.6: ref %i32 = class_element_access %return, element0
-// CHECK:STDOUT:   %.loc13_24.7: init %i32 = initialize_from %.loc13_24.5 to %.loc13_24.6 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc13_24.7: init %i32 = initialize_from %.loc13_24.5 to %.loc13_24.6 [template = constants.%.30]
 // CHECK:STDOUT:   %.loc13_24.8: init %Circle = class_init (%.loc13_24.7), %return [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_25: init %Circle = converted %.loc13_24.1, %.loc13_24.8 [template = constants.%struct]
 // CHECK:STDOUT:   return %.loc13_25 to %return
@@ -381,10 +381,10 @@ class A {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -476,12 +476,12 @@ class A {
 // CHECK:STDOUT: fn @SomeInternalFunction() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc12_12: Core.IntLiteral = int_value 0 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc12_13.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc12_13.2: <bound method> = bound_method %.loc12_12, %.loc12_13.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc12_13.3: <specific function> = specific_function %.loc12_13.2, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc12_13.3(%.loc12_12) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
-// CHECK:STDOUT:   %.loc12_13.5: %i32 = converted %.loc12_12, %.loc12_13.4 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc12_13.1: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc12_13.2: <bound method> = bound_method %.loc12_12, %.loc12_13.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc12_13.3: <specific function> = specific_function %.loc12_13.2, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc12_13.3(%.loc12_12) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.33]
+// CHECK:STDOUT:   %.loc12_13.5: %i32 = converted %.loc12_12, %.loc12_13.4 [template = constants.%.33]
 // CHECK:STDOUT:   return %.loc12_13.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -507,12 +507,12 @@ class A {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.26: type = struct_type {} [template]
-// CHECK:STDOUT:   %.27: <witness> = complete_type_witness %.26 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {} [template]
+// CHECK:STDOUT:   %.31: <witness> = complete_type_witness %.30 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -544,14 +544,14 @@ class A {
 // CHECK:STDOUT:   %.loc5_10.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_10.3: type = converted %int.make_type_signed, %.loc5_10.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_16: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc5_17.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc5_17.2: <bound method> = bound_method %.loc5_16, %.loc5_17.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc5_17.3: <specific function> = specific_function %.loc5_17.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc5_17.3(%.loc5_16) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_17.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_17.5: %i32 = converted %.loc5_16, %.loc5_17.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc5_17.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc5_17.2: <bound method> = bound_method %.loc5_16, %.loc5_17.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc5_17.3: <specific function> = specific_function %.loc5_17.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc5_17.3(%.loc5_16) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_17.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_17.5: %i32 = converted %.loc5_16, %.loc5_17.4 [template = constants.%.29]
 // CHECK:STDOUT:   %x: %i32 = bind_name x, %.loc5_17.5
-// CHECK:STDOUT:   %.loc6: <witness> = complete_type_witness %.26 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc6: <witness> = complete_type_witness %.30 [template = constants.%.31]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%A
@@ -578,12 +578,12 @@ class A {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.26: type = struct_type {} [template]
-// CHECK:STDOUT:   %.27: <witness> = complete_type_witness %.26 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {} [template]
+// CHECK:STDOUT:   %.31: <witness> = complete_type_witness %.30 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -620,26 +620,26 @@ class A {
 // CHECK:STDOUT:   %.loc5_20.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_20.3: type = converted %int.make_type_signed.loc5, %.loc5_20.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_26: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc5_27.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc5_27.2: <bound method> = bound_method %.loc5_26, %.loc5_27.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc5_27.3: <specific function> = specific_function %.loc5_27.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc5: init %i32 = call %.loc5_27.3(%.loc5_26) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_27.4: %i32 = value_of_initializer %int.convert_checked.loc5 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_27.5: %i32 = converted %.loc5_26, %.loc5_27.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc5_27.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc5_27.2: <bound method> = bound_method %.loc5_26, %.loc5_27.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc5_27.3: <specific function> = specific_function %.loc5_27.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc5: init %i32 = call %.loc5_27.3(%.loc5_26) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_27.4: %i32 = value_of_initializer %int.convert_checked.loc5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_27.5: %i32 = converted %.loc5_26, %.loc5_27.4 [template = constants.%.29]
 // CHECK:STDOUT:   %x: %i32 = bind_name x, %.loc5_27.5
 // CHECK:STDOUT:   %.loc6_18.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc6: init type = call constants.%Int(%.loc6_18.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_18.2: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_18.3: type = converted %int.make_type_signed.loc6, %.loc6_18.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_24: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc6_25.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_25.2: <bound method> = bound_method %.loc6_24, %.loc6_25.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc6_25.3: <specific function> = specific_function %.loc6_25.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc6: init %i32 = call %.loc6_25.3(%.loc6_24) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc6_25.4: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc6_25.5: %i32 = converted %.loc6_24, %.loc6_25.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc6_25.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_25.2: <bound method> = bound_method %.loc6_24, %.loc6_25.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc6_25.3: <specific function> = specific_function %.loc6_25.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc6: init %i32 = call %.loc6_25.3(%.loc6_24) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc6_25.4: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc6_25.5: %i32 = converted %.loc6_24, %.loc6_25.4 [template = constants.%.29]
 // CHECK:STDOUT:   %y: %i32 = bind_name y, %.loc6_25.5
-// CHECK:STDOUT:   %.loc7: <witness> = complete_type_witness %.26 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc7: <witness> = complete_type_witness %.30 [template = constants.%.31]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%A

toolchain/check/testdata/class/base.carbon

@@ -69,15 +69,15 @@ class Derived {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.36: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.13, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 4 [template]
-// CHECK:STDOUT:   %struct.1: %Base = struct_value (%.39) [template]
-// CHECK:STDOUT:   %.40: <bound method> = bound_method %.15, %Convert.14 [template]
-// CHECK:STDOUT:   %.41: <specific function> = specific_function %.40, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.42: %i32 = int_value 7 [template]
-// CHECK:STDOUT:   %struct.2: %Derived = struct_value (%struct.1, %.42) [template]
+// CHECK:STDOUT:   %.40: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.13, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 4 [template]
+// CHECK:STDOUT:   %struct.1: %Base = struct_value (%.43) [template]
+// CHECK:STDOUT:   %.44: <bound method> = bound_method %.15, %Convert.14 [template]
+// CHECK:STDOUT:   %.45: <specific function> = specific_function %.44, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.46: %i32 = int_value 7 [template]
+// CHECK:STDOUT:   %struct.2: %Derived = struct_value (%struct.1, %.46) [template]
 // CHECK:STDOUT:   %tuple.type.1: type = tuple_type (type, type) [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (%i32, %i32) [template]
 // CHECK:STDOUT:   %Access.type: type = fn_type @Access [template]
@@ -172,23 +172,23 @@ class Derived {
 // CHECK:STDOUT:   %.loc14_26.1: %.14 = struct_literal (%.loc14_25)
 // CHECK:STDOUT:   %.loc14_34: Core.IntLiteral = int_value 7 [template = constants.%.15]
 // CHECK:STDOUT:   %.loc14_35.1: %.16 = struct_literal (%.loc14_26.1, %.loc14_34)
-// CHECK:STDOUT:   %.loc14_26.2: %Convert.type.2 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_26.3: <bound method> = bound_method %.loc14_25, %.loc14_26.2 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc14_26.4: <specific function> = specific_function %.loc14_26.3, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc14_26: init %i32 = call %.loc14_26.4(%.loc14_25) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc14_26.5: init %i32 = converted %.loc14_25, %int.convert_checked.loc14_26 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc14_26.2: %Convert.type.2 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_26.3: <bound method> = bound_method %.loc14_25, %.loc14_26.2 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc14_26.4: <specific function> = specific_function %.loc14_26.3, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc14_26: init %i32 = call %.loc14_26.4(%.loc14_25) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc14_26.5: init %i32 = converted %.loc14_25, %int.convert_checked.loc14_26 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc14_35.2: ref %Base = class_element_access %return, element0
 // CHECK:STDOUT:   %.loc14_26.6: ref %i32 = class_element_access %.loc14_35.2, element0
-// CHECK:STDOUT:   %.loc14_26.7: init %i32 = initialize_from %.loc14_26.5 to %.loc14_26.6 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc14_26.7: init %i32 = initialize_from %.loc14_26.5 to %.loc14_26.6 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc14_26.8: init %Base = class_init (%.loc14_26.7), %.loc14_35.2 [template = constants.%struct.1]
 // CHECK:STDOUT:   %.loc14_35.3: init %Base = converted %.loc14_26.1, %.loc14_26.8 [template = constants.%struct.1]
-// CHECK:STDOUT:   %.loc14_35.4: %Convert.type.2 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_35.5: <bound method> = bound_method %.loc14_34, %.loc14_35.4 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc14_35.6: <specific function> = specific_function %.loc14_35.5, @Convert.2(constants.%.1) [template = constants.%.41]
-// CHECK:STDOUT:   %int.convert_checked.loc14_35: init %i32 = call %.loc14_35.6(%.loc14_34) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc14_35.7: init %i32 = converted %.loc14_34, %int.convert_checked.loc14_35 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc14_35.4: %Convert.type.2 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_35.5: <bound method> = bound_method %.loc14_34, %.loc14_35.4 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc14_35.6: <specific function> = specific_function %.loc14_35.5, @Convert.2(constants.%.1) [template = constants.%.45]
+// CHECK:STDOUT:   %int.convert_checked.loc14_35: init %i32 = call %.loc14_35.6(%.loc14_34) [template = constants.%.46]
+// CHECK:STDOUT:   %.loc14_35.7: init %i32 = converted %.loc14_34, %int.convert_checked.loc14_35 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc14_35.8: ref %i32 = class_element_access %return, element1
-// CHECK:STDOUT:   %.loc14_35.9: init %i32 = initialize_from %.loc14_35.7 to %.loc14_35.8 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc14_35.9: init %i32 = initialize_from %.loc14_35.7 to %.loc14_35.8 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc14_35.10: init %Derived = class_init (%.loc14_35.3, %.loc14_35.9), %return [template = constants.%struct.2]
 // CHECK:STDOUT:   %.loc14_36: init %Derived = converted %.loc14_35.1, %.loc14_35.10 [template = constants.%struct.2]
 // CHECK:STDOUT:   return %.loc14_36 to %return

toolchain/check/testdata/class/base_method.carbon

@@ -45,15 +45,15 @@ fn Call(p: Derived*) {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %Derived: type = class_type @Derived [template]
-// CHECK:STDOUT:   %.31: type = unbound_element_type %Derived, %Base [template]
-// CHECK:STDOUT:   %.32: type = struct_type {.base: %Base} [template]
-// CHECK:STDOUT:   %.33: <witness> = complete_type_witness %.32 [template]
-// CHECK:STDOUT:   %.34: type = ptr_type %Derived [template]
+// CHECK:STDOUT:   %.35: type = unbound_element_type %Derived, %Base [template]
+// CHECK:STDOUT:   %.36: type = struct_type {.base: %Base} [template]
+// CHECK:STDOUT:   %.37: <witness> = complete_type_witness %.36 [template]
+// CHECK:STDOUT:   %.38: type = ptr_type %Derived [template]
 // CHECK:STDOUT:   %Call.type: type = fn_type @Call [template]
 // CHECK:STDOUT:   %Call: %Call.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -88,13 +88,13 @@ fn Call(p: Derived*) {
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %Derived.decl: type = class_decl @Derived [template = constants.%Derived] {} {}
 // CHECK:STDOUT:   %Call.decl: %Call.type = fn_decl @Call [template = constants.%Call] {
-// CHECK:STDOUT:     %p.patt: %.34 = binding_pattern p
-// CHECK:STDOUT:     %p.param_patt: %.34 = value_param_pattern %p.patt, runtime_param0
+// CHECK:STDOUT:     %p.patt: %.38 = binding_pattern p
+// CHECK:STDOUT:     %p.param_patt: %.38 = value_param_pattern %p.patt, runtime_param0
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Derived.ref: type = name_ref Derived, file.%Derived.decl [template = constants.%Derived]
-// CHECK:STDOUT:     %.loc25: type = ptr_type %Derived [template = constants.%.34]
-// CHECK:STDOUT:     %p.param: %.34 = value_param runtime_param0
-// CHECK:STDOUT:     %p: %.34 = bind_name p, %p.param
+// CHECK:STDOUT:     %.loc25: type = ptr_type %Derived [template = constants.%.38]
+// CHECK:STDOUT:     %p.param: %.38 = value_param runtime_param0
+// CHECK:STDOUT:     %p: %.38 = bind_name p, %p.param
 // CHECK:STDOUT:   }
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -124,8 +124,8 @@ fn Call(p: Derived*) {
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Derived {
 // CHECK:STDOUT:   %Base.ref: type = name_ref Base, file.%Base.decl [template = constants.%Base]
-// CHECK:STDOUT:   %.loc22: %.31 = base_decl %Base, element0 [template]
-// CHECK:STDOUT:   %.loc23: <witness> = complete_type_witness %.32 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc22: %.35 = base_decl %Base, element0 [template]
+// CHECK:STDOUT:   %.loc23: <witness> = complete_type_witness %.36 [template = constants.%.37]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%Derived
@@ -140,22 +140,22 @@ fn Call(p: Derived*) {
 // CHECK:STDOUT:   %a.ref: %.2 = name_ref a, @Base.%.loc12_8 [template = @Base.%.loc12_8]
 // CHECK:STDOUT:   %.loc18_10: ref %i32 = class_element_access %.loc18_4, element0
 // CHECK:STDOUT:   %.loc18_15: Core.IntLiteral = int_value 1 [template = constants.%.7]
-// CHECK:STDOUT:   %.loc18_13.1: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_13.2: <bound method> = bound_method %.loc18_15, %.loc18_13.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc18_13.3: <specific function> = specific_function %.loc18_13.2, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc18_13.3(%.loc18_15) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc18_13.4: init %i32 = converted %.loc18_15, %int.convert_checked [template = constants.%.30]
+// CHECK:STDOUT:   %.loc18_13.1: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_13.2: <bound method> = bound_method %.loc18_15, %.loc18_13.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc18_13.3: <specific function> = specific_function %.loc18_13.2, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc18_13.3(%.loc18_15) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc18_13.4: init %i32 = converted %.loc18_15, %int.convert_checked [template = constants.%.34]
 // CHECK:STDOUT:   assign %.loc18_10, %.loc18_13.4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @Call(%p.param_patt: %.34) {
+// CHECK:STDOUT: fn @Call(%p.param_patt: %.38) {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %p.ref: %.34 = name_ref p, %p
+// CHECK:STDOUT:   %p.ref: %.38 = name_ref p, %p
 // CHECK:STDOUT:   %.loc26_4.1: ref %Derived = deref %p.ref
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, @Base.%F.decl [template = constants.%F]
 // CHECK:STDOUT:   %.loc26_7: <bound method> = bound_method %.loc26_4.1, %F.ref
-// CHECK:STDOUT:   %.loc26_4.2: %.34 = addr_of %.loc26_4.1
+// CHECK:STDOUT:   %.loc26_4.2: %.38 = addr_of %.loc26_4.1
 // CHECK:STDOUT:   %.loc26_4.3: ref %Derived = deref %.loc26_4.2
 // CHECK:STDOUT:   %.loc26_4.4: ref %Base = class_element_access %.loc26_4.3, element0
 // CHECK:STDOUT:   %.loc26_4.5: %.3 = addr_of %.loc26_4.4

toolchain/check/testdata/class/basic.carbon

@@ -47,10 +47,10 @@ fn Run() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 4 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 4 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -172,12 +172,12 @@ fn Run() -> i32 {
 // CHECK:STDOUT:   %Class.ref: type = name_ref Class, file.%Class.decl [template = constants.%Class]
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, @Class.%F.decl [template = constants.%F]
 // CHECK:STDOUT:   %.loc26_18.1: Core.IntLiteral = int_value 4 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc26_18.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc26_18.3: <bound method> = bound_method %.loc26_18.1, %.loc26_18.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc26_18.4: <specific function> = specific_function %.loc26_18.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc26_18.4(%.loc26_18.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc26_18.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
-// CHECK:STDOUT:   %.loc26_18.6: %i32 = converted %.loc26_18.1, %.loc26_18.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc26_18.2: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc26_18.3: <bound method> = bound_method %.loc26_18.1, %.loc26_18.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc26_18.4: <specific function> = specific_function %.loc26_18.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc26_18.4(%.loc26_18.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc26_18.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.33]
+// CHECK:STDOUT:   %.loc26_18.6: %i32 = converted %.loc26_18.1, %.loc26_18.5 [template = constants.%.33]
 // CHECK:STDOUT:   %F.call: init %i32 = call %F.ref(%.loc26_18.6)
 // CHECK:STDOUT:   %.loc26_20.1: %i32 = value_of_initializer %F.call
 // CHECK:STDOUT:   %.loc26_20.2: %i32 = converted %F.call, %.loc26_20.1

toolchain/check/testdata/class/derived_to_base.carbon

@@ -83,19 +83,19 @@ fn ConvertInit() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.48: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.49: <bound method> = bound_method %.23, %Convert.14 [template]
-// CHECK:STDOUT:   %.50: <specific function> = specific_function %.49, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.51: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %struct.1: %A = struct_value (%.51) [template]
-// CHECK:STDOUT:   %.52: <bound method> = bound_method %.25, %Convert.14 [template]
-// CHECK:STDOUT:   %.53: <specific function> = specific_function %.52, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.54: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct.2: %B = struct_value (%struct.1, %.54) [template]
-// CHECK:STDOUT:   %.55: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.56: <specific function> = specific_function %.55, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.57: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %struct.3: %C = struct_value (%struct.2, %.57) [template]
+// CHECK:STDOUT:   %.52: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.53: <bound method> = bound_method %.23, %Convert.14 [template]
+// CHECK:STDOUT:   %.54: <specific function> = specific_function %.53, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.55: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %struct.1: %A = struct_value (%.55) [template]
+// CHECK:STDOUT:   %.56: <bound method> = bound_method %.25, %Convert.14 [template]
+// CHECK:STDOUT:   %.57: <specific function> = specific_function %.56, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.58: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct.2: %B = struct_value (%struct.1, %.58) [template]
+// CHECK:STDOUT:   %.59: <bound method> = bound_method %.27, %Convert.14 [template]
+// CHECK:STDOUT:   %.60: <specific function> = specific_function %.59, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.61: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %struct.3: %C = struct_value (%struct.2, %.61) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -307,34 +307,34 @@ fn ConvertInit() {
 // CHECK:STDOUT:   %.loc38_56: Core.IntLiteral = int_value 3 [template = constants.%.27]
 // CHECK:STDOUT:   %.loc38_57.1: %.28 = struct_literal (%.loc38_48.1, %.loc38_56)
 // CHECK:STDOUT:   %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
-// CHECK:STDOUT:   %.loc38_39.2: %Convert.type.2 = interface_witness_access constants.%.48, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc38_39.3: <bound method> = bound_method %.loc38_38, %.loc38_39.2 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc38_39.4: <specific function> = specific_function %.loc38_39.3, @Convert.2(constants.%.1) [template = constants.%.50]
-// CHECK:STDOUT:   %int.convert_checked.loc38_39: init %i32 = call %.loc38_39.4(%.loc38_38) [template = constants.%.51]
-// CHECK:STDOUT:   %.loc38_39.5: init %i32 = converted %.loc38_38, %int.convert_checked.loc38_39 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc38_39.2: %Convert.type.2 = interface_witness_access constants.%.52, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc38_39.3: <bound method> = bound_method %.loc38_38, %.loc38_39.2 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc38_39.4: <specific function> = specific_function %.loc38_39.3, @Convert.2(constants.%.1) [template = constants.%.54]
+// CHECK:STDOUT:   %int.convert_checked.loc38_39: init %i32 = call %.loc38_39.4(%.loc38_38) [template = constants.%.55]
+// CHECK:STDOUT:   %.loc38_39.5: init %i32 = converted %.loc38_38, %int.convert_checked.loc38_39 [template = constants.%.55]
 // CHECK:STDOUT:   %.loc38_57.2: ref %C = temporary_storage
 // CHECK:STDOUT:   %.loc38_57.3: ref %B = class_element_access %.loc38_57.2, element0
 // CHECK:STDOUT:   %.loc38_48.2: ref %A = class_element_access %.loc38_57.3, element0
 // CHECK:STDOUT:   %.loc38_39.6: ref %i32 = class_element_access %.loc38_48.2, element0
-// CHECK:STDOUT:   %.loc38_39.7: init %i32 = initialize_from %.loc38_39.5 to %.loc38_39.6 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc38_39.7: init %i32 = initialize_from %.loc38_39.5 to %.loc38_39.6 [template = constants.%.55]
 // CHECK:STDOUT:   %.loc38_39.8: init %A = class_init (%.loc38_39.7), %.loc38_48.2 [template = constants.%struct.1]
 // CHECK:STDOUT:   %.loc38_48.3: init %A = converted %.loc38_39.1, %.loc38_39.8 [template = constants.%struct.1]
-// CHECK:STDOUT:   %.loc38_48.4: %Convert.type.2 = interface_witness_access constants.%.48, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc38_48.5: <bound method> = bound_method %.loc38_47, %.loc38_48.4 [template = constants.%.52]
-// CHECK:STDOUT:   %.loc38_48.6: <specific function> = specific_function %.loc38_48.5, @Convert.2(constants.%.1) [template = constants.%.53]
-// CHECK:STDOUT:   %int.convert_checked.loc38_48: init %i32 = call %.loc38_48.6(%.loc38_47) [template = constants.%.54]
-// CHECK:STDOUT:   %.loc38_48.7: init %i32 = converted %.loc38_47, %int.convert_checked.loc38_48 [template = constants.%.54]
+// CHECK:STDOUT:   %.loc38_48.4: %Convert.type.2 = interface_witness_access constants.%.52, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc38_48.5: <bound method> = bound_method %.loc38_47, %.loc38_48.4 [template = constants.%.56]
+// CHECK:STDOUT:   %.loc38_48.6: <specific function> = specific_function %.loc38_48.5, @Convert.2(constants.%.1) [template = constants.%.57]
+// CHECK:STDOUT:   %int.convert_checked.loc38_48: init %i32 = call %.loc38_48.6(%.loc38_47) [template = constants.%.58]
+// CHECK:STDOUT:   %.loc38_48.7: init %i32 = converted %.loc38_47, %int.convert_checked.loc38_48 [template = constants.%.58]
 // CHECK:STDOUT:   %.loc38_48.8: ref %i32 = class_element_access %.loc38_57.3, element1
-// CHECK:STDOUT:   %.loc38_48.9: init %i32 = initialize_from %.loc38_48.7 to %.loc38_48.8 [template = constants.%.54]
+// CHECK:STDOUT:   %.loc38_48.9: init %i32 = initialize_from %.loc38_48.7 to %.loc38_48.8 [template = constants.%.58]
 // CHECK:STDOUT:   %.loc38_48.10: init %B = class_init (%.loc38_48.3, %.loc38_48.9), %.loc38_57.3 [template = constants.%struct.2]
 // CHECK:STDOUT:   %.loc38_57.4: init %B = converted %.loc38_48.1, %.loc38_48.10 [template = constants.%struct.2]
-// CHECK:STDOUT:   %.loc38_57.5: %Convert.type.2 = interface_witness_access constants.%.48, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc38_57.6: <bound method> = bound_method %.loc38_56, %.loc38_57.5 [template = constants.%.55]
-// CHECK:STDOUT:   %.loc38_57.7: <specific function> = specific_function %.loc38_57.6, @Convert.2(constants.%.1) [template = constants.%.56]
-// CHECK:STDOUT:   %int.convert_checked.loc38_57: init %i32 = call %.loc38_57.7(%.loc38_56) [template = constants.%.57]
-// CHECK:STDOUT:   %.loc38_57.8: init %i32 = converted %.loc38_56, %int.convert_checked.loc38_57 [template = constants.%.57]
+// CHECK:STDOUT:   %.loc38_57.5: %Convert.type.2 = interface_witness_access constants.%.52, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc38_57.6: <bound method> = bound_method %.loc38_56, %.loc38_57.5 [template = constants.%.59]
+// CHECK:STDOUT:   %.loc38_57.7: <specific function> = specific_function %.loc38_57.6, @Convert.2(constants.%.1) [template = constants.%.60]
+// CHECK:STDOUT:   %int.convert_checked.loc38_57: init %i32 = call %.loc38_57.7(%.loc38_56) [template = constants.%.61]
+// CHECK:STDOUT:   %.loc38_57.8: init %i32 = converted %.loc38_56, %int.convert_checked.loc38_57 [template = constants.%.61]
 // CHECK:STDOUT:   %.loc38_57.9: ref %i32 = class_element_access %.loc38_57.2, element1
-// CHECK:STDOUT:   %.loc38_57.10: init %i32 = initialize_from %.loc38_57.8 to %.loc38_57.9 [template = constants.%.57]
+// CHECK:STDOUT:   %.loc38_57.10: init %i32 = initialize_from %.loc38_57.8 to %.loc38_57.9 [template = constants.%.61]
 // CHECK:STDOUT:   %.loc38_57.11: init %C = class_init (%.loc38_57.4, %.loc38_57.10), %.loc38_57.2 [template = constants.%struct.3]
 // CHECK:STDOUT:   %.loc38_57.12: ref %C = temporary %.loc38_57.2, %.loc38_57.11
 // CHECK:STDOUT:   %.loc38_59: ref %C = converted %.loc38_57.1, %.loc38_57.12

toolchain/check/testdata/class/fail_base_bad_type.carbon

@@ -250,7 +250,7 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT: constants {
 // CHECK:STDOUT:   %DeriveFromNonType: type = class_type @DeriveFromNonType [template]
 // CHECK:STDOUT:   %.1: Core.IntLiteral = int_value 32 [template]
-// CHECK:STDOUT:   %.21: type = ptr_type %DeriveFromNonType [template]
+// CHECK:STDOUT:   %.25: type = ptr_type %DeriveFromNonType [template]
 // CHECK:STDOUT:   %Int.type: type = fn_type @Int [template]
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
 // CHECK:STDOUT:   %i32: type = int_type signed, %.1 [template]
@@ -276,19 +276,19 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   %Core.import = import Core
 // CHECK:STDOUT:   %DeriveFromNonType.decl: type = class_decl @DeriveFromNonType [template = constants.%DeriveFromNonType] {} {}
 // CHECK:STDOUT:   %AccessMemberWithInvalidBasNonType.decl: %AccessMemberWithInvalidBasNonType.type = fn_decl @AccessMemberWithInvalidBasNonType [template = constants.%AccessMemberWithInvalidBasNonType] {
-// CHECK:STDOUT:     %p.patt: %.21 = binding_pattern p
-// CHECK:STDOUT:     %p.param_patt: %.21 = value_param_pattern %p.patt, runtime_param0
+// CHECK:STDOUT:     %p.patt: %.25 = binding_pattern p
+// CHECK:STDOUT:     %p.param_patt: %.25 = value_param_pattern %p.patt, runtime_param0
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %DeriveFromNonType.ref: type = name_ref DeriveFromNonType, file.%DeriveFromNonType.decl [template = constants.%DeriveFromNonType]
-// CHECK:STDOUT:     %.loc15_58: type = ptr_type %DeriveFromNonType [template = constants.%.21]
+// CHECK:STDOUT:     %.loc15_58: type = ptr_type %DeriveFromNonType [template = constants.%.25]
 // CHECK:STDOUT:     %.loc15_64.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc15_64.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc15_64.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc15_64.3: type = converted %int.make_type_signed, %.loc15_64.2 [template = constants.%i32]
-// CHECK:STDOUT:     %p.param: %.21 = value_param runtime_param0
-// CHECK:STDOUT:     %p: %.21 = bind_name p, %p.param
+// CHECK:STDOUT:     %p.param: %.25 = value_param runtime_param0
+// CHECK:STDOUT:     %p: %.25 = bind_name p, %p.param
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
@@ -306,9 +306,9 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   has_error
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @AccessMemberWithInvalidBasNonType(%p.param_patt: %.21) -> %i32 {
+// CHECK:STDOUT: fn @AccessMemberWithInvalidBasNonType(%p.param_patt: %.25) -> %i32 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %p.ref: %.21 = name_ref p, %p
+// CHECK:STDOUT:   %p.ref: %.25 = name_ref p, %p
 // CHECK:STDOUT:   %.loc15_78: ref %DeriveFromNonType = deref %p.ref
 // CHECK:STDOUT:   %n.ref: <error> = name_ref n, <error> [template = <error>]
 // CHECK:STDOUT:   return <error>
@@ -427,10 +427,10 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   %.5: type = ptr_type %tuple.type.2 [template]
 // CHECK:STDOUT:   %ConvertToBadBaseTuple.type: type = fn_type @ConvertToBadBaseTuple [template]
 // CHECK:STDOUT:   %ConvertToBadBaseTuple: %ConvertToBadBaseTuple.type = struct_value () [template]
-// CHECK:STDOUT:   %.25: Core.IntLiteral = int_value 32 [template]
+// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 32 [template]
 // CHECK:STDOUT:   %Int.type: type = fn_type @Int [template]
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
-// CHECK:STDOUT:   %i32: type = int_type signed, %.25 [template]
+// CHECK:STDOUT:   %i32: type = int_type signed, %.29 [template]
 // CHECK:STDOUT:   %AccessMemberWithInvalidBaseTuple.type: type = fn_type @AccessMemberWithInvalidBaseTuple [template]
 // CHECK:STDOUT:   %AccessMemberWithInvalidBaseTuple: %AccessMemberWithInvalidBaseTuple.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -480,7 +480,7 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %DeriveFromTuple.ref: type = name_ref DeriveFromTuple, file.%DeriveFromTuple.decl [template = constants.%DeriveFromTuple]
 // CHECK:STDOUT:     %.loc23_55: type = ptr_type %DeriveFromTuple [template = constants.%.4]
-// CHECK:STDOUT:     %.loc23_61.1: Core.IntLiteral = int_value 32 [template = constants.%.25]
+// CHECK:STDOUT:     %.loc23_61.1: Core.IntLiteral = int_value 32 [template = constants.%.29]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc23_61.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc23_61.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc23_61.3: type = converted %int.make_type_signed, %.loc23_61.2 [template = constants.%i32]
@@ -646,10 +646,10 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   %.2: type = ptr_type %Incomplete [template]
 // CHECK:STDOUT:   %ConvertToBadBaseIncomplete.type: type = fn_type @ConvertToBadBaseIncomplete [template]
 // CHECK:STDOUT:   %ConvertToBadBaseIncomplete: %ConvertToBadBaseIncomplete.type = struct_value () [template]
-// CHECK:STDOUT:   %.22: Core.IntLiteral = int_value 32 [template]
+// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 32 [template]
 // CHECK:STDOUT:   %Int.type: type = fn_type @Int [template]
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
-// CHECK:STDOUT:   %i32: type = int_type signed, %.22 [template]
+// CHECK:STDOUT:   %i32: type = int_type signed, %.26 [template]
 // CHECK:STDOUT:   %AccessMemberWithInvalidBaseIncomplete.type: type = fn_type @AccessMemberWithInvalidBaseIncomplete [template]
 // CHECK:STDOUT:   %AccessMemberWithInvalidBaseIncomplete: %AccessMemberWithInvalidBaseIncomplete.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -697,7 +697,7 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %DeriveFromIncomplete.ref: type = name_ref DeriveFromIncomplete, file.%DeriveFromIncomplete.decl [template = constants.%DeriveFromIncomplete]
 // CHECK:STDOUT:     %.loc30_65: type = ptr_type %DeriveFromIncomplete [template = constants.%.1]
-// CHECK:STDOUT:     %.loc30_71.1: Core.IntLiteral = int_value 32 [template = constants.%.22]
+// CHECK:STDOUT:     %.loc30_71.1: Core.IntLiteral = int_value 32 [template = constants.%.26]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc30_71.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc30_71.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc30_71.3: type = converted %int.make_type_signed, %.loc30_71.2 [template = constants.%i32]

toolchain/check/testdata/class/fail_derived_to_base.carbon

@@ -63,8 +63,8 @@ fn ConvertIncomplete(p: Incomplete*) -> A2* { return p; }
 // CHECK:STDOUT:   %ConvertUnrelated.type: type = fn_type @ConvertUnrelated [template]
 // CHECK:STDOUT:   %ConvertUnrelated: %ConvertUnrelated.type = struct_value () [template]
 // CHECK:STDOUT:   %Incomplete: type = class_type @Incomplete [template]
-// CHECK:STDOUT:   %.35: type = ptr_type %Incomplete [template]
-// CHECK:STDOUT:   %.36: type = ptr_type %A2 [template]
+// CHECK:STDOUT:   %.39: type = ptr_type %Incomplete [template]
+// CHECK:STDOUT:   %.40: type = ptr_type %A2 [template]
 // CHECK:STDOUT:   %ConvertIncomplete.type: type = fn_type @ConvertIncomplete [template]
 // CHECK:STDOUT:   %ConvertIncomplete: %ConvertIncomplete.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -109,19 +109,19 @@ fn ConvertIncomplete(p: Incomplete*) -> A2* { return p; }
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %Incomplete.decl: type = class_decl @Incomplete [template = constants.%Incomplete] {} {}
 // CHECK:STDOUT:   %ConvertIncomplete.decl: %ConvertIncomplete.type = fn_decl @ConvertIncomplete [template = constants.%ConvertIncomplete] {
-// CHECK:STDOUT:     %p.patt: %.35 = binding_pattern p
-// CHECK:STDOUT:     %p.param_patt: %.35 = value_param_pattern %p.patt, runtime_param0
-// CHECK:STDOUT:     %return.patt: %.36 = return_slot_pattern
-// CHECK:STDOUT:     %return.param_patt: %.36 = out_param_pattern %return.patt, runtime_param1
+// CHECK:STDOUT:     %p.patt: %.39 = binding_pattern p
+// CHECK:STDOUT:     %p.param_patt: %.39 = value_param_pattern %p.patt, runtime_param0
+// CHECK:STDOUT:     %return.patt: %.40 = return_slot_pattern
+// CHECK:STDOUT:     %return.param_patt: %.40 = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Incomplete.ref: type = name_ref Incomplete, file.%Incomplete.decl [template = constants.%Incomplete]
-// CHECK:STDOUT:     %.loc41_35: type = ptr_type %Incomplete [template = constants.%.35]
+// CHECK:STDOUT:     %.loc41_35: type = ptr_type %Incomplete [template = constants.%.39]
 // CHECK:STDOUT:     %A2.ref: type = name_ref A2, file.%A2.decl [template = constants.%A2]
-// CHECK:STDOUT:     %.loc41_43: type = ptr_type %A2 [template = constants.%.36]
-// CHECK:STDOUT:     %p.param: %.35 = value_param runtime_param0
-// CHECK:STDOUT:     %p: %.35 = bind_name p, %p.param
-// CHECK:STDOUT:     %return.param: ref %.36 = out_param runtime_param1
-// CHECK:STDOUT:     %return: ref %.36 = return_slot %return.param
+// CHECK:STDOUT:     %.loc41_43: type = ptr_type %A2 [template = constants.%.40]
+// CHECK:STDOUT:     %p.param: %.39 = value_param runtime_param0
+// CHECK:STDOUT:     %p: %.39 = bind_name p, %p.param
+// CHECK:STDOUT:     %return.param: ref %.40 = out_param runtime_param1
+// CHECK:STDOUT:     %return: ref %.40 = return_slot %return.param
 // CHECK:STDOUT:   }
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -177,10 +177,10 @@ fn ConvertIncomplete(p: Incomplete*) -> A2* { return p; }
 // CHECK:STDOUT:   return <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @ConvertIncomplete(%p.param_patt: %.35) -> %.36 {
+// CHECK:STDOUT: fn @ConvertIncomplete(%p.param_patt: %.39) -> %.40 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %p.ref: %.35 = name_ref p, %p
-// CHECK:STDOUT:   %.loc41_55: %.36 = converted %p.ref, <error> [template = <error>]
+// CHECK:STDOUT:   %p.ref: %.39 = name_ref p, %p
+// CHECK:STDOUT:   %.loc41_55: %.40 = converted %p.ref, <error> [template = <error>]
 // CHECK:STDOUT:   return <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/class/fail_field_modifiers.carbon

@@ -47,16 +47,16 @@ class Class {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.3, %Convert.14 [template]
 // CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: type = struct_type {.j: %i32, .k: %i32} [template]
-// CHECK:STDOUT:   %.32: <witness> = complete_type_witness %.31 [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: type = struct_type {.j: %i32, .k: %i32} [template]
+// CHECK:STDOUT:   %.36: <witness> = complete_type_witness %.35 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -93,26 +93,26 @@ class Class {
 // CHECK:STDOUT:   %.loc29_18.2: type = value_of_initializer %int.make_type_signed.loc29 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc29_18.3: type = converted %int.make_type_signed.loc29, %.loc29_18.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc29_24: Core.IntLiteral = int_value 0 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc29_25.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc29_25.2: <bound method> = bound_method %.loc29_24, %.loc29_25.1 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc29_25.3: <specific function> = specific_function %.loc29_25.2, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc29: init %i32 = call %.loc29_25.3(%.loc29_24) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc29_25.4: %i32 = value_of_initializer %int.convert_checked.loc29 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc29_25.5: %i32 = converted %.loc29_24, %.loc29_25.4 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc29_25.1: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc29_25.2: <bound method> = bound_method %.loc29_24, %.loc29_25.1 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc29_25.3: <specific function> = specific_function %.loc29_25.2, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc29: init %i32 = call %.loc29_25.3(%.loc29_24) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc29_25.4: %i32 = value_of_initializer %int.convert_checked.loc29 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc29_25.5: %i32 = converted %.loc29_24, %.loc29_25.4 [template = constants.%.30]
 // CHECK:STDOUT:   %l: %i32 = bind_name l, %.loc29_25.5
 // CHECK:STDOUT:   %.loc34_16.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc34: init type = call constants.%Int(%.loc34_16.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc34_16.2: type = value_of_initializer %int.make_type_signed.loc34 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc34_16.3: type = converted %int.make_type_signed.loc34, %.loc34_16.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc34_22: Core.IntLiteral = int_value 1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc34_23.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc34_23.2: <bound method> = bound_method %.loc34_22, %.loc34_23.1 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc34_23.3: <specific function> = specific_function %.loc34_23.2, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc34: init %i32 = call %.loc34_23.3(%.loc34_22) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc34_23.4: %i32 = value_of_initializer %int.convert_checked.loc34 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc34_23.5: %i32 = converted %.loc34_22, %.loc34_23.4 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc34_22: Core.IntLiteral = int_value 1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc34_23.1: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc34_23.2: <bound method> = bound_method %.loc34_22, %.loc34_23.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc34_23.3: <specific function> = specific_function %.loc34_23.2, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc34: init %i32 = call %.loc34_23.3(%.loc34_22) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc34_23.4: %i32 = value_of_initializer %int.convert_checked.loc34 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc34_23.5: %i32 = converted %.loc34_22, %.loc34_23.4 [template = constants.%.34]
 // CHECK:STDOUT:   %m: %i32 = bind_name m, %.loc34_23.5
-// CHECK:STDOUT:   %.loc35: <witness> = complete_type_witness %.31 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc35: <witness> = complete_type_witness %.35 [template = constants.%.36]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%Class

toolchain/check/testdata/class/fail_generic_method.carbon

@@ -15,7 +15,7 @@ class Class(T:! type) {
 
 // TODO: The follow-on errors here aren't great. Investigate whether we can
 // enter the scope anyway if the parameters don't match.
-// CHECK:STDERR: fail_generic_method.carbon:[[@LINE+14]]:10: error: redeclaration differs at parameter 1 [RedeclParamDiffers]
+// CHECK:STDERR: fail_generic_method.carbon:[[@LINE+14]]:10: error: type `i32` of parameter 1 in redeclaration differs from previous parameter type `type` [RedeclParamDiffersType]
 // CHECK:STDERR: fn Class(N:! i32).F[self: Self](n: T) {}
 // CHECK:STDERR:          ^~~~~~~
 // CHECK:STDERR: fail_generic_method.carbon:[[@LINE-10]]:13: note: previous declaration's corresponding parameter here [RedeclParamPrevious]

toolchain/check/testdata/class/fail_init.carbon

@@ -50,12 +50,12 @@ fn F() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.34: type = struct_type {.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.38: type = struct_type {.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral} [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -109,20 +109,20 @@ fn F() {
 // CHECK:STDOUT:   %.loc26_17: Core.IntLiteral = int_value 2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc26_18.1: %.9 = struct_literal (%.loc26_9, %.loc26_17)
 // CHECK:STDOUT:   %Class.ref.loc26: type = name_ref Class, file.%Class.decl [template = constants.%Class]
-// CHECK:STDOUT:   %.loc26_18.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc26_18.3: <bound method> = bound_method %.loc26_9, %.loc26_18.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc26_18.4: <specific function> = specific_function %.loc26_18.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc26_18.4(%.loc26_9) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc26_18.5: init %i32 = converted %.loc26_9, %int.convert_checked [template = constants.%.32]
+// CHECK:STDOUT:   %.loc26_18.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc26_18.3: <bound method> = bound_method %.loc26_9, %.loc26_18.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc26_18.4: <specific function> = specific_function %.loc26_18.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc26_18.4(%.loc26_9) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc26_18.5: init %i32 = converted %.loc26_9, %int.convert_checked [template = constants.%.36]
 // CHECK:STDOUT:   %.loc26_18.6: ref %Class = temporary_storage
 // CHECK:STDOUT:   %.loc26_18.7: ref %i32 = class_element_access %.loc26_18.6, element0
-// CHECK:STDOUT:   %.loc26_18.8: init %i32 = initialize_from %.loc26_18.5 to %.loc26_18.7 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc26_18.8: init %i32 = initialize_from %.loc26_18.5 to %.loc26_18.7 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc26_18.9: ref %Class = temporary %.loc26_18.6, <error>
 // CHECK:STDOUT:   %.loc26_20: ref %Class = converted %.loc26_18.1, %.loc26_18.9
 // CHECK:STDOUT:   %.loc30_9: Core.IntLiteral = int_value 1 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc30_17: Core.IntLiteral = int_value 2 [template = constants.%.8]
-// CHECK:STDOUT:   %.loc30_25: Core.IntLiteral = int_value 3 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc30_26.1: %.34 = struct_literal (%.loc30_9, %.loc30_17, %.loc30_25)
+// CHECK:STDOUT:   %.loc30_25: Core.IntLiteral = int_value 3 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc30_26.1: %.38 = struct_literal (%.loc30_9, %.loc30_17, %.loc30_25)
 // CHECK:STDOUT:   %Class.ref.loc30: type = name_ref Class, file.%Class.decl [template = constants.%Class]
 // CHECK:STDOUT:   %.loc30_26.2: ref %Class = temporary_storage
 // CHECK:STDOUT:   %.loc30_26.3: ref %Class = temporary %.loc30_26.2, <error>

toolchain/check/testdata/class/fail_init_as_inplace.carbon

@@ -49,14 +49,14 @@ fn F() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.8, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct: %Class = struct_value (%.32, %.35) [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct: %Class = struct_value (%.36, %.39) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -119,21 +119,21 @@ fn F() {
 // CHECK:STDOUT:   %.loc25_32: Core.IntLiteral = int_value 2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc25_33.1: %.9 = struct_literal (%.loc25_24, %.loc25_32)
 // CHECK:STDOUT:   %Class.ref.loc25_38: type = name_ref Class, file.%Class.decl [template = constants.%Class]
-// CHECK:STDOUT:   %.loc25_33.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc25_33.3: <bound method> = bound_method %.loc25_24, %.loc25_33.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc25_33.4: <specific function> = specific_function %.loc25_33.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc25_33.1: init %i32 = call %.loc25_33.4(%.loc25_24) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc25_33.5: init %i32 = converted %.loc25_24, %int.convert_checked.loc25_33.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc25_33.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc25_33.3: <bound method> = bound_method %.loc25_24, %.loc25_33.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc25_33.4: <specific function> = specific_function %.loc25_33.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc25_33.1: init %i32 = call %.loc25_33.4(%.loc25_24) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc25_33.5: init %i32 = converted %.loc25_24, %int.convert_checked.loc25_33.1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc25_33.6: ref %Class = temporary_storage
 // CHECK:STDOUT:   %.loc25_33.7: ref %i32 = class_element_access %.loc25_33.6, element0
-// CHECK:STDOUT:   %.loc25_33.8: init %i32 = initialize_from %.loc25_33.5 to %.loc25_33.7 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc25_33.9: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc25_33.10: <bound method> = bound_method %.loc25_32, %.loc25_33.9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc25_33.11: <specific function> = specific_function %.loc25_33.10, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc25_33.2: init %i32 = call %.loc25_33.11(%.loc25_32) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc25_33.12: init %i32 = converted %.loc25_32, %int.convert_checked.loc25_33.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc25_33.8: init %i32 = initialize_from %.loc25_33.5 to %.loc25_33.7 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc25_33.9: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc25_33.10: <bound method> = bound_method %.loc25_32, %.loc25_33.9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc25_33.11: <specific function> = specific_function %.loc25_33.10, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc25_33.2: init %i32 = call %.loc25_33.11(%.loc25_32) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc25_33.12: init %i32 = converted %.loc25_32, %int.convert_checked.loc25_33.2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc25_33.13: ref %i32 = class_element_access %.loc25_33.6, element1
-// CHECK:STDOUT:   %.loc25_33.14: init %i32 = initialize_from %.loc25_33.12 to %.loc25_33.13 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc25_33.14: init %i32 = initialize_from %.loc25_33.12 to %.loc25_33.13 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc25_33.15: init %Class = class_init (%.loc25_33.8, %.loc25_33.14), %.loc25_33.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc25_33.16: ref %Class = temporary %.loc25_33.6, %.loc25_33.15
 // CHECK:STDOUT:   %.loc25_35.1: ref %Class = converted %.loc25_33.1, %.loc25_33.16

toolchain/check/testdata/class/fail_scope.carbon

@@ -37,10 +37,10 @@ fn G() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.24: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.25: <bound method> = bound_method %.4, %Convert.14 [template]
-// CHECK:STDOUT:   %.26: <specific function> = specific_function %.25, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.27: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.29: <bound method> = bound_method %.4, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.31: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -97,12 +97,12 @@ fn G() -> i32 {
 // CHECK:STDOUT: fn @F() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc13_12: Core.IntLiteral = int_value 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc13_13.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_13.2: <bound method> = bound_method %.loc13_12, %.loc13_13.1 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc13_13.3: <specific function> = specific_function %.loc13_13.2, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc13_13.3(%.loc13_12) [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_13.5: %i32 = converted %.loc13_12, %.loc13_13.4 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc13_13.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_13.2: <bound method> = bound_method %.loc13_12, %.loc13_13.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_13.3: <specific function> = specific_function %.loc13_13.2, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc13_13.3(%.loc13_12) [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_13.5: %i32 = converted %.loc13_12, %.loc13_13.4 [template = constants.%.31]
 // CHECK:STDOUT:   return %.loc13_13.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/class/field_access.carbon

@@ -38,14 +38,14 @@ fn Run() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
 // CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -96,21 +96,21 @@ fn Run() {
 // CHECK:STDOUT:   %j.ref.loc18: %.2 = name_ref j, @Class.%.loc12_8 [template = @Class.%.loc12_8]
 // CHECK:STDOUT:   %.loc18_4: ref %i32 = class_element_access %c.ref.loc18, element0
 // CHECK:STDOUT:   %.loc18_9: Core.IntLiteral = int_value 1 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc18_7.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_7.2: <bound method> = bound_method %.loc18_9, %.loc18_7.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc18_7.3: <specific function> = specific_function %.loc18_7.2, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc18: init %i32 = call %.loc18_7.3(%.loc18_9) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc18_7.4: init %i32 = converted %.loc18_9, %int.convert_checked.loc18 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc18_7.1: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_7.2: <bound method> = bound_method %.loc18_9, %.loc18_7.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc18_7.3: <specific function> = specific_function %.loc18_7.2, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc18: init %i32 = call %.loc18_7.3(%.loc18_9) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc18_7.4: init %i32 = converted %.loc18_9, %int.convert_checked.loc18 [template = constants.%.33]
 // CHECK:STDOUT:   assign %.loc18_4, %.loc18_7.4
 // CHECK:STDOUT:   %c.ref.loc19: ref %Class = name_ref c, %c
 // CHECK:STDOUT:   %k.ref.loc19: %.2 = name_ref k, @Class.%.loc13_8 [template = @Class.%.loc13_8]
 // CHECK:STDOUT:   %.loc19_4: ref %i32 = class_element_access %c.ref.loc19, element1
-// CHECK:STDOUT:   %.loc19_9: Core.IntLiteral = int_value 2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_7.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc19_7.2: <bound method> = bound_method %.loc19_9, %.loc19_7.1 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc19_7.3: <specific function> = specific_function %.loc19_7.2, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc19: init %i32 = call %.loc19_7.3(%.loc19_9) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc19_7.4: init %i32 = converted %.loc19_9, %int.convert_checked.loc19 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc19_9: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_7.1: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc19_7.2: <bound method> = bound_method %.loc19_9, %.loc19_7.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc19_7.3: <specific function> = specific_function %.loc19_7.2, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc19: init %i32 = call %.loc19_7.3(%.loc19_9) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc19_7.4: init %i32 = converted %.loc19_9, %int.convert_checked.loc19 [template = constants.%.37]
 // CHECK:STDOUT:   assign %.loc19_4, %.loc19_7.4
 // CHECK:STDOUT:   %.loc20_11.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc20: init type = call constants.%Int(%.loc20_11.1) [template = constants.%i32]

toolchain/check/testdata/class/field_access_in_value.carbon

@@ -39,14 +39,14 @@ fn Test() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.6, %Convert.14 [template]
 // CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -97,21 +97,21 @@ fn Test() {
 // CHECK:STDOUT:   %j.ref.loc18: %.2 = name_ref j, @Class.%.loc12_8 [template = @Class.%.loc12_8]
 // CHECK:STDOUT:   %.loc18_5: ref %i32 = class_element_access %cv.ref.loc18, element0
 // CHECK:STDOUT:   %.loc18_10: Core.IntLiteral = int_value 1 [template = constants.%.6]
-// CHECK:STDOUT:   %.loc18_8.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc18_8.2: <bound method> = bound_method %.loc18_10, %.loc18_8.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc18_8.3: <specific function> = specific_function %.loc18_8.2, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc18: init %i32 = call %.loc18_8.3(%.loc18_10) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc18_8.4: init %i32 = converted %.loc18_10, %int.convert_checked.loc18 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc18_8.1: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc18_8.2: <bound method> = bound_method %.loc18_10, %.loc18_8.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc18_8.3: <specific function> = specific_function %.loc18_8.2, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc18: init %i32 = call %.loc18_8.3(%.loc18_10) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc18_8.4: init %i32 = converted %.loc18_10, %int.convert_checked.loc18 [template = constants.%.33]
 // CHECK:STDOUT:   assign %.loc18_5, %.loc18_8.4
 // CHECK:STDOUT:   %cv.ref.loc19: ref %Class = name_ref cv, %cv
 // CHECK:STDOUT:   %k.ref.loc19: %.2 = name_ref k, @Class.%.loc13_8 [template = @Class.%.loc13_8]
 // CHECK:STDOUT:   %.loc19_5: ref %i32 = class_element_access %cv.ref.loc19, element1
-// CHECK:STDOUT:   %.loc19_10: Core.IntLiteral = int_value 2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_8.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc19_8.2: <bound method> = bound_method %.loc19_10, %.loc19_8.1 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc19_8.3: <specific function> = specific_function %.loc19_8.2, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc19: init %i32 = call %.loc19_8.3(%.loc19_10) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc19_8.4: init %i32 = converted %.loc19_10, %int.convert_checked.loc19 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc19_10: Core.IntLiteral = int_value 2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_8.1: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc19_8.2: <bound method> = bound_method %.loc19_10, %.loc19_8.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc19_8.3: <specific function> = specific_function %.loc19_8.2, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc19: init %i32 = call %.loc19_8.3(%.loc19_10) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc19_8.4: init %i32 = converted %.loc19_10, %int.convert_checked.loc19 [template = constants.%.37]
 // CHECK:STDOUT:   assign %.loc19_5, %.loc19_8.4
 // CHECK:STDOUT:   %Class.ref.loc20: type = name_ref Class, file.%Class.decl [template = constants.%Class]
 // CHECK:STDOUT:   %cv.ref.loc20: ref %Class = name_ref cv, %cv

toolchain/check/testdata/class/generic/call.carbon

@@ -107,16 +107,16 @@ class Outer(T:! type) {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %Class.3: type = class_type @Class, @Class(%.4, %.28) [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.30, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %Class.4: type = class_type @Class, @Class(%empty_tuple.type, %.33) [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %Class.3: type = class_type @Class, @Class(%.4, %.32) [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %Class.4: type = class_type @Class, @Class(%empty_tuple.type, %.37) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -158,26 +158,26 @@ class Outer(T:! type) {
 // CHECK:STDOUT:   %.loc6_17.2: type = converted %int.make_type_signed, %.loc6_17.1 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_17.3: type = ptr_type %i32 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc6_20: Core.IntLiteral = int_value 5 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc6_13.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_13.2: <bound method> = bound_method %.loc6_20, %.loc6_13.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc6_13.3: <specific function> = specific_function %.loc6_13.2, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc6: init %i32 = call %.loc6_13.3(%.loc6_20) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc6_13.4: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc6_13.5: %i32 = converted %.loc6_20, %.loc6_13.4 [template = constants.%.28]
-// CHECK:STDOUT:   %Class.loc6: type = class_type @Class, @Class(constants.%.4, constants.%.28) [template = constants.%Class.3]
+// CHECK:STDOUT:   %.loc6_13.1: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_13.2: <bound method> = bound_method %.loc6_20, %.loc6_13.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc6_13.3: <specific function> = specific_function %.loc6_13.2, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked.loc6: init %i32 = call %.loc6_13.3(%.loc6_20) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc6_13.4: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc6_13.5: %i32 = converted %.loc6_20, %.loc6_13.4 [template = constants.%.32]
+// CHECK:STDOUT:   %Class.loc6: type = class_type @Class, @Class(constants.%.4, constants.%.32) [template = constants.%Class.3]
 // CHECK:STDOUT:   %a.var: ref %Class.3 = var a
 // CHECK:STDOUT:   %a: ref %Class.3 = bind_name a, %a.var
 // CHECK:STDOUT:   %Class.ref.loc9: %Class.type = name_ref Class, %Class.decl [template = constants.%Class.1]
 // CHECK:STDOUT:   %.loc9_15: %empty_tuple.type = tuple_literal ()
-// CHECK:STDOUT:   %.loc9_18: Core.IntLiteral = int_value 0 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_18: Core.IntLiteral = int_value 0 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc9_13.1: type = converted %.loc9_15, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
-// CHECK:STDOUT:   %.loc9_13.2: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_13.3: <bound method> = bound_method %.loc9_18, %.loc9_13.2 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc9_13.4: <specific function> = specific_function %.loc9_13.3, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc9: init %i32 = call %.loc9_13.4(%.loc9_18) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_13.5: %i32 = value_of_initializer %int.convert_checked.loc9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc9_13.6: %i32 = converted %.loc9_18, %.loc9_13.5 [template = constants.%.33]
-// CHECK:STDOUT:   %Class.loc9: type = class_type @Class, @Class(constants.%empty_tuple.type, constants.%.33) [template = constants.%Class.4]
+// CHECK:STDOUT:   %.loc9_13.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_13.3: <bound method> = bound_method %.loc9_18, %.loc9_13.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_13.4: <specific function> = specific_function %.loc9_13.3, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked.loc9: init %i32 = call %.loc9_13.4(%.loc9_18) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_13.5: %i32 = value_of_initializer %int.convert_checked.loc9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc9_13.6: %i32 = converted %.loc9_18, %.loc9_13.5 [template = constants.%.37]
+// CHECK:STDOUT:   %Class.loc9: type = class_type @Class, @Class(constants.%empty_tuple.type, constants.%.37) [template = constants.%Class.4]
 // CHECK:STDOUT:   %b.var: ref %Class.4 = var b
 // CHECK:STDOUT:   %b: ref %Class.4 = bind_name b, %b.var
 // CHECK:STDOUT: }
@@ -205,20 +205,20 @@ class Outer(T:! type) {
 // CHECK:STDOUT:   %N.patt.loc4_23.2 => constants.%N.1
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @Class(constants.%.4, constants.%.28) {
+// CHECK:STDOUT: specific @Class(constants.%.4, constants.%.32) {
 // CHECK:STDOUT:   %T.loc4_13.2 => constants.%.4
 // CHECK:STDOUT:   %T.patt.loc4_13.2 => constants.%.4
-// CHECK:STDOUT:   %N.loc4_23.2 => constants.%.28
-// CHECK:STDOUT:   %N.patt.loc4_23.2 => constants.%.28
+// CHECK:STDOUT:   %N.loc4_23.2 => constants.%.32
+// CHECK:STDOUT:   %N.patt.loc4_23.2 => constants.%.32
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @Class(constants.%empty_tuple.type, constants.%.33) {
+// CHECK:STDOUT: specific @Class(constants.%empty_tuple.type, constants.%.37) {
 // CHECK:STDOUT:   %T.loc4_13.2 => constants.%empty_tuple.type
 // CHECK:STDOUT:   %T.patt.loc4_13.2 => constants.%empty_tuple.type
-// CHECK:STDOUT:   %N.loc4_23.2 => constants.%.33
-// CHECK:STDOUT:   %N.patt.loc4_23.2 => constants.%.33
+// CHECK:STDOUT:   %N.loc4_23.2 => constants.%.37
+// CHECK:STDOUT:   %N.patt.loc4_23.2 => constants.%.37
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }

toolchain/check/testdata/class/generic/member_out_of_line.carbon

@@ -97,7 +97,7 @@ class Generic(T:! type) {
   fn WrongType();
 }
 
-// CHECK:STDERR: fail_mismatched_wrong_arg_type.carbon:[[@LINE+6]]:12: error: redeclaration differs at parameter 1 [RedeclParamDiffers]
+// CHECK:STDERR: fail_mismatched_wrong_arg_type.carbon:[[@LINE+6]]:12: error: type `()` of parameter 1 in redeclaration differs from previous parameter type `type` [RedeclParamDiffersType]
 // CHECK:STDERR: fn Generic(T:! ()).WrongType() {}
 // CHECK:STDERR:            ^~~~~~
 // CHECK:STDERR: fail_mismatched_wrong_arg_type.carbon:[[@LINE-7]]:15: note: previous declaration's corresponding parameter here [RedeclParamPrevious]

toolchain/check/testdata/class/generic/redeclare.carbon

@@ -64,7 +64,7 @@ class C(T:! type, U:! i32) {}
 library "[[@TEST_NAME]]";
 
 class D(T:! type);
-// CHECK:STDERR: fail_mismatch_param_type.carbon:[[@LINE+7]]:9: error: redeclaration differs at parameter 1 [RedeclParamDiffers]
+// CHECK:STDERR: fail_mismatch_param_type.carbon:[[@LINE+7]]:9: error: type `i32` of parameter 1 in redeclaration differs from previous parameter type `type` [RedeclParamDiffersType]
 // CHECK:STDERR: class D(T:! i32) {}
 // CHECK:STDERR:         ^~~~~~~
 // CHECK:STDERR: fail_mismatch_param_type.carbon:[[@LINE-4]]:9: note: previous declaration's corresponding parameter here [RedeclParamPrevious]

toolchain/check/testdata/class/import.carbon

@@ -166,25 +166,25 @@ fn Run() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.4) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.8, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.4) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %struct.2: %Field = struct_value (%.32) [template]
-// CHECK:STDOUT:   %.33: type = unbound_element_type %Field, %i32 [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %Convert.14 [template]
-// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.4) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.4) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %struct.2: %Field = struct_value (%.36) [template]
+// CHECK:STDOUT:   %.37: type = unbound_element_type %Field, %i32 [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.39: <bound method> = bound_method %.38, %Convert.14 [template]
+// CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.4) [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %ForwardDeclared.1: type = class_type @ForwardDeclared.1 [template]
 // CHECK:STDOUT:   %struct.3: %ForwardDeclared.1 = struct_value () [template]
 // CHECK:STDOUT:   %F.type: type = fn_type @F [template]
 // CHECK:STDOUT:   %F: %F.type = struct_value () [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.38: type = ptr_type %ForwardDeclared.1 [template]
+// CHECK:STDOUT:   %.42: type = ptr_type %ForwardDeclared.1 [template]
 // CHECK:STDOUT:   %Incomplete: type = class_type @Incomplete [template]
-// CHECK:STDOUT:   %.39: type = ptr_type %Incomplete [template]
+// CHECK:STDOUT:   %.43: type = ptr_type %Incomplete [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -199,7 +199,7 @@ fn Run() {
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %import_ref.5 = import_ref Main//a, inst+4, unloaded
 // CHECK:STDOUT:   %import_ref.6 = import_ref Main//a, inst+9, unloaded
-// CHECK:STDOUT:   %import_ref.7: %.33 = import_ref Main//a, inst+29, loaded [template = %.1]
+// CHECK:STDOUT:   %import_ref.7: %.37 = import_ref Main//a, inst+29, loaded [template = %.1]
 // CHECK:STDOUT:   %import_ref.44 = import_ref Main//a, inst+34, unloaded
 // CHECK:STDOUT:   %import_ref.45: %F.type = import_ref Main//a, inst+41, loaded [template = constants.%F]
 // CHECK:STDOUT:   %import_ref.46: %G.type = import_ref Main//a, inst+52, loaded [template = constants.%G]
@@ -263,25 +263,25 @@ fn Run() {
 // CHECK:STDOUT:   %b: ref %Field = bind_name b, %b.var
 // CHECK:STDOUT:   %.loc9_24: Core.IntLiteral = int_value 1 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc9_25.1: %.9 = struct_literal (%.loc9_24)
-// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_24, %.loc9_25.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.4) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc9: init %i32 = call %.loc9_25.4(%.loc9_24) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc9_25.5: init %i32 = converted %.loc9_24, %int.convert_checked.loc9 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_25.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_25.3: <bound method> = bound_method %.loc9_24, %.loc9_25.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_25.4: <specific function> = specific_function %.loc9_25.3, @Convert.2(constants.%.4) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc9: init %i32 = call %.loc9_25.4(%.loc9_24) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc9_25.5: init %i32 = converted %.loc9_24, %int.convert_checked.loc9 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc9_25.6: ref %i32 = class_element_access %b.var, element0
-// CHECK:STDOUT:   %.loc9_25.7: init %i32 = initialize_from %.loc9_25.5 to %.loc9_25.6 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_25.7: init %i32 = initialize_from %.loc9_25.5 to %.loc9_25.6 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc9_25.8: init %Field = class_init (%.loc9_25.7), %b.var [template = constants.%struct.2]
 // CHECK:STDOUT:   %.loc9_26: init %Field = converted %.loc9_25.1, %.loc9_25.8 [template = constants.%struct.2]
 // CHECK:STDOUT:   assign %b.var, %.loc9_26
 // CHECK:STDOUT:   %b.ref: ref %Field = name_ref b, %b
-// CHECK:STDOUT:   %x.ref: %.33 = name_ref x, imports.%import_ref.7 [template = imports.%.1]
+// CHECK:STDOUT:   %x.ref: %.37 = name_ref x, imports.%import_ref.7 [template = imports.%.1]
 // CHECK:STDOUT:   %.loc10_4: ref %i32 = class_element_access %b.ref, element0
-// CHECK:STDOUT:   %.loc10_9: Core.IntLiteral = int_value 2 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc10_7.1: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_7.2: <bound method> = bound_method %.loc10_9, %.loc10_7.1 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc10_7.3: <specific function> = specific_function %.loc10_7.2, @Convert.2(constants.%.4) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc10: init %i32 = call %.loc10_7.3(%.loc10_9) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc10_7.4: init %i32 = converted %.loc10_9, %int.convert_checked.loc10 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc10_9: Core.IntLiteral = int_value 2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc10_7.1: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_7.2: <bound method> = bound_method %.loc10_9, %.loc10_7.1 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc10_7.3: <specific function> = specific_function %.loc10_7.2, @Convert.2(constants.%.4) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc10: init %i32 = call %.loc10_7.3(%.loc10_9) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc10_7.4: init %i32 = converted %.loc10_9, %int.convert_checked.loc10 [template = constants.%.41]
 // CHECK:STDOUT:   assign %.loc10_4, %.loc10_7.4
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc12: type = name_ref ForwardDeclared, imports.%import_ref.3 [template = constants.%ForwardDeclared.1]
 // CHECK:STDOUT:   %c.var: ref %ForwardDeclared.1 = var c
@@ -298,23 +298,23 @@ fn Run() {
 // CHECK:STDOUT:   %c.ref.loc14: ref %ForwardDeclared.1 = name_ref c, %c
 // CHECK:STDOUT:   %G.ref: %G.type = name_ref G, imports.%import_ref.46 [template = constants.%G]
 // CHECK:STDOUT:   %.loc14_4: <bound method> = bound_method %c.ref.loc14, %G.ref
-// CHECK:STDOUT:   %.loc14_3: %.38 = addr_of %c.ref.loc14
+// CHECK:STDOUT:   %.loc14_3: %.42 = addr_of %c.ref.loc14
 // CHECK:STDOUT:   %G.call: init %empty_tuple.type = call %.loc14_4(%.loc14_3)
 // CHECK:STDOUT:   %ForwardDeclared.ref.loc16: type = name_ref ForwardDeclared, imports.%import_ref.3 [template = constants.%ForwardDeclared.1]
-// CHECK:STDOUT:   %.loc16_25: type = ptr_type %ForwardDeclared.1 [template = constants.%.38]
-// CHECK:STDOUT:   %d.var: ref %.38 = var d
-// CHECK:STDOUT:   %d: ref %.38 = bind_name d, %d.var
+// CHECK:STDOUT:   %.loc16_25: type = ptr_type %ForwardDeclared.1 [template = constants.%.42]
+// CHECK:STDOUT:   %d.var: ref %.42 = var d
+// CHECK:STDOUT:   %d: ref %.42 = bind_name d, %d.var
 // CHECK:STDOUT:   %c.ref.loc16: ref %ForwardDeclared.1 = name_ref c, %c
-// CHECK:STDOUT:   %.loc16_29: %.38 = addr_of %c.ref.loc16
+// CHECK:STDOUT:   %.loc16_29: %.42 = addr_of %c.ref.loc16
 // CHECK:STDOUT:   assign %d.var, %.loc16_29
 // CHECK:STDOUT:   %Incomplete.ref: type = name_ref Incomplete, imports.%import_ref.4 [template = constants.%Incomplete]
-// CHECK:STDOUT:   %.loc18: type = ptr_type %Incomplete [template = constants.%.39]
-// CHECK:STDOUT:   %e.var: ref %.39 = var e
-// CHECK:STDOUT:   %e: ref %.39 = bind_name e, %e.var
+// CHECK:STDOUT:   %.loc18: type = ptr_type %Incomplete [template = constants.%.43]
+// CHECK:STDOUT:   %e.var: ref %.43 = var e
+// CHECK:STDOUT:   %e: ref %.43 = bind_name e, %e.var
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F[%self.param_patt: %ForwardDeclared.1]();
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @G[addr <unexpected>.inst+437: %.38]();
+// CHECK:STDOUT: fn @G[addr <unexpected>.inst+443: %.42]();
 // CHECK:STDOUT:

toolchain/check/testdata/class/import_base.carbon

@@ -145,20 +145,20 @@ fn Run() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.34: <bound method> = bound_method %.10, %Convert.14 [template]
-// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.11, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %struct.1: %Base = struct_value (%.36, %.39) [template]
+// CHECK:STDOUT:   %.37: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.10, %Convert.14 [template]
+// CHECK:STDOUT:   %.39: <specific function> = specific_function %.38, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.40: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.11, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %struct.1: %Base = struct_value (%.40, %.43) [template]
 // CHECK:STDOUT:   %struct.2: %Child = struct_value (%struct.1) [template]
-// CHECK:STDOUT:   %.40: type = unbound_element_type %Base, %i32 [template]
-// CHECK:STDOUT:   %.41: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.42: <bound method> = bound_method %.41, %Convert.14 [template]
-// CHECK:STDOUT:   %.43: <specific function> = specific_function %.42, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.44: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.44: type = unbound_element_type %Base, %i32 [template]
+// CHECK:STDOUT:   %.45: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.46: <bound method> = bound_method %.45, %Convert.14 [template]
+// CHECK:STDOUT:   %.47: <specific function> = specific_function %.46, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.48: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %F.type: type = fn_type @F [template]
 // CHECK:STDOUT:   %F: %F.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -174,7 +174,7 @@ fn Run() {
 // CHECK:STDOUT:   %import_ref.3 = import_ref Main//a, inst+4, unloaded
 // CHECK:STDOUT:   %import_ref.4: %F.type = import_ref Main//a, inst+10, loaded [template = constants.%F]
 // CHECK:STDOUT:   %import_ref.5 = import_ref Main//a, inst+19, unloaded
-// CHECK:STDOUT:   %import_ref.6: %.40 = import_ref Main//a, inst+40, loaded [template = %.1]
+// CHECK:STDOUT:   %import_ref.6: %.44 = import_ref Main//a, inst+40, loaded [template = %.1]
 // CHECK:STDOUT:   %import_ref.7 = import_ref Main//a, inst+45, unloaded
 // CHECK:STDOUT:   %import_ref.8 = import_ref Main//a, inst+50, unloaded
 // CHECK:STDOUT:   %import_ref.9 = import_ref Main//a, inst+54, unloaded
@@ -218,37 +218,37 @@ fn Run() {
 // CHECK:STDOUT:   %.loc7_46: Core.IntLiteral = int_value 1 [template = constants.%.11]
 // CHECK:STDOUT:   %.loc7_47.1: %.12 = struct_literal (%.loc7_33, %.loc7_46)
 // CHECK:STDOUT:   %.loc7_48.1: %.13 = struct_literal (%.loc7_47.1)
-// CHECK:STDOUT:   %.loc7_47.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_47.3: <bound method> = bound_method %.loc7_33, %.loc7_47.2 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc7_47.4: <specific function> = specific_function %.loc7_47.3, @Convert.2(constants.%.1) [template = constants.%.35]
-// CHECK:STDOUT:   %int.convert_checked.loc7_47.1: init %i32 = call %.loc7_47.4(%.loc7_33) [template = constants.%.36]
-// CHECK:STDOUT:   %.loc7_47.5: init %i32 = converted %.loc7_33, %int.convert_checked.loc7_47.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc7_47.2: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_47.3: <bound method> = bound_method %.loc7_33, %.loc7_47.2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc7_47.4: <specific function> = specific_function %.loc7_47.3, @Convert.2(constants.%.1) [template = constants.%.39]
+// CHECK:STDOUT:   %int.convert_checked.loc7_47.1: init %i32 = call %.loc7_47.4(%.loc7_33) [template = constants.%.40]
+// CHECK:STDOUT:   %.loc7_47.5: init %i32 = converted %.loc7_33, %int.convert_checked.loc7_47.1 [template = constants.%.40]
 // CHECK:STDOUT:   %.loc7_48.2: ref %Base = class_element_access %a.var, element0
 // CHECK:STDOUT:   %.loc7_47.6: ref %i32 = class_element_access %.loc7_48.2, element0
-// CHECK:STDOUT:   %.loc7_47.7: init %i32 = initialize_from %.loc7_47.5 to %.loc7_47.6 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc7_47.8: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_47.9: <bound method> = bound_method %.loc7_46, %.loc7_47.8 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc7_47.10: <specific function> = specific_function %.loc7_47.9, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc7_47.2: init %i32 = call %.loc7_47.10(%.loc7_46) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc7_47.11: init %i32 = converted %.loc7_46, %int.convert_checked.loc7_47.2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_47.7: init %i32 = initialize_from %.loc7_47.5 to %.loc7_47.6 [template = constants.%.40]
+// CHECK:STDOUT:   %.loc7_47.8: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_47.9: <bound method> = bound_method %.loc7_46, %.loc7_47.8 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc7_47.10: <specific function> = specific_function %.loc7_47.9, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc7_47.2: init %i32 = call %.loc7_47.10(%.loc7_46) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc7_47.11: init %i32 = converted %.loc7_46, %int.convert_checked.loc7_47.2 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc7_47.12: ref %i32 = class_element_access %.loc7_48.2, element1
-// CHECK:STDOUT:   %.loc7_47.13: init %i32 = initialize_from %.loc7_47.11 to %.loc7_47.12 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc7_47.13: init %i32 = initialize_from %.loc7_47.11 to %.loc7_47.12 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc7_47.14: init %Base = class_init (%.loc7_47.7, %.loc7_47.13), %.loc7_48.2 [template = constants.%struct.1]
 // CHECK:STDOUT:   %.loc7_48.3: init %Base = converted %.loc7_47.1, %.loc7_47.14 [template = constants.%struct.1]
 // CHECK:STDOUT:   %.loc7_48.4: init %Child = class_init (%.loc7_48.3), %a.var [template = constants.%struct.2]
 // CHECK:STDOUT:   %.loc7_49: init %Child = converted %.loc7_48.1, %.loc7_48.4 [template = constants.%struct.2]
 // CHECK:STDOUT:   assign %a.var, %.loc7_49
 // CHECK:STDOUT:   %a.ref.loc8: ref %Child = name_ref a, %a
-// CHECK:STDOUT:   %x.ref: %.40 = name_ref x, imports.%import_ref.6 [template = imports.%.1]
+// CHECK:STDOUT:   %x.ref: %.44 = name_ref x, imports.%import_ref.6 [template = imports.%.1]
 // CHECK:STDOUT:   %.loc8_4.1: ref %Base = class_element_access %a.ref.loc8, element0
 // CHECK:STDOUT:   %.loc8_4.2: ref %Base = converted %a.ref.loc8, %.loc8_4.1
 // CHECK:STDOUT:   %.loc8_4.3: ref %i32 = class_element_access %.loc8_4.2, element0
-// CHECK:STDOUT:   %.loc8_9: Core.IntLiteral = int_value 2 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc8_7.1: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_7.2: <bound method> = bound_method %.loc8_9, %.loc8_7.1 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc8_7.3: <specific function> = specific_function %.loc8_7.2, @Convert.2(constants.%.1) [template = constants.%.43]
-// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_7.3(%.loc8_9) [template = constants.%.44]
-// CHECK:STDOUT:   %.loc8_7.4: init %i32 = converted %.loc8_9, %int.convert_checked.loc8 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc8_9: Core.IntLiteral = int_value 2 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc8_7.1: %Convert.type.2 = interface_witness_access constants.%.37, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_7.2: <bound method> = bound_method %.loc8_9, %.loc8_7.1 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc8_7.3: <specific function> = specific_function %.loc8_7.2, @Convert.2(constants.%.1) [template = constants.%.47]
+// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_7.3(%.loc8_9) [template = constants.%.48]
+// CHECK:STDOUT:   %.loc8_7.4: init %i32 = converted %.loc8_9, %int.convert_checked.loc8 [template = constants.%.48]
 // CHECK:STDOUT:   assign %.loc8_4.3, %.loc8_7.4
 // CHECK:STDOUT:   %a.ref.loc9: ref %Child = name_ref a, %a
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, imports.%import_ref.4 [template = constants.%F]

toolchain/check/testdata/class/inheritance_access.carbon

@@ -478,22 +478,22 @@ class B {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 5 [template]
 // CHECK:STDOUT:   %SomeProtectedFunction.type: type = fn_type @SomeProtectedFunction [template]
 // CHECK:STDOUT:   %SomeProtectedFunction: %SomeProtectedFunction.type = struct_value () [template]
-// CHECK:STDOUT:   %.26: type = struct_type {} [template]
-// CHECK:STDOUT:   %.27: <witness> = complete_type_witness %.26 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {} [template]
+// CHECK:STDOUT:   %.31: <witness> = complete_type_witness %.30 [template]
 // CHECK:STDOUT:   %B: type = class_type @B [template]
-// CHECK:STDOUT:   %.29: type = unbound_element_type %B, %A [template]
+// CHECK:STDOUT:   %.33: type = unbound_element_type %B, %A [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
 // CHECK:STDOUT:   %H.type: type = fn_type @H [template]
 // CHECK:STDOUT:   %H: %H.type = struct_value () [template]
-// CHECK:STDOUT:   %.30: type = struct_type {.base: %A} [template]
-// CHECK:STDOUT:   %.31: <witness> = complete_type_witness %.30 [template]
+// CHECK:STDOUT:   %.34: type = struct_type {.base: %A} [template]
+// CHECK:STDOUT:   %.35: <witness> = complete_type_witness %.34 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -522,12 +522,12 @@ class B {
 // CHECK:STDOUT:   %.loc5_32.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_32.3: type = converted %int.make_type_signed, %.loc5_32.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_38: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc5_39.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc5_39.2: <bound method> = bound_method %.loc5_38, %.loc5_39.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc5_39.3: <specific function> = specific_function %.loc5_39.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc5_39.3(%.loc5_38) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_39.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_39.5: %i32 = converted %.loc5_38, %.loc5_39.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc5_39.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc5_39.2: <bound method> = bound_method %.loc5_38, %.loc5_39.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc5_39.3: <specific function> = specific_function %.loc5_39.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc5_39.3(%.loc5_38) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_39.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_39.5: %i32 = converted %.loc5_38, %.loc5_39.4 [template = constants.%.29]
 // CHECK:STDOUT:   %SOME_CONSTANT: %i32 = bind_name SOME_CONSTANT, %.loc5_39.5
 // CHECK:STDOUT:   %SomeProtectedFunction.decl: %SomeProtectedFunction.type = fn_decl @SomeProtectedFunction [template = constants.%SomeProtectedFunction] {
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
@@ -540,7 +540,7 @@ class B {
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param0
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc9: <witness> = complete_type_witness %.26 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc9: <witness> = complete_type_witness %.30 [template = constants.%.31]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%A
@@ -550,7 +550,7 @@ class B {
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @B {
 // CHECK:STDOUT:   %A.ref: type = name_ref A, file.%A.decl [template = constants.%A]
-// CHECK:STDOUT:   %.loc12: %.29 = base_decl %A, element0 [template]
+// CHECK:STDOUT:   %.loc12: %.33 = base_decl %A, element0 [template]
 // CHECK:STDOUT:   %G.decl: %G.type = fn_decl @G [template = constants.%G] {
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0
@@ -573,7 +573,7 @@ class B {
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param0
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc21: <witness> = complete_type_witness %.30 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc21: <witness> = complete_type_witness %.34 [template = constants.%.35]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%B
@@ -586,12 +586,12 @@ class B {
 // CHECK:STDOUT: fn @SomeProtectedFunction() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc7_12: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc7_13.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_13.2: <bound method> = bound_method %.loc7_12, %.loc7_13.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc7_13.3: <specific function> = specific_function %.loc7_13.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc7_13.3(%.loc7_12) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc7_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc7_13.5: %i32 = converted %.loc7_12, %.loc7_13.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc7_13.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_13.2: <bound method> = bound_method %.loc7_12, %.loc7_13.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc7_13.3: <specific function> = specific_function %.loc7_13.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc7_13.3(%.loc7_12) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc7_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc7_13.5: %i32 = converted %.loc7_12, %.loc7_13.4 [template = constants.%.29]
 // CHECK:STDOUT:   return %.loc7_13.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -954,21 +954,21 @@ class B {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.26: type = struct_type {} [template]
-// CHECK:STDOUT:   %.27: <witness> = complete_type_witness %.26 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {} [template]
+// CHECK:STDOUT:   %.31: <witness> = complete_type_witness %.30 [template]
 // CHECK:STDOUT:   %Internal: type = class_type @Internal [template]
 // CHECK:STDOUT:   %B: type = class_type @B [template]
-// CHECK:STDOUT:   %.29: type = unbound_element_type %B, %Internal [template]
+// CHECK:STDOUT:   %.33: type = unbound_element_type %B, %Internal [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
 // CHECK:STDOUT:   %SomeFunc.type: type = fn_type @SomeFunc [template]
 // CHECK:STDOUT:   %SomeFunc: %SomeFunc.type = struct_value () [template]
-// CHECK:STDOUT:   %.30: type = struct_type {.internal: %Internal} [template]
-// CHECK:STDOUT:   %.31: <witness> = complete_type_witness %.30 [template]
+// CHECK:STDOUT:   %.34: type = struct_type {.internal: %Internal} [template]
+// CHECK:STDOUT:   %.35: <witness> = complete_type_witness %.34 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -999,26 +999,26 @@ class B {
 // CHECK:STDOUT:   %.loc5_42.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_42.3: type = converted %int.make_type_signed.loc5, %.loc5_42.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc5_48: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc5_49.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc5_49.2: <bound method> = bound_method %.loc5_48, %.loc5_49.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc5_49.3: <specific function> = specific_function %.loc5_49.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc5: init %i32 = call %.loc5_49.3(%.loc5_48) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_49.4: %i32 = value_of_initializer %int.convert_checked.loc5 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc5_49.5: %i32 = converted %.loc5_48, %.loc5_49.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc5_49.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc5_49.2: <bound method> = bound_method %.loc5_48, %.loc5_49.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc5_49.3: <specific function> = specific_function %.loc5_49.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc5: init %i32 = call %.loc5_49.3(%.loc5_48) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_49.4: %i32 = value_of_initializer %int.convert_checked.loc5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc5_49.5: %i32 = converted %.loc5_48, %.loc5_49.4 [template = constants.%.29]
 // CHECK:STDOUT:   %SOME_PROTECTED_CONSTANT: %i32 = bind_name SOME_PROTECTED_CONSTANT, %.loc5_49.5
 // CHECK:STDOUT:   %.loc6_38.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc6: init type = call constants.%Int(%.loc6_38.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_38.2: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_38.3: type = converted %int.make_type_signed.loc6, %.loc6_38.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc6_44: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc6_45.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc6_45.2: <bound method> = bound_method %.loc6_44, %.loc6_45.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc6_45.3: <specific function> = specific_function %.loc6_45.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc6: init %i32 = call %.loc6_45.3(%.loc6_44) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc6_45.4: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc6_45.5: %i32 = converted %.loc6_44, %.loc6_45.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc6_45.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc6_45.2: <bound method> = bound_method %.loc6_44, %.loc6_45.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc6_45.3: <specific function> = specific_function %.loc6_45.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc6: init %i32 = call %.loc6_45.3(%.loc6_44) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc6_45.4: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc6_45.5: %i32 = converted %.loc6_44, %.loc6_45.4 [template = constants.%.29]
 // CHECK:STDOUT:   %SOME_PRIVATE_CONSTANT: %i32 = bind_name SOME_PRIVATE_CONSTANT, %.loc6_45.5
-// CHECK:STDOUT:   %.loc7: <witness> = complete_type_witness %.26 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc7: <witness> = complete_type_witness %.30 [template = constants.%.31]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%A
@@ -1032,14 +1032,14 @@ class B {
 // CHECK:STDOUT:   %.loc10_36.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:   %.loc10_36.3: type = converted %int.make_type_signed, %.loc10_36.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc10_42: Core.IntLiteral = int_value 5 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc10_43.1: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc10_43.2: <bound method> = bound_method %.loc10_42, %.loc10_43.1 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc10_43.3: <specific function> = specific_function %.loc10_43.2, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc10_43.3(%.loc10_42) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_43.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc10_43.5: %i32 = converted %.loc10_42, %.loc10_43.4 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc10_43.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc10_43.2: <bound method> = bound_method %.loc10_42, %.loc10_43.1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc10_43.3: <specific function> = specific_function %.loc10_43.2, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc10_43.3(%.loc10_42) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_43.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc10_43.5: %i32 = converted %.loc10_42, %.loc10_43.4 [template = constants.%.29]
 // CHECK:STDOUT:   %INTERNAL_CONSTANT: %i32 = bind_name INTERNAL_CONSTANT, %.loc10_43.5
-// CHECK:STDOUT:   %.loc11: <witness> = complete_type_witness %.26 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11: <witness> = complete_type_witness %.30 [template = constants.%.31]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%Internal
@@ -1048,7 +1048,7 @@ class B {
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @B {
 // CHECK:STDOUT:   %Internal.ref: type = name_ref Internal, file.%Internal.decl [template = constants.%Internal]
-// CHECK:STDOUT:   %.loc14: %.29 = field_decl internal, element0 [template]
+// CHECK:STDOUT:   %.loc14: %.33 = field_decl internal, element0 [template]
 // CHECK:STDOUT:   %G.decl: %G.type = fn_decl @G [template = constants.%G] {
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0
@@ -1076,7 +1076,7 @@ class B {
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc46: <witness> = complete_type_witness %.30 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc46: <witness> = complete_type_witness %.34 [template = constants.%.35]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%B
@@ -1097,7 +1097,7 @@ class B {
 // CHECK:STDOUT: fn @SomeFunc[%self.param_patt: %B]() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %self.ref: %B = name_ref self, %self
-// CHECK:STDOUT:   %internal.ref: %.29 = name_ref internal, @B.%.loc14 [template = @B.%.loc14]
+// CHECK:STDOUT:   %internal.ref: %.33 = name_ref internal, @B.%.loc14 [template = @B.%.loc14]
 // CHECK:STDOUT:   %.loc44_16.1: ref %Internal = class_element_access %self.ref, element0
 // CHECK:STDOUT:   %.loc44_16.2: %Internal = bind_value %.loc44_16.1
 // CHECK:STDOUT:   %INTERNAL_CONSTANT.ref: <error> = name_ref INTERNAL_CONSTANT, <error> [template = <error>]

toolchain/check/testdata/class/init_adapt.carbon

@@ -110,14 +110,14 @@ var e: C = MakeAdaptC();
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.8, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct: %C = struct_value (%.32, %.35) [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct: %C = struct_value (%.36, %.39) [template]
 // CHECK:STDOUT:   %MakeC.type: type = fn_type @MakeC [template]
 // CHECK:STDOUT:   %MakeC: %MakeC.type = struct_value () [template]
 // CHECK:STDOUT:   %MakeAdaptC.type: type = fn_type @MakeAdaptC [template]
@@ -213,21 +213,21 @@ var e: C = MakeAdaptC();
 // CHECK:STDOUT:   %.loc13_18: Core.IntLiteral = int_value 1 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc13_26: Core.IntLiteral = int_value 2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc13_27.1: %.9 = struct_literal (%.loc13_18, %.loc13_26)
-// CHECK:STDOUT:   %.loc13_27.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_27.3: <bound method> = bound_method %.loc13_18, %.loc13_27.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_27.4: <specific function> = specific_function %.loc13_27.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc13_27.1: init %i32 = call %.loc13_27.4(%.loc13_18) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_27.5: init %i32 = converted %.loc13_18, %int.convert_checked.loc13_27.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc13_27.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_27.3: <bound method> = bound_method %.loc13_18, %.loc13_27.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_27.4: <specific function> = specific_function %.loc13_27.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc13_27.1: init %i32 = call %.loc13_27.4(%.loc13_18) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_27.5: init %i32 = converted %.loc13_18, %int.convert_checked.loc13_27.1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc13_27.6: ref %C = temporary_storage
 // CHECK:STDOUT:   %.loc13_27.7: ref %i32 = class_element_access %.loc13_27.6, element0
-// CHECK:STDOUT:   %.loc13_27.8: init %i32 = initialize_from %.loc13_27.5 to %.loc13_27.7 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_27.9: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_27.10: <bound method> = bound_method %.loc13_26, %.loc13_27.9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_27.11: <specific function> = specific_function %.loc13_27.10, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc13_27.2: init %i32 = call %.loc13_27.11(%.loc13_26) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc13_27.12: init %i32 = converted %.loc13_26, %int.convert_checked.loc13_27.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_27.8: init %i32 = initialize_from %.loc13_27.5 to %.loc13_27.7 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_27.9: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_27.10: <bound method> = bound_method %.loc13_26, %.loc13_27.9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_27.11: <specific function> = specific_function %.loc13_27.10, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc13_27.2: init %i32 = call %.loc13_27.11(%.loc13_26) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_27.12: init %i32 = converted %.loc13_26, %int.convert_checked.loc13_27.2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_27.13: ref %i32 = class_element_access %.loc13_27.6, element1
-// CHECK:STDOUT:   %.loc13_27.14: init %i32 = initialize_from %.loc13_27.12 to %.loc13_27.13 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_27.14: init %i32 = initialize_from %.loc13_27.12 to %.loc13_27.13 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_27.15: init %C = class_init (%.loc13_27.8, %.loc13_27.14), %.loc13_27.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_27.16: ref %C = temporary %.loc13_27.6, %.loc13_27.15
 // CHECK:STDOUT:   %.loc13_28.1: ref %C = converted %.loc13_27.1, %.loc13_27.16
@@ -279,14 +279,14 @@ var e: C = MakeAdaptC();
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.30: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.8, %Convert.14 [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.35: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct: %C = struct_value (%.32, %.35) [template]
+// CHECK:STDOUT:   %.33: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.34: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <specific function> = specific_function %.34, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.36: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct: %C = struct_value (%.36, %.39) [template]
 // CHECK:STDOUT:   %MakeC.type: type = fn_type @MakeC [template]
 // CHECK:STDOUT:   %MakeC: %MakeC.type = struct_value () [template]
 // CHECK:STDOUT:   %MakeAdaptC.type: type = fn_type @MakeAdaptC [template]
@@ -382,21 +382,21 @@ var e: C = MakeAdaptC();
 // CHECK:STDOUT:   %.loc13_18: Core.IntLiteral = int_value 1 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc13_26: Core.IntLiteral = int_value 2 [template = constants.%.8]
 // CHECK:STDOUT:   %.loc13_27.1: %.9 = struct_literal (%.loc13_18, %.loc13_26)
-// CHECK:STDOUT:   %.loc13_27.2: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_27.3: <bound method> = bound_method %.loc13_18, %.loc13_27.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_27.4: <specific function> = specific_function %.loc13_27.3, @Convert.2(constants.%.1) [template = constants.%.31]
-// CHECK:STDOUT:   %int.convert_checked.loc13_27.1: init %i32 = call %.loc13_27.4(%.loc13_18) [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_27.5: init %i32 = converted %.loc13_18, %int.convert_checked.loc13_27.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc13_27.2: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_27.3: <bound method> = bound_method %.loc13_18, %.loc13_27.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_27.4: <specific function> = specific_function %.loc13_27.3, @Convert.2(constants.%.1) [template = constants.%.35]
+// CHECK:STDOUT:   %int.convert_checked.loc13_27.1: init %i32 = call %.loc13_27.4(%.loc13_18) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_27.5: init %i32 = converted %.loc13_18, %int.convert_checked.loc13_27.1 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc13_27.6: ref %C = temporary_storage
 // CHECK:STDOUT:   %.loc13_27.7: ref %i32 = class_element_access %.loc13_27.6, element0
-// CHECK:STDOUT:   %.loc13_27.8: init %i32 = initialize_from %.loc13_27.5 to %.loc13_27.7 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_27.9: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_27.10: <bound method> = bound_method %.loc13_26, %.loc13_27.9 [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_27.11: <specific function> = specific_function %.loc13_27.10, @Convert.2(constants.%.1) [template = constants.%.34]
-// CHECK:STDOUT:   %int.convert_checked.loc13_27.2: init %i32 = call %.loc13_27.11(%.loc13_26) [template = constants.%.35]
-// CHECK:STDOUT:   %.loc13_27.12: init %i32 = converted %.loc13_26, %int.convert_checked.loc13_27.2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_27.8: init %i32 = initialize_from %.loc13_27.5 to %.loc13_27.7 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_27.9: %Convert.type.2 = interface_witness_access constants.%.33, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_27.10: <bound method> = bound_method %.loc13_26, %.loc13_27.9 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_27.11: <specific function> = specific_function %.loc13_27.10, @Convert.2(constants.%.1) [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc13_27.2: init %i32 = call %.loc13_27.11(%.loc13_26) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_27.12: init %i32 = converted %.loc13_26, %int.convert_checked.loc13_27.2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_27.13: ref %i32 = class_element_access %.loc13_27.6, element1
-// CHECK:STDOUT:   %.loc13_27.14: init %i32 = initialize_from %.loc13_27.12 to %.loc13_27.13 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc13_27.14: init %i32 = initialize_from %.loc13_27.12 to %.loc13_27.13 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc13_27.15: init %C = class_init (%.loc13_27.8, %.loc13_27.14), %.loc13_27.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_27.16: ref %C = temporary %.loc13_27.6, %.loc13_27.15
 // CHECK:STDOUT:   %.loc13_28.1: ref %C = converted %.loc13_27.1, %.loc13_27.16

toolchain/check/testdata/class/init_as.carbon

@@ -36,14 +36,14 @@ fn F() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct: %Class = struct_value (%.31, %.34) [template]
+// CHECK:STDOUT:   %.32: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.33: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct: %Class = struct_value (%.35, %.38) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -101,21 +101,21 @@ fn F() -> i32 {
 // CHECK:STDOUT:   %.loc17_25: Core.IntLiteral = int_value 2 [template = constants.%.6]
 // CHECK:STDOUT:   %.loc17_26.1: %.7 = struct_literal (%.loc17_17, %.loc17_25)
 // CHECK:STDOUT:   %Class.ref: type = name_ref Class, file.%Class.decl [template = constants.%Class]
-// CHECK:STDOUT:   %.loc17_26.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_26.3: <bound method> = bound_method %.loc17_17, %.loc17_26.2 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc17_26.4: <specific function> = specific_function %.loc17_26.3, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc17_26.1: init %i32 = call %.loc17_26.4(%.loc17_17) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc17_26.5: init %i32 = converted %.loc17_17, %int.convert_checked.loc17_26.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc17_26.2: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_26.3: <bound method> = bound_method %.loc17_17, %.loc17_26.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_26.4: <specific function> = specific_function %.loc17_26.3, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc17_26.1: init %i32 = call %.loc17_26.4(%.loc17_17) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc17_26.5: init %i32 = converted %.loc17_17, %int.convert_checked.loc17_26.1 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc17_26.6: ref %Class = temporary_storage
 // CHECK:STDOUT:   %.loc17_26.7: ref %i32 = class_element_access %.loc17_26.6, element0
-// CHECK:STDOUT:   %.loc17_26.8: init %i32 = initialize_from %.loc17_26.5 to %.loc17_26.7 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc17_26.9: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_26.10: <bound method> = bound_method %.loc17_25, %.loc17_26.9 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc17_26.11: <specific function> = specific_function %.loc17_26.10, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc17_26.2: init %i32 = call %.loc17_26.11(%.loc17_25) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc17_26.12: init %i32 = converted %.loc17_25, %int.convert_checked.loc17_26.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc17_26.8: init %i32 = initialize_from %.loc17_26.5 to %.loc17_26.7 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc17_26.9: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_26.10: <bound method> = bound_method %.loc17_25, %.loc17_26.9 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc17_26.11: <specific function> = specific_function %.loc17_26.10, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc17_26.2: init %i32 = call %.loc17_26.11(%.loc17_25) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc17_26.12: init %i32 = converted %.loc17_25, %int.convert_checked.loc17_26.2 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc17_26.13: ref %i32 = class_element_access %.loc17_26.6, element1
-// CHECK:STDOUT:   %.loc17_26.14: init %i32 = initialize_from %.loc17_26.12 to %.loc17_26.13 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc17_26.14: init %i32 = initialize_from %.loc17_26.12 to %.loc17_26.13 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc17_26.15: init %Class = class_init (%.loc17_26.8, %.loc17_26.14), %.loc17_26.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc17_26.16: ref %Class = temporary %.loc17_26.6, %.loc17_26.15
 // CHECK:STDOUT:   %.loc17_28: ref %Class = converted %.loc17_26.1, %.loc17_26.16

toolchain/check/testdata/class/method.carbon

@@ -85,11 +85,11 @@ fn CallGOnInitializingExpr() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %struct: %Class = struct_value (%.31) [template]
+// CHECK:STDOUT:   %.32: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.33: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %struct: %Class = struct_value (%.35) [template]
 // CHECK:STDOUT:   %CallWithAddr.type: type = fn_type @CallWithAddr [template]
 // CHECK:STDOUT:   %CallWithAddr: %CallWithAddr.type = struct_value () [template]
 // CHECK:STDOUT:   %CallFThroughPointer.type: type = fn_type @CallFThroughPointer [template]
@@ -355,14 +355,14 @@ fn CallGOnInitializingExpr() -> i32 {
 // CHECK:STDOUT:   %.loc35_17: Core.IntLiteral = int_value 1 [template = constants.%.7]
 // CHECK:STDOUT:   %.loc35_18.1: %.8 = struct_literal (%.loc35_17)
 // CHECK:STDOUT:   %Class.ref: type = name_ref Class, file.%Class.decl [template = constants.%Class]
-// CHECK:STDOUT:   %.loc35_18.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc35_18.3: <bound method> = bound_method %.loc35_17, %.loc35_18.2 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc35_18.4: <specific function> = specific_function %.loc35_18.3, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc35_18.4(%.loc35_17) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc35_18.5: init %i32 = converted %.loc35_17, %int.convert_checked [template = constants.%.31]
+// CHECK:STDOUT:   %.loc35_18.2: %Convert.type.2 = interface_witness_access constants.%.32, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc35_18.3: <bound method> = bound_method %.loc35_17, %.loc35_18.2 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc35_18.4: <specific function> = specific_function %.loc35_18.3, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc35_18.4(%.loc35_17) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc35_18.5: init %i32 = converted %.loc35_17, %int.convert_checked [template = constants.%.35]
 // CHECK:STDOUT:   %.loc35_18.6: ref %Class = temporary_storage
 // CHECK:STDOUT:   %.loc35_18.7: ref %i32 = class_element_access %.loc35_18.6, element0
-// CHECK:STDOUT:   %.loc35_18.8: init %i32 = initialize_from %.loc35_18.5 to %.loc35_18.7 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc35_18.8: init %i32 = initialize_from %.loc35_18.5 to %.loc35_18.7 [template = constants.%.35]
 // CHECK:STDOUT:   %.loc35_18.9: init %Class = class_init (%.loc35_18.8), %.loc35_18.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc35_18.10: ref %Class = temporary %.loc35_18.6, %.loc35_18.9
 // CHECK:STDOUT:   %.loc35_20.1: ref %Class = converted %.loc35_18.1, %.loc35_18.10

toolchain/check/testdata/class/reorder.carbon

@@ -36,10 +36,10 @@ class Class {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -104,12 +104,12 @@ class Class {
 // CHECK:STDOUT: fn @F() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc17_12: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc17_13.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_13.2: <bound method> = bound_method %.loc17_12, %.loc17_13.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc17_13.3: <specific function> = specific_function %.loc17_13.2, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc17_13.3(%.loc17_12) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc17_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.28]
-// CHECK:STDOUT:   %.loc17_13.5: %i32 = converted %.loc17_12, %.loc17_13.4 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc17_13.1: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_13.2: <bound method> = bound_method %.loc17_12, %.loc17_13.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc17_13.3: <specific function> = specific_function %.loc17_13.2, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc17_13.3(%.loc17_12) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc17_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.32]
+// CHECK:STDOUT:   %.loc17_13.5: %i32 = converted %.loc17_12, %.loc17_13.4 [template = constants.%.32]
 // CHECK:STDOUT:   return %.loc17_13.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/class/reorder_qualified.carbon

@@ -85,29 +85,29 @@ class A {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.36: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.15, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %struct.1: %A = struct_value (%.39) [template]
-// CHECK:STDOUT:   %.41: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.42: type = struct_type {.b: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %.43: <bound method> = bound_method %.41, %Convert.14 [template]
-// CHECK:STDOUT:   %.44: <specific function> = specific_function %.43, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.45: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %struct.2: %B = struct_value (%.45) [template]
-// CHECK:STDOUT:   %.47: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.48: type = struct_type {.c: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %.49: <bound method> = bound_method %.47, %Convert.14 [template]
-// CHECK:STDOUT:   %.50: <specific function> = specific_function %.49, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.51: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %struct.3: %C = struct_value (%.51) [template]
-// CHECK:STDOUT:   %.53: Core.IntLiteral = int_value 4 [template]
-// CHECK:STDOUT:   %.54: type = struct_type {.d: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %.55: <bound method> = bound_method %.53, %Convert.14 [template]
-// CHECK:STDOUT:   %.56: <specific function> = specific_function %.55, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.57: %i32 = int_value 4 [template]
-// CHECK:STDOUT:   %struct.4: %D = struct_value (%.57) [template]
+// CHECK:STDOUT:   %.40: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.15, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %struct.1: %A = struct_value (%.43) [template]
+// CHECK:STDOUT:   %.45: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.46: type = struct_type {.b: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %.47: <bound method> = bound_method %.45, %Convert.14 [template]
+// CHECK:STDOUT:   %.48: <specific function> = specific_function %.47, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.49: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %struct.2: %B = struct_value (%.49) [template]
+// CHECK:STDOUT:   %.51: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.52: type = struct_type {.c: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %.53: <bound method> = bound_method %.51, %Convert.14 [template]
+// CHECK:STDOUT:   %.54: <specific function> = specific_function %.53, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.55: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %struct.3: %C = struct_value (%.55) [template]
+// CHECK:STDOUT:   %.57: Core.IntLiteral = int_value 4 [template]
+// CHECK:STDOUT:   %.58: type = struct_type {.d: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %.59: <bound method> = bound_method %.57, %Convert.14 [template]
+// CHECK:STDOUT:   %.60: <specific function> = specific_function %.59, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.61: %i32 = int_value 4 [template]
+// CHECK:STDOUT:   %struct.4: %D = struct_value (%.61) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -209,58 +209,58 @@ class A {
 // CHECK:STDOUT:   %a: ref %A = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc29_24: Core.IntLiteral = int_value 1 [template = constants.%.15]
 // CHECK:STDOUT:   %.loc29_25.1: %.16 = struct_literal (%.loc29_24)
-// CHECK:STDOUT:   %.loc29_25.2: %Convert.type.2 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc29_25.3: <bound method> = bound_method %.loc29_24, %.loc29_25.2 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc29_25.4: <specific function> = specific_function %.loc29_25.3, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc29: init %i32 = call %.loc29_25.4(%.loc29_24) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc29_25.5: init %i32 = converted %.loc29_24, %int.convert_checked.loc29 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc29_25.2: %Convert.type.2 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc29_25.3: <bound method> = bound_method %.loc29_24, %.loc29_25.2 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc29_25.4: <specific function> = specific_function %.loc29_25.3, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc29: init %i32 = call %.loc29_25.4(%.loc29_24) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc29_25.5: init %i32 = converted %.loc29_24, %int.convert_checked.loc29 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc29_25.6: ref %i32 = class_element_access %a.var, element0
-// CHECK:STDOUT:   %.loc29_25.7: init %i32 = initialize_from %.loc29_25.5 to %.loc29_25.6 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc29_25.7: init %i32 = initialize_from %.loc29_25.5 to %.loc29_25.6 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc29_25.8: init %A = class_init (%.loc29_25.7), %a.var [template = constants.%struct.1]
 // CHECK:STDOUT:   %.loc29_26: init %A = converted %.loc29_25.1, %.loc29_25.8 [template = constants.%struct.1]
 // CHECK:STDOUT:   assign %a.var, %.loc29_26
 // CHECK:STDOUT:   %B.ref: type = name_ref B, @A.%B.decl [template = constants.%B]
 // CHECK:STDOUT:   %b.var: ref %B = var b
 // CHECK:STDOUT:   %b: ref %B = bind_name b, %b.var
-// CHECK:STDOUT:   %.loc30_24: Core.IntLiteral = int_value 2 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc30_25.1: %.42 = struct_literal (%.loc30_24)
-// CHECK:STDOUT:   %.loc30_25.2: %Convert.type.2 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc30_25.3: <bound method> = bound_method %.loc30_24, %.loc30_25.2 [template = constants.%.43]
-// CHECK:STDOUT:   %.loc30_25.4: <specific function> = specific_function %.loc30_25.3, @Convert.2(constants.%.1) [template = constants.%.44]
-// CHECK:STDOUT:   %int.convert_checked.loc30: init %i32 = call %.loc30_25.4(%.loc30_24) [template = constants.%.45]
-// CHECK:STDOUT:   %.loc30_25.5: init %i32 = converted %.loc30_24, %int.convert_checked.loc30 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc30_24: Core.IntLiteral = int_value 2 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc30_25.1: %.46 = struct_literal (%.loc30_24)
+// CHECK:STDOUT:   %.loc30_25.2: %Convert.type.2 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc30_25.3: <bound method> = bound_method %.loc30_24, %.loc30_25.2 [template = constants.%.47]
+// CHECK:STDOUT:   %.loc30_25.4: <specific function> = specific_function %.loc30_25.3, @Convert.2(constants.%.1) [template = constants.%.48]
+// CHECK:STDOUT:   %int.convert_checked.loc30: init %i32 = call %.loc30_25.4(%.loc30_24) [template = constants.%.49]
+// CHECK:STDOUT:   %.loc30_25.5: init %i32 = converted %.loc30_24, %int.convert_checked.loc30 [template = constants.%.49]
 // CHECK:STDOUT:   %.loc30_25.6: ref %i32 = class_element_access %b.var, element0
-// CHECK:STDOUT:   %.loc30_25.7: init %i32 = initialize_from %.loc30_25.5 to %.loc30_25.6 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc30_25.7: init %i32 = initialize_from %.loc30_25.5 to %.loc30_25.6 [template = constants.%.49]
 // CHECK:STDOUT:   %.loc30_25.8: init %B = class_init (%.loc30_25.7), %b.var [template = constants.%struct.2]
 // CHECK:STDOUT:   %.loc30_26: init %B = converted %.loc30_25.1, %.loc30_25.8 [template = constants.%struct.2]
 // CHECK:STDOUT:   assign %b.var, %.loc30_26
 // CHECK:STDOUT:   %C.ref: type = name_ref C, @B.%C.decl [template = constants.%C]
 // CHECK:STDOUT:   %c.var: ref %C = var c
 // CHECK:STDOUT:   %c: ref %C = bind_name c, %c.var
-// CHECK:STDOUT:   %.loc31_24: Core.IntLiteral = int_value 3 [template = constants.%.47]
-// CHECK:STDOUT:   %.loc31_25.1: %.48 = struct_literal (%.loc31_24)
-// CHECK:STDOUT:   %.loc31_25.2: %Convert.type.2 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc31_25.3: <bound method> = bound_method %.loc31_24, %.loc31_25.2 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc31_25.4: <specific function> = specific_function %.loc31_25.3, @Convert.2(constants.%.1) [template = constants.%.50]
-// CHECK:STDOUT:   %int.convert_checked.loc31: init %i32 = call %.loc31_25.4(%.loc31_24) [template = constants.%.51]
-// CHECK:STDOUT:   %.loc31_25.5: init %i32 = converted %.loc31_24, %int.convert_checked.loc31 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc31_24: Core.IntLiteral = int_value 3 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc31_25.1: %.52 = struct_literal (%.loc31_24)
+// CHECK:STDOUT:   %.loc31_25.2: %Convert.type.2 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc31_25.3: <bound method> = bound_method %.loc31_24, %.loc31_25.2 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc31_25.4: <specific function> = specific_function %.loc31_25.3, @Convert.2(constants.%.1) [template = constants.%.54]
+// CHECK:STDOUT:   %int.convert_checked.loc31: init %i32 = call %.loc31_25.4(%.loc31_24) [template = constants.%.55]
+// CHECK:STDOUT:   %.loc31_25.5: init %i32 = converted %.loc31_24, %int.convert_checked.loc31 [template = constants.%.55]
 // CHECK:STDOUT:   %.loc31_25.6: ref %i32 = class_element_access %c.var, element0
-// CHECK:STDOUT:   %.loc31_25.7: init %i32 = initialize_from %.loc31_25.5 to %.loc31_25.6 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc31_25.7: init %i32 = initialize_from %.loc31_25.5 to %.loc31_25.6 [template = constants.%.55]
 // CHECK:STDOUT:   %.loc31_25.8: init %C = class_init (%.loc31_25.7), %c.var [template = constants.%struct.3]
 // CHECK:STDOUT:   %.loc31_26: init %C = converted %.loc31_25.1, %.loc31_25.8 [template = constants.%struct.3]
 // CHECK:STDOUT:   assign %c.var, %.loc31_26
 // CHECK:STDOUT:   %D.ref: type = name_ref D, @C.%D.decl [template = constants.%D]
 // CHECK:STDOUT:   %d.var: ref %D = var d
 // CHECK:STDOUT:   %d: ref %D = bind_name d, %d.var
-// CHECK:STDOUT:   %.loc32_24: Core.IntLiteral = int_value 4 [template = constants.%.53]
-// CHECK:STDOUT:   %.loc32_25.1: %.54 = struct_literal (%.loc32_24)
-// CHECK:STDOUT:   %.loc32_25.2: %Convert.type.2 = interface_witness_access constants.%.36, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc32_25.3: <bound method> = bound_method %.loc32_24, %.loc32_25.2 [template = constants.%.55]
-// CHECK:STDOUT:   %.loc32_25.4: <specific function> = specific_function %.loc32_25.3, @Convert.2(constants.%.1) [template = constants.%.56]
-// CHECK:STDOUT:   %int.convert_checked.loc32: init %i32 = call %.loc32_25.4(%.loc32_24) [template = constants.%.57]
-// CHECK:STDOUT:   %.loc32_25.5: init %i32 = converted %.loc32_24, %int.convert_checked.loc32 [template = constants.%.57]
+// CHECK:STDOUT:   %.loc32_24: Core.IntLiteral = int_value 4 [template = constants.%.57]
+// CHECK:STDOUT:   %.loc32_25.1: %.58 = struct_literal (%.loc32_24)
+// CHECK:STDOUT:   %.loc32_25.2: %Convert.type.2 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc32_25.3: <bound method> = bound_method %.loc32_24, %.loc32_25.2 [template = constants.%.59]
+// CHECK:STDOUT:   %.loc32_25.4: <specific function> = specific_function %.loc32_25.3, @Convert.2(constants.%.1) [template = constants.%.60]
+// CHECK:STDOUT:   %int.convert_checked.loc32: init %i32 = call %.loc32_25.4(%.loc32_24) [template = constants.%.61]
+// CHECK:STDOUT:   %.loc32_25.5: init %i32 = converted %.loc32_24, %int.convert_checked.loc32 [template = constants.%.61]
 // CHECK:STDOUT:   %.loc32_25.6: ref %i32 = class_element_access %d.var, element0
-// CHECK:STDOUT:   %.loc32_25.7: init %i32 = initialize_from %.loc32_25.5 to %.loc32_25.6 [template = constants.%.57]
+// CHECK:STDOUT:   %.loc32_25.7: init %i32 = initialize_from %.loc32_25.5 to %.loc32_25.6 [template = constants.%.61]
 // CHECK:STDOUT:   %.loc32_25.8: init %D = class_init (%.loc32_25.7), %d.var [template = constants.%struct.4]
 // CHECK:STDOUT:   %.loc32_26: init %D = converted %.loc32_25.1, %.loc32_25.8 [template = constants.%struct.4]
 // CHECK:STDOUT:   assign %d.var, %.loc32_26

toolchain/check/testdata/class/scope.carbon

@@ -45,16 +45,16 @@ fn Run() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.24: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.25: <bound method> = bound_method %.4, %Convert.14 [template]
-// CHECK:STDOUT:   %.26: <specific function> = specific_function %.25, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.27: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.29: <bound method> = bound_method %.4, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.31: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %F.type.2: type = fn_type @F.2 [template]
 // CHECK:STDOUT:   %F.2: %F.type.2 = struct_value () [template]
-// CHECK:STDOUT:   %.28: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.28, %Convert.14 [template]
-// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.31: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.33: <bound method> = bound_method %.32, %Convert.14 [template]
+// CHECK:STDOUT:   %.34: <specific function> = specific_function %.33, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.35: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %Run.type: type = fn_type @Run [template]
 // CHECK:STDOUT:   %Run: %Run.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -125,12 +125,12 @@ fn Run() {
 // CHECK:STDOUT: fn @F.1() -> %i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc13_12: Core.IntLiteral = int_value 1 [template = constants.%.4]
-// CHECK:STDOUT:   %.loc13_13.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_13.2: <bound method> = bound_method %.loc13_12, %.loc13_13.1 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc13_13.3: <specific function> = specific_function %.loc13_13.2, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc13_13.3(%.loc13_12) [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_13.5: %i32 = converted %.loc13_12, %.loc13_13.4 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc13_13.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_13.2: <bound method> = bound_method %.loc13_12, %.loc13_13.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_13.3: <specific function> = specific_function %.loc13_13.2, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc13_13.3(%.loc13_12) [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_13.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_13.5: %i32 = converted %.loc13_12, %.loc13_13.4 [template = constants.%.31]
 // CHECK:STDOUT:   return %.loc13_13.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -145,13 +145,13 @@ fn Run() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F.2() -> %i32 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc22_10: Core.IntLiteral = int_value 2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc22_11.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc22_11.2: <bound method> = bound_method %.loc22_10, %.loc22_11.1 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc22_11.3: <specific function> = specific_function %.loc22_11.2, @Convert.2(constants.%.1) [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc22_11.3(%.loc22_10) [template = constants.%.31]
-// CHECK:STDOUT:   %.loc22_11.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.31]
-// CHECK:STDOUT:   %.loc22_11.5: %i32 = converted %.loc22_10, %.loc22_11.4 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc22_10: Core.IntLiteral = int_value 2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc22_11.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc22_11.2: <bound method> = bound_method %.loc22_10, %.loc22_11.1 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc22_11.3: <specific function> = specific_function %.loc22_11.2, @Convert.2(constants.%.1) [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc22_11.3(%.loc22_10) [template = constants.%.35]
+// CHECK:STDOUT:   %.loc22_11.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.35]
+// CHECK:STDOUT:   %.loc22_11.5: %i32 = converted %.loc22_10, %.loc22_11.4 [template = constants.%.35]
 // CHECK:STDOUT:   return %.loc22_11.5
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/class/self.carbon

@@ -184,8 +184,8 @@ class Class {
 // CHECK:STDOUT:   %Class: type = class_type @Class [template]
 // CHECK:STDOUT:   %F.type: type = fn_type @F [template]
 // CHECK:STDOUT:   %F: %F.type = struct_value () [template]
-// CHECK:STDOUT:   %.20: type = struct_type {} [template]
-// CHECK:STDOUT:   %.21: <witness> = complete_type_witness %.20 [template]
+// CHECK:STDOUT:   %.24: type = struct_type {} [template]
+// CHECK:STDOUT:   %.25: <witness> = complete_type_witness %.24 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -220,7 +220,7 @@ class Class {
 // CHECK:STDOUT:     %return.param: ref <error> = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref <error> = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc12: <witness> = complete_type_witness %.20 [template = constants.%.21]
+// CHECK:STDOUT:   %.loc12: <witness> = complete_type_witness %.24 [template = constants.%.25]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = constants.%Class

toolchain/check/testdata/class/self_conversion.carbon

@@ -57,11 +57,11 @@ fn Call(p: Derived*) -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.30: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.10, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.34: type = ptr_type %Derived [template]
+// CHECK:STDOUT:   %.34: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.10, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.38: type = ptr_type %Derived [template]
 // CHECK:STDOUT:   %Call.type: type = fn_type @Call [template]
 // CHECK:STDOUT:   %Call: %Call.type = struct_value () [template]
 // CHECK:STDOUT: }
@@ -112,19 +112,19 @@ fn Call(p: Derived*) -> i32 {
 // CHECK:STDOUT:     %self.loc26: %.7 = bind_name self, %self.param.loc26
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %Call.decl: %Call.type = fn_decl @Call [template = constants.%Call] {
-// CHECK:STDOUT:     %p.patt: %.34 = binding_pattern p
-// CHECK:STDOUT:     %p.param_patt: %.34 = value_param_pattern %p.patt, runtime_param0
+// CHECK:STDOUT:     %p.patt: %.38 = binding_pattern p
+// CHECK:STDOUT:     %p.param_patt: %.38 = value_param_pattern %p.patt, runtime_param0
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Derived.ref: type = name_ref Derived, file.%Derived.decl [template = constants.%Derived]
-// CHECK:STDOUT:     %.loc30_19: type = ptr_type %Derived [template = constants.%.34]
+// CHECK:STDOUT:     %.loc30_19: type = ptr_type %Derived [template = constants.%.38]
 // CHECK:STDOUT:     %.loc30_25.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc30_25.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc30_25.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc30_25.3: type = converted %int.make_type_signed, %.loc30_25.2 [template = constants.%i32]
-// CHECK:STDOUT:     %p.param: %.34 = value_param runtime_param0
-// CHECK:STDOUT:     %p: %.34 = bind_name p, %p.param
+// CHECK:STDOUT:     %p.param: %.38 = value_param runtime_param0
+// CHECK:STDOUT:     %p: %.38 = bind_name p, %p.param
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
@@ -198,28 +198,28 @@ fn Call(p: Derived*) -> i32 {
 // CHECK:STDOUT:   %a.ref: %.2 = name_ref a, @Base.%.loc12_8 [template = @Base.%.loc12_8]
 // CHECK:STDOUT:   %.loc27_10: ref %i32 = class_element_access %.loc27_4, element0
 // CHECK:STDOUT:   %.loc27_15: Core.IntLiteral = int_value 1 [template = constants.%.10]
-// CHECK:STDOUT:   %.loc27_13.1: %Convert.type.2 = interface_witness_access constants.%.30, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc27_13.2: <bound method> = bound_method %.loc27_15, %.loc27_13.1 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc27_13.3: <specific function> = specific_function %.loc27_13.2, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc27_13.3(%.loc27_15) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc27_13.4: init %i32 = converted %.loc27_15, %int.convert_checked [template = constants.%.33]
+// CHECK:STDOUT:   %.loc27_13.1: %Convert.type.2 = interface_witness_access constants.%.34, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc27_13.2: <bound method> = bound_method %.loc27_15, %.loc27_13.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc27_13.3: <specific function> = specific_function %.loc27_13.2, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc27_13.3(%.loc27_15) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc27_13.4: init %i32 = converted %.loc27_15, %int.convert_checked [template = constants.%.37]
 // CHECK:STDOUT:   assign %.loc27_10, %.loc27_13.4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @Call(%p.param_patt: %.34) -> %i32 {
+// CHECK:STDOUT: fn @Call(%p.param_patt: %.38) -> %i32 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %p.ref.loc31: %.34 = name_ref p, %p
+// CHECK:STDOUT:   %p.ref.loc31: %.38 = name_ref p, %p
 // CHECK:STDOUT:   %.loc31_4.1: ref %Derived = deref %p.ref.loc31
 // CHECK:STDOUT:   %AddrSelfBase.ref: %AddrSelfBase.type = name_ref AddrSelfBase, @Derived.%AddrSelfBase.decl [template = constants.%AddrSelfBase]
 // CHECK:STDOUT:   %.loc31_7: <bound method> = bound_method %.loc31_4.1, %AddrSelfBase.ref
-// CHECK:STDOUT:   %.loc31_4.2: %.34 = addr_of %.loc31_4.1
+// CHECK:STDOUT:   %.loc31_4.2: %.38 = addr_of %.loc31_4.1
 // CHECK:STDOUT:   %.loc31_4.3: ref %Derived = deref %.loc31_4.2
 // CHECK:STDOUT:   %.loc31_4.4: ref %Base = class_element_access %.loc31_4.3, element0
 // CHECK:STDOUT:   %.loc31_4.5: %.7 = addr_of %.loc31_4.4
 // CHECK:STDOUT:   %.loc31_4.6: %.7 = converted %.loc31_4.2, %.loc31_4.5
 // CHECK:STDOUT:   %AddrSelfBase.call: init %empty_tuple.type = call %.loc31_7(%.loc31_4.6)
-// CHECK:STDOUT:   %p.ref.loc32: %.34 = name_ref p, %p
+// CHECK:STDOUT:   %p.ref.loc32: %.38 = name_ref p, %p
 // CHECK:STDOUT:   %.loc32_11.1: ref %Derived = deref %p.ref.loc32
 // CHECK:STDOUT:   %SelfBase.ref: %SelfBase.type = name_ref SelfBase, @Derived.%SelfBase.decl [template = constants.%SelfBase]
 // CHECK:STDOUT:   %.loc32_14: <bound method> = bound_method %.loc32_11.1, %SelfBase.ref

toolchain/check/testdata/class/syntactic_merge_literal.carbon

@@ -46,11 +46,11 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.24: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.25: <bound method> = bound_method %.4, %Convert.14 [template]
-// CHECK:STDOUT:   %.26: <specific function> = specific_function %.25, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.27: %i32 = int_value 1000 [template]
-// CHECK:STDOUT:   %C.3: type = class_type @C, @C(%.27) [template]
+// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.29: <bound method> = bound_method %.4, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.31: %i32 = int_value 1000 [template]
+// CHECK:STDOUT:   %C.3: type = class_type @C, @C(%.31) [template]
 // CHECK:STDOUT:   %b: %C.3 = bind_symbolic_name b, 0 [symbolic]
 // CHECK:STDOUT:   %b.patt: %C.3 = symbolic_binding_pattern b, 0 [symbolic]
 // CHECK:STDOUT:   %D.type: type = generic_class_type @D [template]
@@ -91,13 +91,13 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %C.ref.loc3: %C.type = name_ref C, file.%C.decl [template = constants.%C.1]
 // CHECK:STDOUT:     %.loc3_15: Core.IntLiteral = int_value 1000 [template = constants.%.4]
-// CHECK:STDOUT:     %.loc3_14.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc3_14.2: <bound method> = bound_method %.loc3_15, %.loc3_14.1 [template = constants.%.25]
-// CHECK:STDOUT:     %.loc3_14.3: <specific function> = specific_function %.loc3_14.2, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:     %int.convert_checked.loc3: init %i32 = call %.loc3_14.3(%.loc3_15) [template = constants.%.27]
-// CHECK:STDOUT:     %.loc3_14.4: %i32 = value_of_initializer %int.convert_checked.loc3 [template = constants.%.27]
-// CHECK:STDOUT:     %.loc3_14.5: %i32 = converted %.loc3_15, %.loc3_14.4 [template = constants.%.27]
-// CHECK:STDOUT:     %C.loc3: type = class_type @C, @C(constants.%.27) [template = constants.%C.3]
+// CHECK:STDOUT:     %.loc3_14.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc3_14.2: <bound method> = bound_method %.loc3_15, %.loc3_14.1 [template = constants.%.29]
+// CHECK:STDOUT:     %.loc3_14.3: <specific function> = specific_function %.loc3_14.2, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:     %int.convert_checked.loc3: init %i32 = call %.loc3_14.3(%.loc3_15) [template = constants.%.31]
+// CHECK:STDOUT:     %.loc3_14.4: %i32 = value_of_initializer %int.convert_checked.loc3 [template = constants.%.31]
+// CHECK:STDOUT:     %.loc3_14.5: %i32 = converted %.loc3_15, %.loc3_14.4 [template = constants.%.31]
+// CHECK:STDOUT:     %C.loc3: type = class_type @C, @C(constants.%.31) [template = constants.%C.3]
 // CHECK:STDOUT:     %b.param.loc3: %C.3 = value_param runtime_param<invalid>
 // CHECK:STDOUT:     %b.loc3_9.1: %C.3 = bind_symbolic_name b, 0, %b.param.loc3 [symbolic = %b.loc3_9.2 (constants.%b)]
 // CHECK:STDOUT:   }
@@ -107,13 +107,13 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %C.ref.loc4: %C.type = name_ref C, file.%C.decl [template = constants.%C.1]
 // CHECK:STDOUT:     %.loc4_15: Core.IntLiteral = int_value 1000 [template = constants.%.4]
-// CHECK:STDOUT:     %.loc4_14.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc4_14.2: <bound method> = bound_method %.loc4_15, %.loc4_14.1 [template = constants.%.25]
-// CHECK:STDOUT:     %.loc4_14.3: <specific function> = specific_function %.loc4_14.2, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:     %int.convert_checked.loc4: init %i32 = call %.loc4_14.3(%.loc4_15) [template = constants.%.27]
-// CHECK:STDOUT:     %.loc4_14.4: %i32 = value_of_initializer %int.convert_checked.loc4 [template = constants.%.27]
-// CHECK:STDOUT:     %.loc4_14.5: %i32 = converted %.loc4_15, %.loc4_14.4 [template = constants.%.27]
-// CHECK:STDOUT:     %C.loc4: type = class_type @C, @C(constants.%.27) [template = constants.%C.3]
+// CHECK:STDOUT:     %.loc4_14.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc4_14.2: <bound method> = bound_method %.loc4_15, %.loc4_14.1 [template = constants.%.29]
+// CHECK:STDOUT:     %.loc4_14.3: <specific function> = specific_function %.loc4_14.2, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:     %int.convert_checked.loc4: init %i32 = call %.loc4_14.3(%.loc4_15) [template = constants.%.31]
+// CHECK:STDOUT:     %.loc4_14.4: %i32 = value_of_initializer %int.convert_checked.loc4 [template = constants.%.31]
+// CHECK:STDOUT:     %.loc4_14.5: %i32 = converted %.loc4_15, %.loc4_14.4 [template = constants.%.31]
+// CHECK:STDOUT:     %C.loc4: type = class_type @C, @C(constants.%.31) [template = constants.%C.3]
 // CHECK:STDOUT:     %b.param.loc4: %C.3 = value_param runtime_param<invalid>
 // CHECK:STDOUT:     %b.loc4: %C.3 = bind_symbolic_name b, 0, %b.param.loc4 [symbolic = constants.%b]
 // CHECK:STDOUT:   }
@@ -152,9 +152,9 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   %a.patt.loc2_9.2 => constants.%a
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @C(constants.%.27) {
-// CHECK:STDOUT:   %a.loc2_9.2 => constants.%.27
-// CHECK:STDOUT:   %a.patt.loc2_9.2 => constants.%.27
+// CHECK:STDOUT: specific @C(constants.%.31) {
+// CHECK:STDOUT:   %a.loc2_9.2 => constants.%.31
+// CHECK:STDOUT:   %a.patt.loc2_9.2 => constants.%.31
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @D(constants.%b) {
@@ -180,18 +180,18 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.24: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.25: <bound method> = bound_method %.4, %Convert.14 [template]
-// CHECK:STDOUT:   %.26: <specific function> = specific_function %.25, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.27: %i32 = int_value 1000 [template]
-// CHECK:STDOUT:   %C.3: type = class_type @C, @C(%.27) [template]
+// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.29: <bound method> = bound_method %.4, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.31: %i32 = int_value 1000 [template]
+// CHECK:STDOUT:   %C.3: type = class_type @C, @C(%.31) [template]
 // CHECK:STDOUT:   %b: %C.3 = bind_symbolic_name b, 0 [symbolic]
 // CHECK:STDOUT:   %b.patt: %C.3 = symbolic_binding_pattern b, 0 [symbolic]
 // CHECK:STDOUT:   %D.type: type = generic_class_type @D [template]
 // CHECK:STDOUT:   %D.1: %D.type = struct_value () [template]
 // CHECK:STDOUT:   %.type: type = generic_class_type @.1 [template]
-// CHECK:STDOUT:   %.28: %.type = struct_value () [template]
-// CHECK:STDOUT:   %.29: type = class_type @.1, @.1(%b) [symbolic]
+// CHECK:STDOUT:   %.32: %.type = struct_value () [template]
+// CHECK:STDOUT:   %.33: type = class_type @.1, @.1(%b) [symbolic]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -227,29 +227,29 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %C.ref: %C.type = name_ref C, file.%C.decl [template = constants.%C.1]
 // CHECK:STDOUT:     %.loc3_15: Core.IntLiteral = int_value 1000 [template = constants.%.4]
-// CHECK:STDOUT:     %.loc3_14.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc3_14.2: <bound method> = bound_method %.loc3_15, %.loc3_14.1 [template = constants.%.25]
-// CHECK:STDOUT:     %.loc3_14.3: <specific function> = specific_function %.loc3_14.2, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc3_14.3(%.loc3_15) [template = constants.%.27]
-// CHECK:STDOUT:     %.loc3_14.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.27]
-// CHECK:STDOUT:     %.loc3_14.5: %i32 = converted %.loc3_15, %.loc3_14.4 [template = constants.%.27]
-// CHECK:STDOUT:     %C: type = class_type @C, @C(constants.%.27) [template = constants.%C.3]
+// CHECK:STDOUT:     %.loc3_14.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc3_14.2: <bound method> = bound_method %.loc3_15, %.loc3_14.1 [template = constants.%.29]
+// CHECK:STDOUT:     %.loc3_14.3: <specific function> = specific_function %.loc3_14.2, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc3_14.3(%.loc3_15) [template = constants.%.31]
+// CHECK:STDOUT:     %.loc3_14.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.31]
+// CHECK:STDOUT:     %.loc3_14.5: %i32 = converted %.loc3_15, %.loc3_14.4 [template = constants.%.31]
+// CHECK:STDOUT:     %C: type = class_type @C, @C(constants.%.31) [template = constants.%C.3]
 // CHECK:STDOUT:     %b.param: %C.3 = value_param runtime_param<invalid>
 // CHECK:STDOUT:     %b.loc3_9.1: %C.3 = bind_symbolic_name b, 0, %b.param [symbolic = %b.loc3_9.2 (constants.%b)]
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.decl: %.type = class_decl @.1 [template = constants.%.28] {
+// CHECK:STDOUT:   %.decl: %.type = class_decl @.1 [template = constants.%.32] {
 // CHECK:STDOUT:     %b.patt.loc10_9.1: %C.3 = symbolic_binding_pattern b, 0 [symbolic = %b.patt.loc10_9.2 (constants.%b.patt)]
 // CHECK:STDOUT:     %b.param_patt: %C.3 = value_param_pattern %b.patt.loc10_9.1, runtime_param<invalid> [symbolic = %b.patt.loc10_9.2 (constants.%b.patt)]
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %C.ref: %C.type = name_ref C, file.%C.decl [template = constants.%C.1]
 // CHECK:STDOUT:     %.loc10_15: Core.IntLiteral = int_value 1000 [template = constants.%.4]
-// CHECK:STDOUT:     %.loc10_14.1: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc10_14.2: <bound method> = bound_method %.loc10_15, %.loc10_14.1 [template = constants.%.25]
-// CHECK:STDOUT:     %.loc10_14.3: <specific function> = specific_function %.loc10_14.2, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc10_14.3(%.loc10_15) [template = constants.%.27]
-// CHECK:STDOUT:     %.loc10_14.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.27]
-// CHECK:STDOUT:     %.loc10_14.5: %i32 = converted %.loc10_15, %.loc10_14.4 [template = constants.%.27]
-// CHECK:STDOUT:     %C: type = class_type @C, @C(constants.%.27) [template = constants.%C.3]
+// CHECK:STDOUT:     %.loc10_14.1: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc10_14.2: <bound method> = bound_method %.loc10_15, %.loc10_14.1 [template = constants.%.29]
+// CHECK:STDOUT:     %.loc10_14.3: <specific function> = specific_function %.loc10_14.2, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc10_14.3(%.loc10_15) [template = constants.%.31]
+// CHECK:STDOUT:     %.loc10_14.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.31]
+// CHECK:STDOUT:     %.loc10_14.5: %i32 = converted %.loc10_15, %.loc10_14.4 [template = constants.%.31]
+// CHECK:STDOUT:     %C: type = class_type @C, @C(constants.%.31) [template = constants.%C.3]
 // CHECK:STDOUT:     %b.param: %C.3 = value_param runtime_param<invalid>
 // CHECK:STDOUT:     %b.loc10_9.1: %C.3 = bind_symbolic_name b, 0, %b.param [symbolic = %b.loc10_9.2 (constants.%b)]
 // CHECK:STDOUT:   }
@@ -286,7 +286,7 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:     %.loc10_24: <witness> = complete_type_witness %.2 [template = constants.%.3]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   !members:
-// CHECK:STDOUT:     .Self = constants.%.29
+// CHECK:STDOUT:     .Self = constants.%.33
 // CHECK:STDOUT:   }
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -295,9 +295,9 @@ class D(b:! C(1_000)) {}
 // CHECK:STDOUT:   %a.patt.loc2_9.2 => constants.%a
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @C(constants.%.27) {
-// CHECK:STDOUT:   %a.loc2_9.2 => constants.%.27
-// CHECK:STDOUT:   %a.patt.loc2_9.2 => constants.%.27
+// CHECK:STDOUT: specific @C(constants.%.31) {
+// CHECK:STDOUT:   %a.loc2_9.2 => constants.%.31
+// CHECK:STDOUT:   %a.patt.loc2_9.2 => constants.%.31
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @D(constants.%b) {

toolchain/check/testdata/deduce/array.carbon

@@ -115,19 +115,19 @@ fn G() -> C {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.7) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.7) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.7) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 0 [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.32: type = array_type %.3, %C [template]
+// CHECK:STDOUT:   %.36: type = array_type %.3, %C [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (%.1, %.1, %.1) [template]
 // CHECK:STDOUT:   %struct: %C = struct_value () [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %array: %.32 = tuple_value (%struct, %struct, %struct) [template]
-// CHECK:STDOUT:   %.36: <specific function> = specific_function %F, @F(%C) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %array: %.36 = tuple_value (%struct, %struct, %struct) [template]
+// CHECK:STDOUT:   %.40: <specific function> = specific_function %F, @F(%C) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -194,12 +194,12 @@ fn G() -> C {
 // CHECK:STDOUT:   !entry:
 // CHECK:STDOUT:     %a.ref: @F.%.loc6_24.2 (%.4) = name_ref a, %a
 // CHECK:STDOUT:     %.loc6_43.1: Core.IntLiteral = int_value 0 [template = constants.%.6]
-// CHECK:STDOUT:     %.loc6_43.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc6_43.3: <bound method> = bound_method %.loc6_43.1, %.loc6_43.2 [template = constants.%.28]
-// CHECK:STDOUT:     %.loc6_43.4: <specific function> = specific_function %.loc6_43.3, @Convert.2(constants.%.7) [template = constants.%.29]
-// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc6_43.4(%.loc6_43.1) [template = constants.%.30]
-// CHECK:STDOUT:     %.loc6_43.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.30]
-// CHECK:STDOUT:     %.loc6_43.6: %i32 = converted %.loc6_43.1, %.loc6_43.5 [template = constants.%.30]
+// CHECK:STDOUT:     %.loc6_43.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc6_43.3: <bound method> = bound_method %.loc6_43.1, %.loc6_43.2 [template = constants.%.32]
+// CHECK:STDOUT:     %.loc6_43.4: <specific function> = specific_function %.loc6_43.3, @Convert.2(constants.%.7) [template = constants.%.33]
+// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc6_43.4(%.loc6_43.1) [template = constants.%.34]
+// CHECK:STDOUT:     %.loc6_43.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.34]
+// CHECK:STDOUT:     %.loc6_43.6: %i32 = converted %.loc6_43.1, %.loc6_43.5 [template = constants.%.34]
 // CHECK:STDOUT:     %.loc6_44.1: ref @F.%.loc6_24.2 (%.4) = value_as_ref %a.ref
 // CHECK:STDOUT:     %.loc6_44.2: ref @F.%T.loc6_6.2 (%T) = array_index %.loc6_44.1, %.loc6_43.6
 // CHECK:STDOUT:     %.loc6_44.3: @F.%T.loc6_6.2 (%T) = bind_value %.loc6_44.2
@@ -211,9 +211,9 @@ fn G() -> C {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %C.ref.loc9: type = name_ref C, file.%C.decl [template = constants.%C]
 // CHECK:STDOUT:   %.loc9_14: Core.IntLiteral = int_value 3 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc9_15: type = array_type %.loc9_14, %C [template = constants.%.32]
-// CHECK:STDOUT:   %a.var: ref %.32 = var a
-// CHECK:STDOUT:   %a: ref %.32 = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc9_15: type = array_type %.loc9_14, %C [template = constants.%.36]
+// CHECK:STDOUT:   %a.var: ref %.36 = var a
+// CHECK:STDOUT:   %a: ref %.36 = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc9_21.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc9_25.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc9_29.1: %.1 = struct_literal ()
@@ -222,22 +222,22 @@ fn G() -> C {
 // CHECK:STDOUT:   %.loc9_30.3: ref %C = array_index %a.var, %.loc9_30.2
 // CHECK:STDOUT:   %.loc9_21.2: init %C = class_init (), %.loc9_30.3 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc9_30.4: init %C = converted %.loc9_21.1, %.loc9_21.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc9_30.5: Core.IntLiteral = int_value 1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_30.5: Core.IntLiteral = int_value 1 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc9_30.6: ref %C = array_index %a.var, %.loc9_30.5
 // CHECK:STDOUT:   %.loc9_25.2: init %C = class_init (), %.loc9_30.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc9_30.7: init %C = converted %.loc9_25.1, %.loc9_25.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc9_30.8: Core.IntLiteral = int_value 2 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc9_30.8: Core.IntLiteral = int_value 2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc9_30.9: ref %C = array_index %a.var, %.loc9_30.8
 // CHECK:STDOUT:   %.loc9_29.2: init %C = class_init (), %.loc9_30.9 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc9_30.10: init %C = converted %.loc9_29.1, %.loc9_29.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc9_30.11: init %.32 = array_init (%.loc9_30.4, %.loc9_30.7, %.loc9_30.10) to %a.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc9_31: init %.32 = converted %.loc9_30.1, %.loc9_30.11 [template = constants.%array]
+// CHECK:STDOUT:   %.loc9_30.11: init %.36 = array_init (%.loc9_30.4, %.loc9_30.7, %.loc9_30.10) to %a.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc9_31: init %.36 = converted %.loc9_30.1, %.loc9_30.11 [template = constants.%array]
 // CHECK:STDOUT:   assign %a.var, %.loc9_31
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
-// CHECK:STDOUT:   %a.ref: ref %.32 = name_ref a, %a
-// CHECK:STDOUT:   %.loc10_10: <specific function> = specific_function %F.ref, @F(constants.%C) [template = constants.%.36]
+// CHECK:STDOUT:   %a.ref: ref %.36 = name_ref a, %a
+// CHECK:STDOUT:   %.loc10_10: <specific function> = specific_function %F.ref, @F(constants.%C) [template = constants.%.40]
 // CHECK:STDOUT:   %.loc8_8.2: ref %C = splice_block %return {}
-// CHECK:STDOUT:   %.loc10_12: %.32 = bind_value %a.ref
+// CHECK:STDOUT:   %.loc10_12: %.36 = bind_value %a.ref
 // CHECK:STDOUT:   %F.call: init %C = call %.loc10_10(%.loc10_12) to %.loc8_8.2
 // CHECK:STDOUT:   return %F.call to %return
 // CHECK:STDOUT: }
@@ -251,7 +251,7 @@ fn G() -> C {
 // CHECK:STDOUT: specific @F(constants.%C) {
 // CHECK:STDOUT:   %T.loc6_6.2 => constants.%C
 // CHECK:STDOUT:   %T.patt.loc6_6.2 => constants.%C
-// CHECK:STDOUT:   %.loc6_24.2 => constants.%.32
+// CHECK:STDOUT:   %.loc6_24.2 => constants.%.36
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }
@@ -271,22 +271,22 @@ fn G() -> C {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.13: type = fn_type @Convert.4, @impl.3(%.3) [template]
 // CHECK:STDOUT:   %Convert.13: %Convert.type.13 = struct_value () [template]
-// CHECK:STDOUT:   %.21: <witness> = interface_witness (%Convert.13) [template]
-// CHECK:STDOUT:   %.22: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
-// CHECK:STDOUT:   %.23: <specific function> = specific_function %.22, @Convert.4(%.3) [symbolic]
-// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.23(%N.1) [symbolic]
+// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.13) [template]
+// CHECK:STDOUT:   %.26: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
+// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.4(%.3) [symbolic]
+// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.27(%N.1) [symbolic]
 // CHECK:STDOUT:   %F.type: type = fn_type @F [template]
 // CHECK:STDOUT:   %F: %F.type = struct_value () [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.25: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.26: type = array_type %.25, %C [template]
+// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.30: type = array_type %.29, %C [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (%.1, %.1, %.1) [template]
-// CHECK:STDOUT:   %.28: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 0 [template]
 // CHECK:STDOUT:   %struct: %C = struct_value () [template]
-// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %array: %.26 = tuple_value (%struct, %struct, %struct) [template]
+// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %array: %.30 = tuple_value (%struct, %struct, %struct) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -321,9 +321,9 @@ fn G() -> C {
 // CHECK:STDOUT:     %.loc10_10.3: type = converted %int.make_type_signed.loc10_10, %.loc10_10.2 [template = constants.%i32]
 // CHECK:STDOUT:     %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
 // CHECK:STDOUT:     %N.ref.loc10_22: %i32 = name_ref N, %N.loc10_6.1 [symbolic = %N.loc10_6.2 (constants.%N.1)]
-// CHECK:STDOUT:     %.loc10_22.1: %Convert.type.2 = interface_witness_access constants.%.21, element0 [template = constants.%Convert.13]
-// CHECK:STDOUT:     %.loc10_22.2: <bound method> = bound_method %N.ref.loc10_22, %.loc10_22.1 [symbolic = %.loc10_22.6 (constants.%.22)]
-// CHECK:STDOUT:     %.loc10_22.3: <specific function> = specific_function %.loc10_22.2, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.23)]
+// CHECK:STDOUT:     %.loc10_22.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.13]
+// CHECK:STDOUT:     %.loc10_22.2: <bound method> = bound_method %N.ref.loc10_22, %.loc10_22.1 [symbolic = %.loc10_22.6 (constants.%.26)]
+// CHECK:STDOUT:     %.loc10_22.3: <specific function> = specific_function %.loc10_22.2, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.27)]
 // CHECK:STDOUT:     %int.convert_checked.loc10_22.1: init Core.IntLiteral = call %.loc10_22.3(%N.ref.loc10_22) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc10_22.4: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_22.1 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc10_22.5: Core.IntLiteral = converted %N.ref.loc10_22, %.loc10_22.4 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
@@ -359,8 +359,8 @@ fn G() -> C {
 // CHECK:STDOUT: generic fn @F(%N.loc10_6.1: %i32) {
 // CHECK:STDOUT:   %N.loc10_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc10_6.2 (constants.%N.1)]
 // CHECK:STDOUT:   %N.patt.loc10_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.1)]
-// CHECK:STDOUT:   %.loc10_22.6: <bound method> = bound_method %N.loc10_6.2, constants.%Convert.13 [symbolic = %.loc10_22.6 (constants.%.22)]
-// CHECK:STDOUT:   %.loc10_22.7: <specific function> = specific_function %.loc10_22.6, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.23)]
+// CHECK:STDOUT:   %.loc10_22.6: <bound method> = bound_method %N.loc10_6.2, constants.%Convert.13 [symbolic = %.loc10_22.6 (constants.%.26)]
+// CHECK:STDOUT:   %.loc10_22.7: <specific function> = specific_function %.loc10_22.6, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.27)]
 // CHECK:STDOUT:   %int.convert_checked.loc10_22.2: init Core.IntLiteral = call %.loc10_22.7(%N.loc10_6.2) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
@@ -375,39 +375,39 @@ fn G() -> C {
 // CHECK:STDOUT: fn @G() -> %return: %C {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %C.ref.loc13: type = name_ref C, file.%C.decl [template = constants.%C]
-// CHECK:STDOUT:   %.loc13_14: Core.IntLiteral = int_value 3 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc13_15: type = array_type %.loc13_14, %C [template = constants.%.26]
-// CHECK:STDOUT:   %a.var: ref %.26 = var a
-// CHECK:STDOUT:   %a: ref %.26 = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc13_14: Core.IntLiteral = int_value 3 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_15: type = array_type %.loc13_14, %C [template = constants.%.30]
+// CHECK:STDOUT:   %a.var: ref %.30 = var a
+// CHECK:STDOUT:   %a: ref %.30 = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc13_21.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_25.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_29.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_30.1: %tuple.type = tuple_literal (%.loc13_21.1, %.loc13_25.1, %.loc13_29.1)
-// CHECK:STDOUT:   %.loc13_30.2: Core.IntLiteral = int_value 0 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_30.2: Core.IntLiteral = int_value 0 [template = constants.%.32]
 // CHECK:STDOUT:   %.loc13_30.3: ref %C = array_index %a.var, %.loc13_30.2
 // CHECK:STDOUT:   %.loc13_21.2: init %C = class_init (), %.loc13_30.3 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.4: init %C = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.5: Core.IntLiteral = int_value 1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_30.5: Core.IntLiteral = int_value 1 [template = constants.%.33]
 // CHECK:STDOUT:   %.loc13_30.6: ref %C = array_index %a.var, %.loc13_30.5
 // CHECK:STDOUT:   %.loc13_25.2: init %C = class_init (), %.loc13_30.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.7: init %C = converted %.loc13_25.1, %.loc13_25.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.8: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_30.8: Core.IntLiteral = int_value 2 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_30.9: ref %C = array_index %a.var, %.loc13_30.8
 // CHECK:STDOUT:   %.loc13_29.2: init %C = class_init (), %.loc13_30.9 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.10: init %C = converted %.loc13_29.1, %.loc13_29.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.11: init %.26 = array_init (%.loc13_30.4, %.loc13_30.7, %.loc13_30.10) to %a.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc13_31: init %.26 = converted %.loc13_30.1, %.loc13_30.11 [template = constants.%array]
+// CHECK:STDOUT:   %.loc13_30.11: init %.30 = array_init (%.loc13_30.4, %.loc13_30.7, %.loc13_30.10) to %a.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc13_31: init %.30 = converted %.loc13_30.1, %.loc13_30.11 [template = constants.%array]
 // CHECK:STDOUT:   assign %a.var, %.loc13_31
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
-// CHECK:STDOUT:   %a.ref: ref %.26 = name_ref a, %a
+// CHECK:STDOUT:   %a.ref: ref %.30 = name_ref a, %a
 // CHECK:STDOUT:   return <error> to %return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @F(constants.%N.1) {
 // CHECK:STDOUT:   %N.loc10_6.2 => constants.%N.1
 // CHECK:STDOUT:   %N.patt.loc10_6.2 => constants.%N.1
-// CHECK:STDOUT:   %.loc10_22.6 => constants.%.22
-// CHECK:STDOUT:   %.loc10_22.7 => constants.%.23
+// CHECK:STDOUT:   %.loc10_22.6 => constants.%.26
+// CHECK:STDOUT:   %.loc10_22.7 => constants.%.27
 // CHECK:STDOUT:   %int.convert_checked.loc10_22.2 => constants.%int.convert_checked
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -428,22 +428,22 @@ fn G() -> C {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.13: type = fn_type @Convert.4, @impl.3(%.3) [template]
 // CHECK:STDOUT:   %Convert.13: %Convert.type.13 = struct_value () [template]
-// CHECK:STDOUT:   %.21: <witness> = interface_witness (%Convert.13) [template]
-// CHECK:STDOUT:   %.22: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
-// CHECK:STDOUT:   %.23: <specific function> = specific_function %.22, @Convert.4(%.3) [symbolic]
-// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.23(%N.1) [symbolic]
+// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.13) [template]
+// CHECK:STDOUT:   %.26: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
+// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.4(%.3) [symbolic]
+// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.27(%N.1) [symbolic]
 // CHECK:STDOUT:   %F.type: type = fn_type @F [template]
 // CHECK:STDOUT:   %F: %F.type = struct_value () [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.25: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.26: type = array_type %.25, %C [template]
+// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.30: type = array_type %.29, %C [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (%.1, %.1, %.1) [template]
-// CHECK:STDOUT:   %.28: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 0 [template]
 // CHECK:STDOUT:   %struct: %C = struct_value () [template]
-// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %array: %.26 = tuple_value (%struct, %struct, %struct) [template]
+// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %array: %.30 = tuple_value (%struct, %struct, %struct) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -480,9 +480,9 @@ fn G() -> C {
 // CHECK:STDOUT:     %.loc10_20.3: type = converted %int.make_type_signed, %.loc10_20.2 [template = constants.%i32]
 // CHECK:STDOUT:     %T.ref.loc10_29: type = name_ref T, %T.loc10_6.1 [symbolic = %T.loc10_6.2 (constants.%T)]
 // CHECK:STDOUT:     %N.ref: %i32 = name_ref N, %N.loc10_16.1 [symbolic = %N.loc10_16.2 (constants.%N.1)]
-// CHECK:STDOUT:     %.loc10_32.1: %Convert.type.2 = interface_witness_access constants.%.21, element0 [template = constants.%Convert.13]
-// CHECK:STDOUT:     %.loc10_32.2: <bound method> = bound_method %N.ref, %.loc10_32.1 [symbolic = %.loc10_32.6 (constants.%.22)]
-// CHECK:STDOUT:     %.loc10_32.3: <specific function> = specific_function %.loc10_32.2, @Convert.4(constants.%.3) [symbolic = %.loc10_32.7 (constants.%.23)]
+// CHECK:STDOUT:     %.loc10_32.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.13]
+// CHECK:STDOUT:     %.loc10_32.2: <bound method> = bound_method %N.ref, %.loc10_32.1 [symbolic = %.loc10_32.6 (constants.%.26)]
+// CHECK:STDOUT:     %.loc10_32.3: <specific function> = specific_function %.loc10_32.2, @Convert.4(constants.%.3) [symbolic = %.loc10_32.7 (constants.%.27)]
 // CHECK:STDOUT:     %int.convert_checked.loc10_32.1: init Core.IntLiteral = call %.loc10_32.3(%N.ref) [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc10_32.4: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_32.1 [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc10_32.5: Core.IntLiteral = converted %N.ref, %.loc10_32.4 [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)]
@@ -519,8 +519,8 @@ fn G() -> C {
 // CHECK:STDOUT:   %T.patt.loc10_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc10_6.2 (constants.%T.patt)]
 // CHECK:STDOUT:   %N.loc10_16.2: %i32 = bind_symbolic_name N, 1 [symbolic = %N.loc10_16.2 (constants.%N.1)]
 // CHECK:STDOUT:   %N.patt.loc10_16.2: %i32 = symbolic_binding_pattern N, 1 [symbolic = %N.patt.loc10_16.2 (constants.%N.patt.1)]
-// CHECK:STDOUT:   %.loc10_32.6: <bound method> = bound_method %N.loc10_16.2, constants.%Convert.13 [symbolic = %.loc10_32.6 (constants.%.22)]
-// CHECK:STDOUT:   %.loc10_32.7: <specific function> = specific_function %.loc10_32.6, @Convert.4(constants.%.3) [symbolic = %.loc10_32.7 (constants.%.23)]
+// CHECK:STDOUT:   %.loc10_32.6: <bound method> = bound_method %N.loc10_16.2, constants.%Convert.13 [symbolic = %.loc10_32.6 (constants.%.26)]
+// CHECK:STDOUT:   %.loc10_32.7: <specific function> = specific_function %.loc10_32.6, @Convert.4(constants.%.3) [symbolic = %.loc10_32.7 (constants.%.27)]
 // CHECK:STDOUT:   %int.convert_checked.loc10_32.2: init Core.IntLiteral = call %.loc10_32.7(%N.loc10_16.2) [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   fn[%T.param_patt: type, %N.param_patt: %i32](%a.param_patt: <error>) -> @F.%T.loc10_6.2 (%T);
@@ -529,31 +529,31 @@ fn G() -> C {
 // CHECK:STDOUT: fn @G() -> %return: %C {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %C.ref.loc13: type = name_ref C, file.%C.decl [template = constants.%C]
-// CHECK:STDOUT:   %.loc13_14: Core.IntLiteral = int_value 3 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc13_15: type = array_type %.loc13_14, %C [template = constants.%.26]
-// CHECK:STDOUT:   %a.var: ref %.26 = var a
-// CHECK:STDOUT:   %a: ref %.26 = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc13_14: Core.IntLiteral = int_value 3 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_15: type = array_type %.loc13_14, %C [template = constants.%.30]
+// CHECK:STDOUT:   %a.var: ref %.30 = var a
+// CHECK:STDOUT:   %a: ref %.30 = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc13_21.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_25.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_29.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_30.1: %tuple.type = tuple_literal (%.loc13_21.1, %.loc13_25.1, %.loc13_29.1)
-// CHECK:STDOUT:   %.loc13_30.2: Core.IntLiteral = int_value 0 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_30.2: Core.IntLiteral = int_value 0 [template = constants.%.32]
 // CHECK:STDOUT:   %.loc13_30.3: ref %C = array_index %a.var, %.loc13_30.2
 // CHECK:STDOUT:   %.loc13_21.2: init %C = class_init (), %.loc13_30.3 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.4: init %C = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.5: Core.IntLiteral = int_value 1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_30.5: Core.IntLiteral = int_value 1 [template = constants.%.33]
 // CHECK:STDOUT:   %.loc13_30.6: ref %C = array_index %a.var, %.loc13_30.5
 // CHECK:STDOUT:   %.loc13_25.2: init %C = class_init (), %.loc13_30.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.7: init %C = converted %.loc13_25.1, %.loc13_25.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.8: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_30.8: Core.IntLiteral = int_value 2 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_30.9: ref %C = array_index %a.var, %.loc13_30.8
 // CHECK:STDOUT:   %.loc13_29.2: init %C = class_init (), %.loc13_30.9 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.10: init %C = converted %.loc13_29.1, %.loc13_29.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.11: init %.26 = array_init (%.loc13_30.4, %.loc13_30.7, %.loc13_30.10) to %a.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc13_31: init %.26 = converted %.loc13_30.1, %.loc13_30.11 [template = constants.%array]
+// CHECK:STDOUT:   %.loc13_30.11: init %.30 = array_init (%.loc13_30.4, %.loc13_30.7, %.loc13_30.10) to %a.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc13_31: init %.30 = converted %.loc13_30.1, %.loc13_30.11 [template = constants.%array]
 // CHECK:STDOUT:   assign %a.var, %.loc13_31
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
-// CHECK:STDOUT:   %a.ref: ref %.26 = name_ref a, %a
+// CHECK:STDOUT:   %a.ref: ref %.30 = name_ref a, %a
 // CHECK:STDOUT:   return <error> to %return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -562,8 +562,8 @@ fn G() -> C {
 // CHECK:STDOUT:   %T.patt.loc10_6.2 => constants.%T
 // CHECK:STDOUT:   %N.loc10_16.2 => constants.%N.1
 // CHECK:STDOUT:   %N.patt.loc10_16.2 => constants.%N.1
-// CHECK:STDOUT:   %.loc10_32.6 => constants.%.22
-// CHECK:STDOUT:   %.loc10_32.7 => constants.%.23
+// CHECK:STDOUT:   %.loc10_32.6 => constants.%.26
+// CHECK:STDOUT:   %.loc10_32.7 => constants.%.27
 // CHECK:STDOUT:   %int.convert_checked.loc10_32.2 => constants.%int.convert_checked
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -585,20 +585,20 @@ fn G() -> C {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.7) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.7) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.7) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 0 [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.33: type = array_type %.32, %C [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.37: type = array_type %.36, %C [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (%.1, %.1, %.1) [template]
 // CHECK:STDOUT:   %struct: %C = struct_value () [template]
-// CHECK:STDOUT:   %.35: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %array: %.33 = tuple_value (%struct, %struct, %struct) [template]
-// CHECK:STDOUT:   %.36: type = array_type %.3, %C [template]
-// CHECK:STDOUT:   %.37: <specific function> = specific_function %F, @F(%C) [template]
+// CHECK:STDOUT:   %.39: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %array: %.37 = tuple_value (%struct, %struct, %struct) [template]
+// CHECK:STDOUT:   %.40: type = array_type %.3, %C [template]
+// CHECK:STDOUT:   %.41: <specific function> = specific_function %F, @F(%C) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -665,12 +665,12 @@ fn G() -> C {
 // CHECK:STDOUT:   !entry:
 // CHECK:STDOUT:     %a.ref: @F.%.loc6_24.2 (%.4) = name_ref a, %a
 // CHECK:STDOUT:     %.loc6_43.1: Core.IntLiteral = int_value 0 [template = constants.%.6]
-// CHECK:STDOUT:     %.loc6_43.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc6_43.3: <bound method> = bound_method %.loc6_43.1, %.loc6_43.2 [template = constants.%.28]
-// CHECK:STDOUT:     %.loc6_43.4: <specific function> = specific_function %.loc6_43.3, @Convert.2(constants.%.7) [template = constants.%.29]
-// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc6_43.4(%.loc6_43.1) [template = constants.%.30]
-// CHECK:STDOUT:     %.loc6_43.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.30]
-// CHECK:STDOUT:     %.loc6_43.6: %i32 = converted %.loc6_43.1, %.loc6_43.5 [template = constants.%.30]
+// CHECK:STDOUT:     %.loc6_43.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc6_43.3: <bound method> = bound_method %.loc6_43.1, %.loc6_43.2 [template = constants.%.32]
+// CHECK:STDOUT:     %.loc6_43.4: <specific function> = specific_function %.loc6_43.3, @Convert.2(constants.%.7) [template = constants.%.33]
+// CHECK:STDOUT:     %int.convert_checked: init %i32 = call %.loc6_43.4(%.loc6_43.1) [template = constants.%.34]
+// CHECK:STDOUT:     %.loc6_43.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.34]
+// CHECK:STDOUT:     %.loc6_43.6: %i32 = converted %.loc6_43.1, %.loc6_43.5 [template = constants.%.34]
 // CHECK:STDOUT:     %.loc6_44.1: ref @F.%.loc6_24.2 (%.4) = value_as_ref %a.ref
 // CHECK:STDOUT:     %.loc6_44.2: ref @F.%T.loc6_6.2 (%T) = array_index %.loc6_44.1, %.loc6_43.6
 // CHECK:STDOUT:     %.loc6_44.3: @F.%T.loc6_6.2 (%T) = bind_value %.loc6_44.2
@@ -681,10 +681,10 @@ fn G() -> C {
 // CHECK:STDOUT: fn @G() -> %return: %C {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %C.ref.loc10: type = name_ref C, file.%C.decl [template = constants.%C]
-// CHECK:STDOUT:   %.loc10_14: Core.IntLiteral = int_value 3 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc10_15: type = array_type %.loc10_14, %C [template = constants.%.33]
-// CHECK:STDOUT:   %a.var: ref %.33 = var a
-// CHECK:STDOUT:   %a: ref %.33 = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc10_14: Core.IntLiteral = int_value 3 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc10_15: type = array_type %.loc10_14, %C [template = constants.%.37]
+// CHECK:STDOUT:   %a.var: ref %.37 = var a
+// CHECK:STDOUT:   %a: ref %.37 = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc10_21.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc10_25.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc10_29.1: %.1 = struct_literal ()
@@ -693,7 +693,7 @@ fn G() -> C {
 // CHECK:STDOUT:   %.loc10_30.3: ref %C = array_index %a.var, %.loc10_30.2
 // CHECK:STDOUT:   %.loc10_21.2: init %C = class_init (), %.loc10_30.3 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc10_30.4: init %C = converted %.loc10_21.1, %.loc10_21.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc10_30.5: Core.IntLiteral = int_value 1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc10_30.5: Core.IntLiteral = int_value 1 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc10_30.6: ref %C = array_index %a.var, %.loc10_30.5
 // CHECK:STDOUT:   %.loc10_25.2: init %C = class_init (), %.loc10_30.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc10_30.7: init %C = converted %.loc10_25.1, %.loc10_25.2 [template = constants.%struct]
@@ -701,14 +701,14 @@ fn G() -> C {
 // CHECK:STDOUT:   %.loc10_30.9: ref %C = array_index %a.var, %.loc10_30.8
 // CHECK:STDOUT:   %.loc10_29.2: init %C = class_init (), %.loc10_30.9 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc10_30.10: init %C = converted %.loc10_29.1, %.loc10_29.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc10_30.11: init %.33 = array_init (%.loc10_30.4, %.loc10_30.7, %.loc10_30.10) to %a.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc10_31: init %.33 = converted %.loc10_30.1, %.loc10_30.11 [template = constants.%array]
+// CHECK:STDOUT:   %.loc10_30.11: init %.37 = array_init (%.loc10_30.4, %.loc10_30.7, %.loc10_30.10) to %a.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc10_31: init %.37 = converted %.loc10_30.1, %.loc10_30.11 [template = constants.%array]
 // CHECK:STDOUT:   assign %a.var, %.loc10_31
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
-// CHECK:STDOUT:   %a.ref: ref %.33 = name_ref a, %a
-// CHECK:STDOUT:   %.loc21_10: <specific function> = specific_function %F.ref, @F(constants.%C) [template = constants.%.37]
+// CHECK:STDOUT:   %a.ref: ref %.37 = name_ref a, %a
+// CHECK:STDOUT:   %.loc21_10: <specific function> = specific_function %F.ref, @F(constants.%C) [template = constants.%.41]
 // CHECK:STDOUT:   %.loc8_8.2: ref %C = splice_block %return {}
-// CHECK:STDOUT:   %.loc21_12: %.36 = converted %a.ref, <error> [template = <error>]
+// CHECK:STDOUT:   %.loc21_12: %.40 = converted %a.ref, <error> [template = <error>]
 // CHECK:STDOUT:   %F.call: init %C = call %.loc21_10(<error>) to %.loc8_8.2
 // CHECK:STDOUT:   return %F.call to %return
 // CHECK:STDOUT: }
@@ -722,7 +722,7 @@ fn G() -> C {
 // CHECK:STDOUT: specific @F(constants.%C) {
 // CHECK:STDOUT:   %T.loc6_6.2 => constants.%C
 // CHECK:STDOUT:   %T.patt.loc6_6.2 => constants.%C
-// CHECK:STDOUT:   %.loc6_24.2 => constants.%.36
+// CHECK:STDOUT:   %.loc6_24.2 => constants.%.40
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }
@@ -743,22 +743,22 @@ fn G() -> C {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.13: type = fn_type @Convert.4, @impl.3(%.3) [template]
 // CHECK:STDOUT:   %Convert.13: %Convert.type.13 = struct_value () [template]
-// CHECK:STDOUT:   %.21: <witness> = interface_witness (%Convert.13) [template]
-// CHECK:STDOUT:   %.22: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
-// CHECK:STDOUT:   %.23: <specific function> = specific_function %.22, @Convert.4(%.3) [symbolic]
-// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.23(%N.1) [symbolic]
+// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.13) [template]
+// CHECK:STDOUT:   %.26: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
+// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.4(%.3) [symbolic]
+// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.27(%N.1) [symbolic]
 // CHECK:STDOUT:   %F.type: type = fn_type @F [template]
 // CHECK:STDOUT:   %F: %F.type = struct_value () [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.25: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.26: type = array_type %.25, %D [template]
+// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.30: type = array_type %.29, %D [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (%.1, %.1, %.1) [template]
-// CHECK:STDOUT:   %.28: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.32: Core.IntLiteral = int_value 0 [template]
 // CHECK:STDOUT:   %struct: %D = struct_value () [template]
-// CHECK:STDOUT:   %.29: Core.IntLiteral = int_value 1 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %array: %.26 = tuple_value (%struct, %struct, %struct) [template]
+// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %array: %.30 = tuple_value (%struct, %struct, %struct) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -795,9 +795,9 @@ fn G() -> C {
 // CHECK:STDOUT:     %.loc10_10.3: type = converted %int.make_type_signed.loc10_10, %.loc10_10.2 [template = constants.%i32]
 // CHECK:STDOUT:     %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
 // CHECK:STDOUT:     %N.ref.loc10_22: %i32 = name_ref N, %N.loc10_6.1 [symbolic = %N.loc10_6.2 (constants.%N.1)]
-// CHECK:STDOUT:     %.loc10_22.1: %Convert.type.2 = interface_witness_access constants.%.21, element0 [template = constants.%Convert.13]
-// CHECK:STDOUT:     %.loc10_22.2: <bound method> = bound_method %N.ref.loc10_22, %.loc10_22.1 [symbolic = %.loc10_22.6 (constants.%.22)]
-// CHECK:STDOUT:     %.loc10_22.3: <specific function> = specific_function %.loc10_22.2, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.23)]
+// CHECK:STDOUT:     %.loc10_22.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.13]
+// CHECK:STDOUT:     %.loc10_22.2: <bound method> = bound_method %N.ref.loc10_22, %.loc10_22.1 [symbolic = %.loc10_22.6 (constants.%.26)]
+// CHECK:STDOUT:     %.loc10_22.3: <specific function> = specific_function %.loc10_22.2, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.27)]
 // CHECK:STDOUT:     %int.convert_checked.loc10_22.1: init Core.IntLiteral = call %.loc10_22.3(%N.ref.loc10_22) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc10_22.4: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_22.1 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc10_22.5: Core.IntLiteral = converted %N.ref.loc10_22, %.loc10_22.4 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
@@ -840,8 +840,8 @@ fn G() -> C {
 // CHECK:STDOUT: generic fn @F(%N.loc10_6.1: %i32) {
 // CHECK:STDOUT:   %N.loc10_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc10_6.2 (constants.%N.1)]
 // CHECK:STDOUT:   %N.patt.loc10_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.1)]
-// CHECK:STDOUT:   %.loc10_22.6: <bound method> = bound_method %N.loc10_6.2, constants.%Convert.13 [symbolic = %.loc10_22.6 (constants.%.22)]
-// CHECK:STDOUT:   %.loc10_22.7: <specific function> = specific_function %.loc10_22.6, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.23)]
+// CHECK:STDOUT:   %.loc10_22.6: <bound method> = bound_method %N.loc10_6.2, constants.%Convert.13 [symbolic = %.loc10_22.6 (constants.%.26)]
+// CHECK:STDOUT:   %.loc10_22.7: <specific function> = specific_function %.loc10_22.6, @Convert.4(constants.%.3) [symbolic = %.loc10_22.7 (constants.%.27)]
 // CHECK:STDOUT:   %int.convert_checked.loc10_22.2: init Core.IntLiteral = call %.loc10_22.7(%N.loc10_6.2) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
@@ -856,39 +856,39 @@ fn G() -> C {
 // CHECK:STDOUT: fn @G() -> %return: %C {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %D.ref: type = name_ref D, file.%D.decl [template = constants.%D]
-// CHECK:STDOUT:   %.loc13_14: Core.IntLiteral = int_value 3 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc13_15: type = array_type %.loc13_14, %D [template = constants.%.26]
-// CHECK:STDOUT:   %a.var: ref %.26 = var a
-// CHECK:STDOUT:   %a: ref %.26 = bind_name a, %a.var
+// CHECK:STDOUT:   %.loc13_14: Core.IntLiteral = int_value 3 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_15: type = array_type %.loc13_14, %D [template = constants.%.30]
+// CHECK:STDOUT:   %a.var: ref %.30 = var a
+// CHECK:STDOUT:   %a: ref %.30 = bind_name a, %a.var
 // CHECK:STDOUT:   %.loc13_21.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_25.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_29.1: %.1 = struct_literal ()
 // CHECK:STDOUT:   %.loc13_30.1: %tuple.type = tuple_literal (%.loc13_21.1, %.loc13_25.1, %.loc13_29.1)
-// CHECK:STDOUT:   %.loc13_30.2: Core.IntLiteral = int_value 0 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_30.2: Core.IntLiteral = int_value 0 [template = constants.%.32]
 // CHECK:STDOUT:   %.loc13_30.3: ref %D = array_index %a.var, %.loc13_30.2
 // CHECK:STDOUT:   %.loc13_21.2: init %D = class_init (), %.loc13_30.3 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.4: init %D = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.5: Core.IntLiteral = int_value 1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_30.5: Core.IntLiteral = int_value 1 [template = constants.%.33]
 // CHECK:STDOUT:   %.loc13_30.6: ref %D = array_index %a.var, %.loc13_30.5
 // CHECK:STDOUT:   %.loc13_25.2: init %D = class_init (), %.loc13_30.6 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.7: init %D = converted %.loc13_25.1, %.loc13_25.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.8: Core.IntLiteral = int_value 2 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_30.8: Core.IntLiteral = int_value 2 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_30.9: ref %D = array_index %a.var, %.loc13_30.8
 // CHECK:STDOUT:   %.loc13_29.2: init %D = class_init (), %.loc13_30.9 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc13_30.10: init %D = converted %.loc13_29.1, %.loc13_29.2 [template = constants.%struct]
-// CHECK:STDOUT:   %.loc13_30.11: init %.26 = array_init (%.loc13_30.4, %.loc13_30.7, %.loc13_30.10) to %a.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc13_31: init %.26 = converted %.loc13_30.1, %.loc13_30.11 [template = constants.%array]
+// CHECK:STDOUT:   %.loc13_30.11: init %.30 = array_init (%.loc13_30.4, %.loc13_30.7, %.loc13_30.10) to %a.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc13_31: init %.30 = converted %.loc13_30.1, %.loc13_30.11 [template = constants.%array]
 // CHECK:STDOUT:   assign %a.var, %.loc13_31
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
-// CHECK:STDOUT:   %a.ref: ref %.26 = name_ref a, %a
+// CHECK:STDOUT:   %a.ref: ref %.30 = name_ref a, %a
 // CHECK:STDOUT:   return <error> to %return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @F(constants.%N.1) {
 // CHECK:STDOUT:   %N.loc10_6.2 => constants.%N.1
 // CHECK:STDOUT:   %N.patt.loc10_6.2 => constants.%N.1
-// CHECK:STDOUT:   %.loc10_22.6 => constants.%.22
-// CHECK:STDOUT:   %.loc10_22.7 => constants.%.23
+// CHECK:STDOUT:   %.loc10_22.6 => constants.%.26
+// CHECK:STDOUT:   %.loc10_22.7 => constants.%.27
 // CHECK:STDOUT:   %int.convert_checked.loc10_22.2 => constants.%int.convert_checked
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/deduce/generic_type.carbon

@@ -733,13 +733,13 @@ fn G() -> i32 {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %WithNontype.3: type = class_type @WithNontype, @WithNontype(%.28) [template]
+// CHECK:STDOUT:   %.29: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.30: <bound method> = bound_method %.5, %Convert.14 [template]
+// CHECK:STDOUT:   %.31: <specific function> = specific_function %.30, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.32: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %WithNontype.3: type = class_type @WithNontype, @WithNontype(%.32) [template]
 // CHECK:STDOUT:   %struct: %WithNontype.3 = struct_value () [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %F, @F(%.28) [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %F, @F(%.32) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -843,18 +843,18 @@ fn G() -> i32 {
 // CHECK:STDOUT:   %.loc9_13.1: %.2 = struct_literal ()
 // CHECK:STDOUT:   %WithNontype.ref: %WithNontype.type = name_ref WithNontype, file.%WithNontype.decl [template = constants.%WithNontype.1]
 // CHECK:STDOUT:   %.loc9_30: Core.IntLiteral = int_value 0 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc9_29.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc9_29.2: <bound method> = bound_method %.loc9_30, %.loc9_29.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc9_29.3: <specific function> = specific_function %.loc9_29.2, @Convert.2(constants.%.1) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc9_29.3(%.loc9_30) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_29.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.28]
-// CHECK:STDOUT:   %.loc9_29.5: %i32 = converted %.loc9_30, %.loc9_29.4 [template = constants.%.28]
-// CHECK:STDOUT:   %WithNontype: type = class_type @WithNontype, @WithNontype(constants.%.28) [template = constants.%WithNontype.3]
+// CHECK:STDOUT:   %.loc9_29.1: %Convert.type.2 = interface_witness_access constants.%.29, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc9_29.2: <bound method> = bound_method %.loc9_30, %.loc9_29.1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc9_29.3: <specific function> = specific_function %.loc9_29.2, @Convert.2(constants.%.1) [template = constants.%.31]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc9_29.3(%.loc9_30) [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_29.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.32]
+// CHECK:STDOUT:   %.loc9_29.5: %i32 = converted %.loc9_30, %.loc9_29.4 [template = constants.%.32]
+// CHECK:STDOUT:   %WithNontype: type = class_type @WithNontype, @WithNontype(constants.%.32) [template = constants.%WithNontype.3]
 // CHECK:STDOUT:   %.loc9_13.2: ref %WithNontype.3 = temporary_storage
 // CHECK:STDOUT:   %.loc9_13.3: init %WithNontype.3 = class_init (), %.loc9_13.2 [template = constants.%struct]
 // CHECK:STDOUT:   %.loc9_13.4: ref %WithNontype.3 = temporary %.loc9_13.2, %.loc9_13.3
 // CHECK:STDOUT:   %.loc9_15.1: ref %WithNontype.3 = converted %.loc9_13.1, %.loc9_13.4
-// CHECK:STDOUT:   %.loc9_10: <specific function> = specific_function %F.ref, @F(constants.%.28) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc9_10: <specific function> = specific_function %F.ref, @F(constants.%.32) [template = constants.%.33]
 // CHECK:STDOUT:   %.loc9_15.2: %WithNontype.3 = bind_value %.loc9_15.1
 // CHECK:STDOUT:   %F.call: init %i32 = call %.loc9_10(%.loc9_15.2)
 // CHECK:STDOUT:   %.loc9_33.1: %i32 = value_of_initializer %F.call
@@ -880,16 +880,16 @@ fn G() -> i32 {
 // CHECK:STDOUT:   %WithNontype.loc6_29.2 => constants.%WithNontype.2
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @WithNontype(constants.%.28) {
-// CHECK:STDOUT:   %N.loc4_19.2 => constants.%.28
-// CHECK:STDOUT:   %N.patt.loc4_19.2 => constants.%.28
+// CHECK:STDOUT: specific @WithNontype(constants.%.32) {
+// CHECK:STDOUT:   %N.loc4_19.2 => constants.%.32
+// CHECK:STDOUT:   %N.patt.loc4_19.2 => constants.%.32
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @F(constants.%.28) {
-// CHECK:STDOUT:   %N.loc6_6.2 => constants.%.28
-// CHECK:STDOUT:   %N.patt.loc6_6.2 => constants.%.28
+// CHECK:STDOUT: specific @F(constants.%.32) {
+// CHECK:STDOUT:   %N.loc6_6.2 => constants.%.32
+// CHECK:STDOUT:   %N.patt.loc6_6.2 => constants.%.32
 // CHECK:STDOUT:   %WithNontype.loc6_29.2 => constants.%WithNontype.3
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:

toolchain/check/testdata/deduce/tuple.carbon

@@ -240,18 +240,18 @@ fn G(pair: (C, D)) -> D {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.31: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %tuple.2: %tuple.type.2 = tuple_value (%.30, %.33) [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %tuple.2: %tuple.type.2 = tuple_value (%.34, %.37) [template]
 // CHECK:STDOUT:   %HasPair.4: type = class_type @HasPair, @HasPair(%tuple.2) [template]
 // CHECK:STDOUT:   %G.type: type = fn_type @G [template]
 // CHECK:STDOUT:   %G: %G.type = struct_value () [template]
-// CHECK:STDOUT:   %.34: <specific function> = specific_function %F, @F(%.30, %.33) [template]
+// CHECK:STDOUT:   %.38: <specific function> = specific_function %F, @F(%.34, %.37) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -336,18 +336,18 @@ fn G(pair: (C, D)) -> D {
 // CHECK:STDOUT:     %.loc8_18: Core.IntLiteral = int_value 1 [template = constants.%.6]
 // CHECK:STDOUT:     %.loc8_21: Core.IntLiteral = int_value 2 [template = constants.%.7]
 // CHECK:STDOUT:     %.loc8_22.1: %tuple.type.3 = tuple_literal (%.loc8_18, %.loc8_21)
-// CHECK:STDOUT:     %.loc8_22.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc8_22.3: <bound method> = bound_method %.loc8_18, %.loc8_22.2 [template = constants.%.28]
-// CHECK:STDOUT:     %.loc8_22.4: <specific function> = specific_function %.loc8_22.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:     %int.convert_checked.loc8_22.1: init %i32 = call %.loc8_22.4(%.loc8_18) [template = constants.%.30]
-// CHECK:STDOUT:     %.loc8_22.5: %i32 = value_of_initializer %int.convert_checked.loc8_22.1 [template = constants.%.30]
-// CHECK:STDOUT:     %.loc8_22.6: %i32 = converted %.loc8_18, %.loc8_22.5 [template = constants.%.30]
-// CHECK:STDOUT:     %.loc8_22.7: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:     %.loc8_22.8: <bound method> = bound_method %.loc8_21, %.loc8_22.7 [template = constants.%.31]
-// CHECK:STDOUT:     %.loc8_22.9: <specific function> = specific_function %.loc8_22.8, @Convert.2(constants.%.1) [template = constants.%.32]
-// CHECK:STDOUT:     %int.convert_checked.loc8_22.2: init %i32 = call %.loc8_22.9(%.loc8_21) [template = constants.%.33]
-// CHECK:STDOUT:     %.loc8_22.10: %i32 = value_of_initializer %int.convert_checked.loc8_22.2 [template = constants.%.33]
-// CHECK:STDOUT:     %.loc8_22.11: %i32 = converted %.loc8_21, %.loc8_22.10 [template = constants.%.33]
+// CHECK:STDOUT:     %.loc8_22.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc8_22.3: <bound method> = bound_method %.loc8_18, %.loc8_22.2 [template = constants.%.32]
+// CHECK:STDOUT:     %.loc8_22.4: <specific function> = specific_function %.loc8_22.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:     %int.convert_checked.loc8_22.1: init %i32 = call %.loc8_22.4(%.loc8_18) [template = constants.%.34]
+// CHECK:STDOUT:     %.loc8_22.5: %i32 = value_of_initializer %int.convert_checked.loc8_22.1 [template = constants.%.34]
+// CHECK:STDOUT:     %.loc8_22.6: %i32 = converted %.loc8_18, %.loc8_22.5 [template = constants.%.34]
+// CHECK:STDOUT:     %.loc8_22.7: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:     %.loc8_22.8: <bound method> = bound_method %.loc8_21, %.loc8_22.7 [template = constants.%.35]
+// CHECK:STDOUT:     %.loc8_22.9: <specific function> = specific_function %.loc8_22.8, @Convert.2(constants.%.1) [template = constants.%.36]
+// CHECK:STDOUT:     %int.convert_checked.loc8_22.2: init %i32 = call %.loc8_22.9(%.loc8_21) [template = constants.%.37]
+// CHECK:STDOUT:     %.loc8_22.10: %i32 = value_of_initializer %int.convert_checked.loc8_22.2 [template = constants.%.37]
+// CHECK:STDOUT:     %.loc8_22.11: %i32 = converted %.loc8_21, %.loc8_22.10 [template = constants.%.37]
 // CHECK:STDOUT:     %tuple: %tuple.type.2 = tuple_value (%.loc8_22.6, %.loc8_22.11) [template = constants.%tuple.2]
 // CHECK:STDOUT:     %.loc8_16: %tuple.type.2 = converted %.loc8_22.1, %tuple [template = constants.%tuple.2]
 // CHECK:STDOUT:     %HasPair: type = class_type @HasPair, @HasPair(constants.%tuple.2) [template = constants.%HasPair.4]
@@ -397,7 +397,7 @@ fn G(pair: (C, D)) -> D {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
 // CHECK:STDOUT:   %h.ref: %HasPair.4 = name_ref h, %h
-// CHECK:STDOUT:   %.loc9_10: <specific function> = specific_function %F.ref, @F(constants.%.30, constants.%.33) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc9_10: <specific function> = specific_function %F.ref, @F(constants.%.34, constants.%.37) [template = constants.%.38]
 // CHECK:STDOUT:   %F.call: init %i32 = call %.loc9_10(%h.ref)
 // CHECK:STDOUT:   %.loc9_14.1: %i32 = value_of_initializer %F.call
 // CHECK:STDOUT:   %.loc9_14.2: %i32 = converted %F.call, %.loc9_14.1
@@ -437,11 +437,11 @@ fn G(pair: (C, D)) -> D {
 // CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @F(constants.%.30, constants.%.33) {
-// CHECK:STDOUT:   %A.loc6_6.2 => constants.%.30
-// CHECK:STDOUT:   %A.patt.loc6_6.2 => constants.%.30
-// CHECK:STDOUT:   %B.loc6_15.2 => constants.%.33
-// CHECK:STDOUT:   %B.patt.loc6_15.2 => constants.%.33
+// CHECK:STDOUT: specific @F(constants.%.34, constants.%.37) {
+// CHECK:STDOUT:   %A.loc6_6.2 => constants.%.34
+// CHECK:STDOUT:   %A.patt.loc6_6.2 => constants.%.34
+// CHECK:STDOUT:   %B.loc6_15.2 => constants.%.37
+// CHECK:STDOUT:   %B.patt.loc6_15.2 => constants.%.37
 // CHECK:STDOUT:   %tuple.loc6_40.2 => constants.%tuple.2
 // CHECK:STDOUT:   %HasPair.loc6_34.2 => constants.%HasPair.4
 // CHECK:STDOUT:

toolchain/check/testdata/eval/aggregate.carbon

@@ -31,37 +31,37 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.24: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.25: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.26: <specific function> = specific_function %.25, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.27: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.4, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %tuple.1: %tuple.type.2 = tuple_value (%.27, %.30) [template]
-// CHECK:STDOUT:   %.31: type = struct_type {.a: %i32, .b: %i32, .c: %i32} [template]
-// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.34: type = struct_type {.c: Core.IntLiteral, .b: Core.IntLiteral, .a: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %.35: type = struct_type {.b: %i32, .a: %i32, .c: %i32} [template]
-// CHECK:STDOUT:   %.37: <bound method> = bound_method %.33, %Convert.14 [template]
-// CHECK:STDOUT:   %.38: <specific function> = specific_function %.37, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.39: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %struct.1: %.35 = struct_value (%.30, %.27, %.39) [template]
-// CHECK:STDOUT:   %struct.2: %.31 = struct_value (%.27, %.30, %.39) [template]
-// CHECK:STDOUT:   %.40: type = array_type %.3, %i32 [template]
-// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.28: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.29: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.30: <specific function> = specific_function %.29, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.31: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.4, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %tuple.1: %tuple.type.2 = tuple_value (%.31, %.34) [template]
+// CHECK:STDOUT:   %.35: type = struct_type {.a: %i32, .b: %i32, .c: %i32} [template]
+// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.38: type = struct_type {.c: Core.IntLiteral, .b: Core.IntLiteral, .a: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %.39: type = struct_type {.b: %i32, .a: %i32, .c: %i32} [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.37, %Convert.14 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %struct.1: %.39 = struct_value (%.34, %.31, %.43) [template]
+// CHECK:STDOUT:   %struct.2: %.35 = struct_value (%.31, %.34, %.43) [template]
+// CHECK:STDOUT:   %.44: type = array_type %.3, %i32 [template]
+// CHECK:STDOUT:   %.46: Core.IntLiteral = int_value 0 [template]
 // CHECK:STDOUT:   %tuple.type.4: type = tuple_type (Core.IntLiteral) [template]
-// CHECK:STDOUT:   %.43: Core.IntLiteral = int_value 5 [template]
-// CHECK:STDOUT:   %.44: Core.IntLiteral = int_value 7 [template]
-// CHECK:STDOUT:   %.45: Core.IntLiteral = int_value 9 [template]
+// CHECK:STDOUT:   %.47: Core.IntLiteral = int_value 5 [template]
+// CHECK:STDOUT:   %.48: Core.IntLiteral = int_value 7 [template]
+// CHECK:STDOUT:   %.49: Core.IntLiteral = int_value 9 [template]
 // CHECK:STDOUT:   %tuple.type.5: type = tuple_type (Core.IntLiteral, Core.IntLiteral, Core.IntLiteral, Core.IntLiteral) [template]
-// CHECK:STDOUT:   %tuple.2: %tuple.type.5 = tuple_value (%.43, %.44, %.3, %.45) [template]
-// CHECK:STDOUT:   %.47: <bound method> = bound_method %.42, %Convert.14 [template]
-// CHECK:STDOUT:   %.48: <specific function> = specific_function %.47, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.49: %i32 = int_value 0 [template]
-// CHECK:STDOUT:   %array: %.40 = tuple_value (%.49) [template]
-// CHECK:STDOUT:   %.50: type = struct_type {.a: Core.IntLiteral, .b: Core.IntLiteral} [template]
-// CHECK:STDOUT:   %struct.3: %.50 = struct_value (%.33, %.3) [template]
+// CHECK:STDOUT:   %tuple.2: %tuple.type.5 = tuple_value (%.47, %.48, %.3, %.49) [template]
+// CHECK:STDOUT:   %.51: <bound method> = bound_method %.46, %Convert.14 [template]
+// CHECK:STDOUT:   %.52: <specific function> = specific_function %.51, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.53: %i32 = int_value 0 [template]
+// CHECK:STDOUT:   %array: %.44 = tuple_value (%.53) [template]
+// CHECK:STDOUT:   %.54: type = struct_type {.a: Core.IntLiteral, .b: Core.IntLiteral} [template]
+// CHECK:STDOUT:   %struct.3: %.54 = struct_value (%.37, %.3) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -106,25 +106,25 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %int.make_type_signed.loc13_41: init type = call constants.%Int(%.loc13_41.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc13_41.2: type = value_of_initializer %int.make_type_signed.loc13_41 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc13_41.3: type = converted %int.make_type_signed.loc13_41, %.loc13_41.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc13_44: type = struct_type {.a: %i32, .b: %i32, .c: %i32} [template = constants.%.31]
-// CHECK:STDOUT:   %struct_copy.var: ref %.31 = var struct_copy
-// CHECK:STDOUT:   %struct_copy: ref %.31 = bind_name struct_copy, %struct_copy.var
+// CHECK:STDOUT:   %.loc13_44: type = struct_type {.a: %i32, .b: %i32, .c: %i32} [template = constants.%.35]
+// CHECK:STDOUT:   %struct_copy.var: ref %.35 = var struct_copy
+// CHECK:STDOUT:   %struct_copy: ref %.35 = bind_name struct_copy, %struct_copy.var
 // CHECK:STDOUT:   %.loc15_19.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc15: init type = call constants.%Int(%.loc15_19.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc15_24: Core.IntLiteral = int_value 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc15_19.2: type = value_of_initializer %int.make_type_signed.loc15 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc15_19.3: type = converted %int.make_type_signed.loc15, %.loc15_19.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_25: type = array_type %.loc15_24, %i32 [template = constants.%.40]
-// CHECK:STDOUT:   %tuple_index.var: ref %.40 = var tuple_index
-// CHECK:STDOUT:   %tuple_index: ref %.40 = bind_name tuple_index, %tuple_index.var
+// CHECK:STDOUT:   %.loc15_25: type = array_type %.loc15_24, %i32 [template = constants.%.44]
+// CHECK:STDOUT:   %tuple_index.var: ref %.44 = var tuple_index
+// CHECK:STDOUT:   %tuple_index: ref %.44 = bind_name tuple_index, %tuple_index.var
 // CHECK:STDOUT:   %.loc17_21.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc17: init type = call constants.%Int(%.loc17_21.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc17_26: Core.IntLiteral = int_value 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc17_21.2: type = value_of_initializer %int.make_type_signed.loc17 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc17_21.3: type = converted %int.make_type_signed.loc17, %.loc17_21.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc17_27: type = array_type %.loc17_26, %i32 [template = constants.%.40]
-// CHECK:STDOUT:   %struct_access.var: ref %.40 = var struct_access
-// CHECK:STDOUT:   %struct_access: ref %.40 = bind_name struct_access, %struct_access.var
+// CHECK:STDOUT:   %.loc17_27: type = array_type %.loc17_26, %i32 [template = constants.%.44]
+// CHECK:STDOUT:   %struct_access.var: ref %.44 = var struct_access
+// CHECK:STDOUT:   %struct_access: ref %.44 = bind_name struct_access, %struct_access.var
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
@@ -142,33 +142,33 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %.loc11_49.4: type = value_of_initializer %int.make_type_signed.loc11_46 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc11_49.5: type = converted %int.make_type_signed.loc11_46, %.loc11_49.4 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc11_49.6: type = converted %.loc11_49.1, constants.%tuple.type.2 [template = constants.%tuple.type.2]
-// CHECK:STDOUT:   %.loc11_35.2: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_35.3: <bound method> = bound_method %.loc11_31, %.loc11_35.2 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc11_35.4: <specific function> = specific_function %.loc11_35.3, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked.loc11_35.1: init %i32 = call %.loc11_35.4(%.loc11_31) [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_35.5: %i32 = value_of_initializer %int.convert_checked.loc11_35.1 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_35.6: %i32 = converted %.loc11_31, %.loc11_35.5 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_35.7: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc11_35.8: <bound method> = bound_method %.loc11_34, %.loc11_35.7 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc11_35.9: <specific function> = specific_function %.loc11_35.8, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc11_35.2: init %i32 = call %.loc11_35.9(%.loc11_34) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_35.10: %i32 = value_of_initializer %int.convert_checked.loc11_35.2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc11_35.11: %i32 = converted %.loc11_34, %.loc11_35.10 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_35.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_35.3: <bound method> = bound_method %.loc11_31, %.loc11_35.2 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc11_35.4: <specific function> = specific_function %.loc11_35.3, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked.loc11_35.1: init %i32 = call %.loc11_35.4(%.loc11_31) [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_35.5: %i32 = value_of_initializer %int.convert_checked.loc11_35.1 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_35.6: %i32 = converted %.loc11_31, %.loc11_35.5 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_35.7: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc11_35.8: <bound method> = bound_method %.loc11_34, %.loc11_35.7 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc11_35.9: <specific function> = specific_function %.loc11_35.8, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc11_35.2: init %i32 = call %.loc11_35.9(%.loc11_34) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_35.10: %i32 = value_of_initializer %int.convert_checked.loc11_35.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc11_35.11: %i32 = converted %.loc11_34, %.loc11_35.10 [template = constants.%.34]
 // CHECK:STDOUT:   %tuple.loc11: %tuple.type.2 = tuple_value (%.loc11_35.6, %.loc11_35.11) [template = constants.%tuple.1]
 // CHECK:STDOUT:   %.loc11_37.1: %tuple.type.2 = converted %.loc11_35.1, %tuple.loc11 [template = constants.%tuple.1]
-// CHECK:STDOUT:   %.loc11_37.2: %i32 = tuple_access %.loc11_37.1, element0 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc11_37.2: %i32 = tuple_access %.loc11_37.1, element0 [template = constants.%.31]
 // CHECK:STDOUT:   %.loc11_37.3: ref %i32 = tuple_access file.%tuple_copy.var, element0
-// CHECK:STDOUT:   %.loc11_37.4: init %i32 = initialize_from %.loc11_37.2 to %.loc11_37.3 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc11_37.5: %i32 = tuple_access %.loc11_37.1, element1 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_37.4: init %i32 = initialize_from %.loc11_37.2 to %.loc11_37.3 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc11_37.5: %i32 = tuple_access %.loc11_37.1, element1 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc11_37.6: ref %i32 = tuple_access file.%tuple_copy.var, element1
-// CHECK:STDOUT:   %.loc11_37.7: init %i32 = initialize_from %.loc11_37.5 to %.loc11_37.6 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc11_37.7: init %i32 = initialize_from %.loc11_37.5 to %.loc11_37.6 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc11_37.8: init %tuple.type.2 = tuple_init (%.loc11_37.4, %.loc11_37.7) to file.%tuple_copy.var [template = constants.%tuple.1]
 // CHECK:STDOUT:   %.loc11_50: init %tuple.type.2 = converted %.loc11_37.1, %.loc11_37.8 [template = constants.%tuple.1]
 // CHECK:STDOUT:   assign file.%tuple_copy.var, %.loc11_50
-// CHECK:STDOUT:   %.loc13_54: Core.IntLiteral = int_value 3 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_54: Core.IntLiteral = int_value 3 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc13_62: Core.IntLiteral = int_value 2 [template = constants.%.4]
 // CHECK:STDOUT:   %.loc13_70: Core.IntLiteral = int_value 1 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc13_71.1: %.34 = struct_literal (%.loc13_54, %.loc13_62, %.loc13_70)
+// CHECK:STDOUT:   %.loc13_71.1: %.38 = struct_literal (%.loc13_54, %.loc13_62, %.loc13_70)
 // CHECK:STDOUT:   %.loc13_81.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc13_81: init type = call constants.%Int(%.loc13_81.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc13_81.2: type = value_of_initializer %int.make_type_signed.loc13_81 [template = constants.%i32]
@@ -181,47 +181,47 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %int.make_type_signed.loc13_99: init type = call constants.%Int(%.loc13_99.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc13_99.2: type = value_of_initializer %int.make_type_signed.loc13_99 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc13_99.3: type = converted %int.make_type_signed.loc13_99, %.loc13_99.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc13_102: type = struct_type {.b: %i32, .a: %i32, .c: %i32} [template = constants.%.35]
-// CHECK:STDOUT:   %.loc13_71.2: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_71.3: <bound method> = bound_method %.loc13_62, %.loc13_71.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc13_71.4: <specific function> = specific_function %.loc13_71.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc13_71.1: init %i32 = call %.loc13_71.4(%.loc13_62) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_71.5: %i32 = value_of_initializer %int.convert_checked.loc13_71.1 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_71.6: %i32 = converted %.loc13_62, %.loc13_71.5 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_71.7: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_71.8: <bound method> = bound_method %.loc13_70, %.loc13_71.7 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc13_71.9: <specific function> = specific_function %.loc13_71.8, @Convert.2(constants.%.1) [template = constants.%.26]
-// CHECK:STDOUT:   %int.convert_checked.loc13_71.2: init %i32 = call %.loc13_71.9(%.loc13_70) [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_71.10: %i32 = value_of_initializer %int.convert_checked.loc13_71.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_71.11: %i32 = converted %.loc13_70, %.loc13_71.10 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_71.12: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_71.13: <bound method> = bound_method %.loc13_54, %.loc13_71.12 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc13_71.14: <specific function> = specific_function %.loc13_71.13, @Convert.2(constants.%.1) [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc13_71.3: init %i32 = call %.loc13_71.14(%.loc13_54) [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_71.15: %i32 = value_of_initializer %int.convert_checked.loc13_71.3 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_71.16: %i32 = converted %.loc13_54, %.loc13_71.15 [template = constants.%.39]
-// CHECK:STDOUT:   %struct.loc13: %.35 = struct_value (%.loc13_71.6, %.loc13_71.11, %.loc13_71.16) [template = constants.%struct.1]
-// CHECK:STDOUT:   %.loc13_73.1: %.35 = converted %.loc13_71.1, %struct.loc13 [template = constants.%struct.1]
-// CHECK:STDOUT:   %.loc13_73.2: %i32 = struct_access %.loc13_73.1, element1 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc13_102: type = struct_type {.b: %i32, .a: %i32, .c: %i32} [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_71.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_71.3: <bound method> = bound_method %.loc13_62, %.loc13_71.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc13_71.4: <specific function> = specific_function %.loc13_71.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc13_71.1: init %i32 = call %.loc13_71.4(%.loc13_62) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_71.5: %i32 = value_of_initializer %int.convert_checked.loc13_71.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_71.6: %i32 = converted %.loc13_62, %.loc13_71.5 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_71.7: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_71.8: <bound method> = bound_method %.loc13_70, %.loc13_71.7 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc13_71.9: <specific function> = specific_function %.loc13_71.8, @Convert.2(constants.%.1) [template = constants.%.30]
+// CHECK:STDOUT:   %int.convert_checked.loc13_71.2: init %i32 = call %.loc13_71.9(%.loc13_70) [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_71.10: %i32 = value_of_initializer %int.convert_checked.loc13_71.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_71.11: %i32 = converted %.loc13_70, %.loc13_71.10 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_71.12: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_71.13: <bound method> = bound_method %.loc13_54, %.loc13_71.12 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc13_71.14: <specific function> = specific_function %.loc13_71.13, @Convert.2(constants.%.1) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc13_71.3: init %i32 = call %.loc13_71.14(%.loc13_54) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_71.15: %i32 = value_of_initializer %int.convert_checked.loc13_71.3 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_71.16: %i32 = converted %.loc13_54, %.loc13_71.15 [template = constants.%.43]
+// CHECK:STDOUT:   %struct.loc13: %.39 = struct_value (%.loc13_71.6, %.loc13_71.11, %.loc13_71.16) [template = constants.%struct.1]
+// CHECK:STDOUT:   %.loc13_73.1: %.39 = converted %.loc13_71.1, %struct.loc13 [template = constants.%struct.1]
+// CHECK:STDOUT:   %.loc13_73.2: %i32 = struct_access %.loc13_73.1, element1 [template = constants.%.31]
 // CHECK:STDOUT:   %.loc13_73.3: ref %i32 = struct_access file.%struct_copy.var, element1
-// CHECK:STDOUT:   %.loc13_73.4: init %i32 = initialize_from %.loc13_73.2 to %.loc13_73.3 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_73.5: %i32 = struct_access %.loc13_73.1, element0 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_73.4: init %i32 = initialize_from %.loc13_73.2 to %.loc13_73.3 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_73.5: %i32 = struct_access %.loc13_73.1, element0 [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_73.6: ref %i32 = struct_access file.%struct_copy.var, element0
-// CHECK:STDOUT:   %.loc13_73.7: init %i32 = initialize_from %.loc13_73.5 to %.loc13_73.6 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_73.8: %i32 = struct_access %.loc13_73.1, element2 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc13_73.7: init %i32 = initialize_from %.loc13_73.5 to %.loc13_73.6 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_73.8: %i32 = struct_access %.loc13_73.1, element2 [template = constants.%.43]
 // CHECK:STDOUT:   %.loc13_73.9: ref %i32 = struct_access file.%struct_copy.var, element2
-// CHECK:STDOUT:   %.loc13_73.10: init %i32 = initialize_from %.loc13_73.8 to %.loc13_73.9 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc13_73.11: init %.31 = struct_init (%.loc13_73.4, %.loc13_73.7, %.loc13_73.10) to file.%struct_copy.var [template = constants.%struct.2]
-// CHECK:STDOUT:   %.loc13_103: init %.31 = converted %.loc13_73.1, %.loc13_73.11 [template = constants.%struct.2]
+// CHECK:STDOUT:   %.loc13_73.10: init %i32 = initialize_from %.loc13_73.8 to %.loc13_73.9 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc13_73.11: init %.35 = struct_init (%.loc13_73.4, %.loc13_73.7, %.loc13_73.10) to file.%struct_copy.var [template = constants.%struct.2]
+// CHECK:STDOUT:   %.loc13_103: init %.35 = converted %.loc13_73.1, %.loc13_73.11 [template = constants.%struct.2]
 // CHECK:STDOUT:   assign file.%struct_copy.var, %.loc13_103
-// CHECK:STDOUT:   %.loc15_30: Core.IntLiteral = int_value 0 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc15_30: Core.IntLiteral = int_value 0 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc15_32.1: %tuple.type.4 = tuple_literal (%.loc15_30)
 // CHECK:STDOUT:   %.loc15_38.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc15: init type = call constants.%Int(%.loc15_38.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_44: Core.IntLiteral = int_value 5 [template = constants.%.43]
-// CHECK:STDOUT:   %.loc15_47: Core.IntLiteral = int_value 7 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc15_44: Core.IntLiteral = int_value 5 [template = constants.%.47]
+// CHECK:STDOUT:   %.loc15_47: Core.IntLiteral = int_value 7 [template = constants.%.48]
 // CHECK:STDOUT:   %.loc15_50: Core.IntLiteral = int_value 1 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc15_53: Core.IntLiteral = int_value 9 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc15_53: Core.IntLiteral = int_value 9 [template = constants.%.49]
 // CHECK:STDOUT:   %.loc15_54.1: %tuple.type.5 = tuple_literal (%.loc15_44, %.loc15_47, %.loc15_50, %.loc15_53)
 // CHECK:STDOUT:   %.loc15_56: Core.IntLiteral = int_value 2 [template = constants.%.4]
 // CHECK:STDOUT:   %tuple.loc15: %tuple.type.5 = tuple_value (%.loc15_44, %.loc15_47, %.loc15_50, %.loc15_53) [template = constants.%tuple.2]
@@ -229,43 +229,43 @@ var struct_access: [i32; 1] = (0,) as [i32; {.a = 3, .b = 1}.b];
 // CHECK:STDOUT:   %.loc15_55: Core.IntLiteral = tuple_access %.loc15_54.2, element2 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc15_38.2: type = value_of_initializer %int.make_type_signed.loc15 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc15_38.3: type = converted %int.make_type_signed.loc15, %.loc15_38.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc15_57: type = array_type %.loc15_55, %i32 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc15_32.2: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_32.3: <bound method> = bound_method %.loc15_30, %.loc15_32.2 [template = constants.%.47]
-// CHECK:STDOUT:   %.loc15_32.4: <specific function> = specific_function %.loc15_32.3, @Convert.2(constants.%.1) [template = constants.%.48]
-// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_32.4(%.loc15_30) [template = constants.%.49]
-// CHECK:STDOUT:   %.loc15_32.5: init %i32 = converted %.loc15_30, %int.convert_checked.loc15 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc15_5: ref %.40 = splice_block file.%tuple_index.var {}
-// CHECK:STDOUT:   %.loc15_32.6: Core.IntLiteral = int_value 0 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc15_57: type = array_type %.loc15_55, %i32 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc15_32.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_32.3: <bound method> = bound_method %.loc15_30, %.loc15_32.2 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc15_32.4: <specific function> = specific_function %.loc15_32.3, @Convert.2(constants.%.1) [template = constants.%.52]
+// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_32.4(%.loc15_30) [template = constants.%.53]
+// CHECK:STDOUT:   %.loc15_32.5: init %i32 = converted %.loc15_30, %int.convert_checked.loc15 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc15_5: ref %.44 = splice_block file.%tuple_index.var {}
+// CHECK:STDOUT:   %.loc15_32.6: Core.IntLiteral = int_value 0 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc15_32.7: ref %i32 = array_index %.loc15_5, %.loc15_32.6
-// CHECK:STDOUT:   %.loc15_32.8: init %i32 = initialize_from %.loc15_32.5 to %.loc15_32.7 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc15_32.9: init %.40 = array_init (%.loc15_32.8) to %.loc15_5 [template = constants.%array]
-// CHECK:STDOUT:   %.loc15_34: init %.40 = converted %.loc15_32.1, %.loc15_32.9 [template = constants.%array]
+// CHECK:STDOUT:   %.loc15_32.8: init %i32 = initialize_from %.loc15_32.5 to %.loc15_32.7 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc15_32.9: init %.44 = array_init (%.loc15_32.8) to %.loc15_5 [template = constants.%array]
+// CHECK:STDOUT:   %.loc15_34: init %.44 = converted %.loc15_32.1, %.loc15_32.9 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%tuple_index.var, %.loc15_34
-// CHECK:STDOUT:   %.loc17_32: Core.IntLiteral = int_value 0 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc17_32: Core.IntLiteral = int_value 0 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc17_34.1: %tuple.type.4 = tuple_literal (%.loc17_32)
 // CHECK:STDOUT:   %.loc17_40.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc17: init type = call constants.%Int(%.loc17_40.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc17_51: Core.IntLiteral = int_value 3 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc17_51: Core.IntLiteral = int_value 3 [template = constants.%.37]
 // CHECK:STDOUT:   %.loc17_59: Core.IntLiteral = int_value 1 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc17_60.1: %.50 = struct_literal (%.loc17_51, %.loc17_59)
-// CHECK:STDOUT:   %struct.loc17: %.50 = struct_value (%.loc17_51, %.loc17_59) [template = constants.%struct.3]
-// CHECK:STDOUT:   %.loc17_60.2: %.50 = converted %.loc17_60.1, %struct.loc17 [template = constants.%struct.3]
+// CHECK:STDOUT:   %.loc17_60.1: %.54 = struct_literal (%.loc17_51, %.loc17_59)
+// CHECK:STDOUT:   %struct.loc17: %.54 = struct_value (%.loc17_51, %.loc17_59) [template = constants.%struct.3]
+// CHECK:STDOUT:   %.loc17_60.2: %.54 = converted %.loc17_60.1, %struct.loc17 [template = constants.%struct.3]
 // CHECK:STDOUT:   %.loc17_61: Core.IntLiteral = struct_access %.loc17_60.2, element1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc17_40.2: type = value_of_initializer %int.make_type_signed.loc17 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc17_40.3: type = converted %int.make_type_signed.loc17, %.loc17_40.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc17_63: type = array_type %.loc17_61, %i32 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc17_34.2: %Convert.type.2 = interface_witness_access constants.%.24, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc17_34.3: <bound method> = bound_method %.loc17_32, %.loc17_34.2 [template = constants.%.47]
-// CHECK:STDOUT:   %.loc17_34.4: <specific function> = specific_function %.loc17_34.3, @Convert.2(constants.%.1) [template = constants.%.48]
-// CHECK:STDOUT:   %int.convert_checked.loc17: init %i32 = call %.loc17_34.4(%.loc17_32) [template = constants.%.49]
-// CHECK:STDOUT:   %.loc17_34.5: init %i32 = converted %.loc17_32, %int.convert_checked.loc17 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc17_5: ref %.40 = splice_block file.%struct_access.var {}
-// CHECK:STDOUT:   %.loc17_34.6: Core.IntLiteral = int_value 0 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc17_63: type = array_type %.loc17_61, %i32 [template = constants.%.44]
+// CHECK:STDOUT:   %.loc17_34.2: %Convert.type.2 = interface_witness_access constants.%.28, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc17_34.3: <bound method> = bound_method %.loc17_32, %.loc17_34.2 [template = constants.%.51]
+// CHECK:STDOUT:   %.loc17_34.4: <specific function> = specific_function %.loc17_34.3, @Convert.2(constants.%.1) [template = constants.%.52]
+// CHECK:STDOUT:   %int.convert_checked.loc17: init %i32 = call %.loc17_34.4(%.loc17_32) [template = constants.%.53]
+// CHECK:STDOUT:   %.loc17_34.5: init %i32 = converted %.loc17_32, %int.convert_checked.loc17 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc17_5: ref %.44 = splice_block file.%struct_access.var {}
+// CHECK:STDOUT:   %.loc17_34.6: Core.IntLiteral = int_value 0 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc17_34.7: ref %i32 = array_index %.loc17_5, %.loc17_34.6
-// CHECK:STDOUT:   %.loc17_34.8: init %i32 = initialize_from %.loc17_34.5 to %.loc17_34.7 [template = constants.%.49]
-// CHECK:STDOUT:   %.loc17_34.9: init %.40 = array_init (%.loc17_34.8) to %.loc17_5 [template = constants.%array]
-// CHECK:STDOUT:   %.loc17_36: init %.40 = converted %.loc17_34.1, %.loc17_34.9 [template = constants.%array]
+// CHECK:STDOUT:   %.loc17_34.8: init %i32 = initialize_from %.loc17_34.5 to %.loc17_34.7 [template = constants.%.53]
+// CHECK:STDOUT:   %.loc17_34.9: init %.44 = array_init (%.loc17_34.8) to %.loc17_5 [template = constants.%array]
+// CHECK:STDOUT:   %.loc17_36: init %.44 = converted %.loc17_34.1, %.loc17_34.9 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%struct_access.var, %.loc17_36
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/eval/fail_aggregate.carbon

@@ -35,25 +35,25 @@ var array_index: [i32; 1] = (0,) as [i32; ((5, 7, 1, 9) as [i32; 4])[2]];
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.6, %Convert.14 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 5 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.7, %Convert.14 [template]
-// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 7 [template]
-// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.39: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.6, %Convert.14 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.38: %i32 = int_value 5 [template]
+// CHECK:STDOUT:   %.39: <bound method> = bound_method %.7, %Convert.14 [template]
 // CHECK:STDOUT:   %.40: <specific function> = specific_function %.39, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.41: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.43: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 7 [template]
+// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.43: <bound method> = bound_method %.2, %Convert.14 [template]
 // CHECK:STDOUT:   %.44: <specific function> = specific_function %.43, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.45: %i32 = int_value 9 [template]
-// CHECK:STDOUT:   %array: %.10 = tuple_value (%.34, %.37, %.41, %.45) [template]
-// CHECK:STDOUT:   %.46: <bound method> = bound_method %.38, %Convert.14 [template]
-// CHECK:STDOUT:   %.47: <specific function> = specific_function %.46, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.48: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.45: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.46: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.47: <bound method> = bound_method %.8, %Convert.14 [template]
+// CHECK:STDOUT:   %.48: <specific function> = specific_function %.47, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.49: %i32 = int_value 9 [template]
+// CHECK:STDOUT:   %array: %.10 = tuple_value (%.38, %.41, %.45, %.49) [template]
+// CHECK:STDOUT:   %.50: <bound method> = bound_method %.42, %Convert.14 [template]
+// CHECK:STDOUT:   %.51: <specific function> = specific_function %.50, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.52: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -98,49 +98,49 @@ var array_index: [i32; 1] = (0,) as [i32; ((5, 7, 1, 9) as [i32; 4])[2]];
 // CHECK:STDOUT:   %.loc16_61.2: type = value_of_initializer %int.make_type_signed.loc16_61 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc16_61.3: type = converted %int.make_type_signed.loc16_61, %.loc16_61.2 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc16_67: type = array_type %.loc16_66, %i32 [template = constants.%.10]
-// CHECK:STDOUT:   %.loc16_55.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_55.3: <bound method> = bound_method %.loc16_45, %.loc16_55.2 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc16_55.4: <specific function> = specific_function %.loc16_55.3, @Convert.2(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc16_55.1: init %i32 = call %.loc16_55.4(%.loc16_45) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_55.5: init %i32 = converted %.loc16_45, %int.convert_checked.loc16_55.1 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_55.2: %Convert.type.2 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_55.3: <bound method> = bound_method %.loc16_45, %.loc16_55.2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc16_55.4: <specific function> = specific_function %.loc16_55.3, @Convert.2(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc16_55.1: init %i32 = call %.loc16_55.4(%.loc16_45) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_55.5: init %i32 = converted %.loc16_45, %int.convert_checked.loc16_55.1 [template = constants.%.38]
 // CHECK:STDOUT:   %.loc16_55.6: ref %.10 = temporary_storage
 // CHECK:STDOUT:   %.loc16_55.7: Core.IntLiteral = int_value 0 [template = constants.%.5]
 // CHECK:STDOUT:   %.loc16_55.8: ref %i32 = array_index %.loc16_55.6, %.loc16_55.7
-// CHECK:STDOUT:   %.loc16_55.9: init %i32 = initialize_from %.loc16_55.5 to %.loc16_55.8 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc16_55.10: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_55.11: <bound method> = bound_method %.loc16_48, %.loc16_55.10 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc16_55.12: <specific function> = specific_function %.loc16_55.11, @Convert.2(constants.%.1) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc16_55.2: init %i32 = call %.loc16_55.12(%.loc16_48) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc16_55.13: init %i32 = converted %.loc16_48, %int.convert_checked.loc16_55.2 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc16_55.9: init %i32 = initialize_from %.loc16_55.5 to %.loc16_55.8 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_55.10: %Convert.type.2 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_55.11: <bound method> = bound_method %.loc16_48, %.loc16_55.10 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc16_55.12: <specific function> = specific_function %.loc16_55.11, @Convert.2(constants.%.1) [template = constants.%.40]
+// CHECK:STDOUT:   %int.convert_checked.loc16_55.2: init %i32 = call %.loc16_55.12(%.loc16_48) [template = constants.%.41]
+// CHECK:STDOUT:   %.loc16_55.13: init %i32 = converted %.loc16_48, %int.convert_checked.loc16_55.2 [template = constants.%.41]
 // CHECK:STDOUT:   %.loc16_55.14: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc16_55.15: ref %i32 = array_index %.loc16_55.6, %.loc16_55.14
-// CHECK:STDOUT:   %.loc16_55.16: init %i32 = initialize_from %.loc16_55.13 to %.loc16_55.15 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc16_55.17: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_55.18: <bound method> = bound_method %.loc16_51, %.loc16_55.17 [template = constants.%.39]
-// CHECK:STDOUT:   %.loc16_55.19: <specific function> = specific_function %.loc16_55.18, @Convert.2(constants.%.1) [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc16_55.3: init %i32 = call %.loc16_55.19(%.loc16_51) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc16_55.20: init %i32 = converted %.loc16_51, %int.convert_checked.loc16_55.3 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc16_55.21: Core.IntLiteral = int_value 2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_55.16: init %i32 = initialize_from %.loc16_55.13 to %.loc16_55.15 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc16_55.17: %Convert.type.2 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_55.18: <bound method> = bound_method %.loc16_51, %.loc16_55.17 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc16_55.19: <specific function> = specific_function %.loc16_55.18, @Convert.2(constants.%.1) [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc16_55.3: init %i32 = call %.loc16_55.19(%.loc16_51) [template = constants.%.45]
+// CHECK:STDOUT:   %.loc16_55.20: init %i32 = converted %.loc16_51, %int.convert_checked.loc16_55.3 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc16_55.21: Core.IntLiteral = int_value 2 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc16_55.22: ref %i32 = array_index %.loc16_55.6, %.loc16_55.21
-// CHECK:STDOUT:   %.loc16_55.23: init %i32 = initialize_from %.loc16_55.20 to %.loc16_55.22 [template = constants.%.41]
-// CHECK:STDOUT:   %.loc16_55.24: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_55.25: <bound method> = bound_method %.loc16_54, %.loc16_55.24 [template = constants.%.43]
-// CHECK:STDOUT:   %.loc16_55.26: <specific function> = specific_function %.loc16_55.25, @Convert.2(constants.%.1) [template = constants.%.44]
-// CHECK:STDOUT:   %int.convert_checked.loc16_55.4: init %i32 = call %.loc16_55.26(%.loc16_54) [template = constants.%.45]
-// CHECK:STDOUT:   %.loc16_55.27: init %i32 = converted %.loc16_54, %int.convert_checked.loc16_55.4 [template = constants.%.45]
-// CHECK:STDOUT:   %.loc16_55.28: Core.IntLiteral = int_value 3 [template = constants.%.42]
+// CHECK:STDOUT:   %.loc16_55.23: init %i32 = initialize_from %.loc16_55.20 to %.loc16_55.22 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc16_55.24: %Convert.type.2 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_55.25: <bound method> = bound_method %.loc16_54, %.loc16_55.24 [template = constants.%.47]
+// CHECK:STDOUT:   %.loc16_55.26: <specific function> = specific_function %.loc16_55.25, @Convert.2(constants.%.1) [template = constants.%.48]
+// CHECK:STDOUT:   %int.convert_checked.loc16_55.4: init %i32 = call %.loc16_55.26(%.loc16_54) [template = constants.%.49]
+// CHECK:STDOUT:   %.loc16_55.27: init %i32 = converted %.loc16_54, %int.convert_checked.loc16_55.4 [template = constants.%.49]
+// CHECK:STDOUT:   %.loc16_55.28: Core.IntLiteral = int_value 3 [template = constants.%.46]
 // CHECK:STDOUT:   %.loc16_55.29: ref %i32 = array_index %.loc16_55.6, %.loc16_55.28
-// CHECK:STDOUT:   %.loc16_55.30: init %i32 = initialize_from %.loc16_55.27 to %.loc16_55.29 [template = constants.%.45]
+// CHECK:STDOUT:   %.loc16_55.30: init %i32 = initialize_from %.loc16_55.27 to %.loc16_55.29 [template = constants.%.49]
 // CHECK:STDOUT:   %.loc16_55.31: init %.10 = array_init (%.loc16_55.9, %.loc16_55.16, %.loc16_55.23, %.loc16_55.30) to %.loc16_55.6 [template = constants.%array]
 // CHECK:STDOUT:   %.loc16_57.1: init %.10 = converted %.loc16_55.1, %.loc16_55.31 [template = constants.%array]
-// CHECK:STDOUT:   %.loc16_70.1: Core.IntLiteral = int_value 2 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc16_70.1: Core.IntLiteral = int_value 2 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc16_57.2: ref %.10 = temporary %.loc16_55.6, %.loc16_57.1
-// CHECK:STDOUT:   %.loc16_70.2: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_70.3: <bound method> = bound_method %.loc16_70.1, %.loc16_70.2 [template = constants.%.46]
-// CHECK:STDOUT:   %.loc16_70.4: <specific function> = specific_function %.loc16_70.3, @Convert.2(constants.%.1) [template = constants.%.47]
-// CHECK:STDOUT:   %int.convert_checked.loc16_70: init %i32 = call %.loc16_70.4(%.loc16_70.1) [template = constants.%.48]
-// CHECK:STDOUT:   %.loc16_70.5: %i32 = value_of_initializer %int.convert_checked.loc16_70 [template = constants.%.48]
-// CHECK:STDOUT:   %.loc16_70.6: %i32 = converted %.loc16_70.1, %.loc16_70.5 [template = constants.%.48]
+// CHECK:STDOUT:   %.loc16_70.2: %Convert.type.2 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_70.3: <bound method> = bound_method %.loc16_70.1, %.loc16_70.2 [template = constants.%.50]
+// CHECK:STDOUT:   %.loc16_70.4: <specific function> = specific_function %.loc16_70.3, @Convert.2(constants.%.1) [template = constants.%.51]
+// CHECK:STDOUT:   %int.convert_checked.loc16_70: init %i32 = call %.loc16_70.4(%.loc16_70.1) [template = constants.%.52]
+// CHECK:STDOUT:   %.loc16_70.5: %i32 = value_of_initializer %int.convert_checked.loc16_70 [template = constants.%.52]
+// CHECK:STDOUT:   %.loc16_70.6: %i32 = converted %.loc16_70.1, %.loc16_70.5 [template = constants.%.52]
 // CHECK:STDOUT:   %.loc16_71.1: ref %i32 = array_index %.loc16_57.2, %.loc16_70.6
 // CHECK:STDOUT:   %.loc16_71.2: %i32 = bind_value %.loc16_71.1
 // CHECK:STDOUT:   %.loc16_38.2: type = value_of_initializer %int.make_type_signed.loc16_38 [template = constants.%i32]

toolchain/check/testdata/eval/fail_symbolic.carbon

@@ -30,10 +30,10 @@ fn G(N:! i32) {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.13: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.13: %Convert.type.13 = struct_value () [template]
-// CHECK:STDOUT:   %.19: <witness> = interface_witness (%Convert.13) [template]
-// CHECK:STDOUT:   %.20: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
-// CHECK:STDOUT:   %.21: <specific function> = specific_function %.20, @Convert.4(%.1) [symbolic]
-// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.21(%N.1) [symbolic]
+// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.13) [template]
+// CHECK:STDOUT:   %.24: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
+// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.4(%.1) [symbolic]
+// CHECK:STDOUT:   %int.convert_checked: init Core.IntLiteral = call %.25(%N.1) [symbolic]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -69,8 +69,8 @@ fn G(N:! i32) {
 // CHECK:STDOUT:   %N.patt.loc12_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc12_6.2 (constants.%N.patt.1)]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !definition:
-// CHECK:STDOUT:   %.loc16_16.6: <bound method> = bound_method %N.loc12_6.2, constants.%Convert.13 [symbolic = %.loc16_16.6 (constants.%.20)]
-// CHECK:STDOUT:   %.loc16_16.7: <specific function> = specific_function %.loc16_16.6, @Convert.4(constants.%.1) [symbolic = %.loc16_16.7 (constants.%.21)]
+// CHECK:STDOUT:   %.loc16_16.6: <bound method> = bound_method %N.loc12_6.2, constants.%Convert.13 [symbolic = %.loc16_16.6 (constants.%.24)]
+// CHECK:STDOUT:   %.loc16_16.7: <specific function> = specific_function %.loc16_16.6, @Convert.4(constants.%.1) [symbolic = %.loc16_16.7 (constants.%.25)]
 // CHECK:STDOUT:   %int.convert_checked.loc16_16.2: init Core.IntLiteral = call %.loc16_16.7(%N.loc12_6.2) [symbolic = %int.convert_checked.loc16_16.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   fn(%N.param_patt: %i32) {
@@ -80,9 +80,9 @@ fn G(N:! i32) {
 // CHECK:STDOUT:     %N.ref: %i32 = name_ref N, %N.loc12_6.1 [symbolic = %N.loc12_6.2 (constants.%N.1)]
 // CHECK:STDOUT:     %.loc16_11.2: type = value_of_initializer %int.make_type_signed.loc16 [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_11.3: type = converted %int.make_type_signed.loc16, %.loc16_11.2 [template = constants.%i32]
-// CHECK:STDOUT:     %.loc16_16.1: %Convert.type.2 = interface_witness_access constants.%.19, element0 [template = constants.%Convert.13]
-// CHECK:STDOUT:     %.loc16_16.2: <bound method> = bound_method %N.ref, %.loc16_16.1 [symbolic = %.loc16_16.6 (constants.%.20)]
-// CHECK:STDOUT:     %.loc16_16.3: <specific function> = specific_function %.loc16_16.2, @Convert.4(constants.%.1) [symbolic = %.loc16_16.7 (constants.%.21)]
+// CHECK:STDOUT:     %.loc16_16.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.13]
+// CHECK:STDOUT:     %.loc16_16.2: <bound method> = bound_method %N.ref, %.loc16_16.1 [symbolic = %.loc16_16.6 (constants.%.24)]
+// CHECK:STDOUT:     %.loc16_16.3: <specific function> = specific_function %.loc16_16.2, @Convert.4(constants.%.1) [symbolic = %.loc16_16.7 (constants.%.25)]
 // CHECK:STDOUT:     %int.convert_checked.loc16_16.1: init Core.IntLiteral = call %.loc16_16.3(%N.ref) [symbolic = %int.convert_checked.loc16_16.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc16_16.4: Core.IntLiteral = value_of_initializer %int.convert_checked.loc16_16.1 [symbolic = %int.convert_checked.loc16_16.2 (constants.%int.convert_checked)]
 // CHECK:STDOUT:     %.loc16_16.5: Core.IntLiteral = converted %N.ref, %.loc16_16.4 [symbolic = %int.convert_checked.loc16_16.2 (constants.%int.convert_checked)]

toolchain/check/testdata/function/builtin/call.carbon

@@ -27,21 +27,21 @@ var arr: [i32; Add(1, 2)];
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 3 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.4, @impl.3(%.1) [template]
 // CHECK:STDOUT:   %Convert.15: %Convert.type.15 = struct_value () [template]
-// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.15) [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.30, %Convert.15 [template]
-// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.4(%.1) [template]
-// CHECK:STDOUT:   %.34: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.35: type = array_type %.34, %i32 [template]
+// CHECK:STDOUT:   %.35: <witness> = interface_witness (%Convert.15) [template]
+// CHECK:STDOUT:   %.36: <bound method> = bound_method %.34, %Convert.15 [template]
+// CHECK:STDOUT:   %.37: <specific function> = specific_function %.36, @Convert.4(%.1) [template]
+// CHECK:STDOUT:   %.38: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.39: type = array_type %.38, %i32 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -92,32 +92,32 @@ var arr: [i32; Add(1, 2)];
 // CHECK:STDOUT:   %Add.ref: %Add.type = name_ref Add, %Add.decl [template = constants.%Add]
 // CHECK:STDOUT:   %.loc13_20.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc13_23.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc13_20.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_20.3: <bound method> = bound_method %.loc13_20.1, %.loc13_20.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc13_20.4: <specific function> = specific_function %.loc13_20.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc13_20: init %i32 = call %.loc13_20.4(%.loc13_20.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_20.5: %i32 = value_of_initializer %int.convert_checked.loc13_20 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_20.6: %i32 = converted %.loc13_20.1, %.loc13_20.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_23.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_23.3: <bound method> = bound_method %.loc13_23.1, %.loc13_23.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc13_23.4: <specific function> = specific_function %.loc13_23.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc13_23: init %i32 = call %.loc13_23.4(%.loc13_23.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_23.5: %i32 = value_of_initializer %int.convert_checked.loc13_23 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc13_23.6: %i32 = converted %.loc13_23.1, %.loc13_23.5 [template = constants.%.29]
-// CHECK:STDOUT:   %int.sadd: init %i32 = call %Add.ref(%.loc13_20.6, %.loc13_23.6) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_20.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_20.3: <bound method> = bound_method %.loc13_20.1, %.loc13_20.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_20.4: <specific function> = specific_function %.loc13_20.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc13_20: init %i32 = call %.loc13_20.4(%.loc13_20.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_20.5: %i32 = value_of_initializer %int.convert_checked.loc13_20 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_20.6: %i32 = converted %.loc13_20.1, %.loc13_20.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_23.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_23.3: <bound method> = bound_method %.loc13_23.1, %.loc13_23.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc13_23.4: <specific function> = specific_function %.loc13_23.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc13_23: init %i32 = call %.loc13_23.4(%.loc13_23.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_23.5: %i32 = value_of_initializer %int.convert_checked.loc13_23 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc13_23.6: %i32 = converted %.loc13_23.1, %.loc13_23.5 [template = constants.%.33]
+// CHECK:STDOUT:   %int.sadd: init %i32 = call %Add.ref(%.loc13_20.6, %.loc13_23.6) [template = constants.%.34]
 // CHECK:STDOUT:   %.loc13_11.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:   %.loc13_11.3: type = converted %int.make_type_signed, %.loc13_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc13_19.1: %Convert.type.6 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.15]
-// CHECK:STDOUT:   %.loc13_19.2: <bound method> = bound_method %int.sadd, %.loc13_19.1 [template = constants.%.32]
-// CHECK:STDOUT:   %.loc13_19.3: <specific function> = specific_function %.loc13_19.2, @Convert.4(constants.%.1) [template = constants.%.33]
-// CHECK:STDOUT:   %.loc13_19.4: %i32 = value_of_initializer %int.sadd [template = constants.%.30]
-// CHECK:STDOUT:   %.loc13_19.5: %i32 = converted %int.sadd, %.loc13_19.4 [template = constants.%.30]
-// CHECK:STDOUT:   %int.convert_checked.loc13_19: init Core.IntLiteral = call %.loc13_19.3(%.loc13_19.5) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc13_19 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_19.7: Core.IntLiteral = converted %int.sadd, %.loc13_19.6 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc13_25: type = array_type %.loc13_19.7, %i32 [template = constants.%.35]
-// CHECK:STDOUT:   %arr.var: ref %.35 = var arr
-// CHECK:STDOUT:   %arr: ref %.35 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc13_19.1: %Convert.type.6 = interface_witness_access constants.%.35, element0 [template = constants.%Convert.15]
+// CHECK:STDOUT:   %.loc13_19.2: <bound method> = bound_method %int.sadd, %.loc13_19.1 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc13_19.3: <specific function> = specific_function %.loc13_19.2, @Convert.4(constants.%.1) [template = constants.%.37]
+// CHECK:STDOUT:   %.loc13_19.4: %i32 = value_of_initializer %int.sadd [template = constants.%.34]
+// CHECK:STDOUT:   %.loc13_19.5: %i32 = converted %int.sadd, %.loc13_19.4 [template = constants.%.34]
+// CHECK:STDOUT:   %int.convert_checked.loc13_19: init Core.IntLiteral = call %.loc13_19.3(%.loc13_19.5) [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_19.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc13_19 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_19.7: Core.IntLiteral = converted %int.sadd, %.loc13_19.6 [template = constants.%.38]
+// CHECK:STDOUT:   %.loc13_25: type = array_type %.loc13_19.7, %i32 [template = constants.%.39]
+// CHECK:STDOUT:   %arr.var: ref %.39 = var arr
+// CHECK:STDOUT:   %arr: ref %.39 = bind_name arr, %arr.var
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Add(%a.param_patt: %i32, %b.param_patt: %i32) -> %i32 = "int.sadd";

toolchain/check/testdata/function/builtin/method.carbon

@@ -23,43 +23,45 @@ var arr: [i32; (1 as i32).(I.F)(2)];
 // CHECK:STDOUT: constants {
 // CHECK:STDOUT:   %I.type: type = facet_type <@I> [template]
 // CHECK:STDOUT:   %Self.1: %I.type = bind_symbolic_name Self, 0 [symbolic]
+// CHECK:STDOUT:   %.1: type = facet_access_type %Self.1 [symbolic]
 // CHECK:STDOUT:   %F.type.1: type = fn_type @F.1 [template]
 // CHECK:STDOUT:   %F.1: %F.type.1 = struct_value () [template]
-// CHECK:STDOUT:   %.1: type = assoc_entity_type %I.type, %F.type.1 [template]
-// CHECK:STDOUT:   %.2: %.1 = assoc_entity element0, @I.%F.decl [template]
-// CHECK:STDOUT:   %.3: Core.IntLiteral = int_value 32 [template]
+// CHECK:STDOUT:   %.2: type = assoc_entity_type %I.type, %F.type.1 [template]
+// CHECK:STDOUT:   %.3: %.2 = assoc_entity element0, @I.%F.decl [template]
+// CHECK:STDOUT:   %.4: Core.IntLiteral = int_value 32 [template]
 // CHECK:STDOUT:   %Int.type: type = fn_type @Int [template]
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
-// CHECK:STDOUT:   %i32: type = int_type signed, %.3 [template]
+// CHECK:STDOUT:   %i32: type = int_type signed, %.4 [template]
 // CHECK:STDOUT:   %F.type.2: type = fn_type @F.2 [template]
 // CHECK:STDOUT:   %F.2: %F.type.2 = struct_value () [template]
-// CHECK:STDOUT:   %.4: <witness> = interface_witness (%F.2) [template]
-// CHECK:STDOUT:   %.5: Core.IntLiteral = int_value 1 [template]
+// CHECK:STDOUT:   %.5: %I.type = facet_value %i32, %i32 [template]
+// CHECK:STDOUT:   %.6: <witness> = interface_witness (%F.2) [template]
+// CHECK:STDOUT:   %.7: Core.IntLiteral = int_value 1 [template]
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.7: type = fn_type @Convert.2, @ImplicitAs(Core.IntLiteral) [template]
-// CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.7, @impl.6(%.3) [template]
+// CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.7, @impl.6(%.4) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.25: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.26: <bound method> = bound_method %.5, %Convert.14 [template]
-// CHECK:STDOUT:   %.27: <specific function> = specific_function %.26, @Convert.7(%.3) [template]
-// CHECK:STDOUT:   %.28: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.29: <bound method> = bound_method %.28, %F.2 [template]
-// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.7, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.7(%.4) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.35: <bound method> = bound_method %.34, %F.2 [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 2 [template]
 // CHECK:STDOUT:   %Convert.type.15: type = fn_type @Convert.2, @ImplicitAs(%i32) [template]
-// CHECK:STDOUT:   %Convert.type.16: type = fn_type @Convert.3, @impl.2(%.3) [template]
+// CHECK:STDOUT:   %Convert.type.16: type = fn_type @Convert.3, @impl.2(%.4) [template]
 // CHECK:STDOUT:   %Convert.16: %Convert.type.16 = struct_value () [template]
-// CHECK:STDOUT:   %.34: <witness> = interface_witness (%Convert.16) [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.30, %Convert.16 [template]
-// CHECK:STDOUT:   %.36: <specific function> = specific_function %.35, @Convert.3(%.3) [template]
-// CHECK:STDOUT:   %.37: %i32 = int_value 2 [template]
-// CHECK:STDOUT:   %.38: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %Convert.type.17: type = fn_type @Convert.5, @impl.4(%.3) [template]
+// CHECK:STDOUT:   %.40: <witness> = interface_witness (%Convert.16) [template]
+// CHECK:STDOUT:   %.41: <bound method> = bound_method %.36, %Convert.16 [template]
+// CHECK:STDOUT:   %.42: <specific function> = specific_function %.41, @Convert.3(%.4) [template]
+// CHECK:STDOUT:   %.43: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.44: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %Convert.type.17: type = fn_type @Convert.5, @impl.4(%.4) [template]
 // CHECK:STDOUT:   %Convert.17: %Convert.type.17 = struct_value () [template]
-// CHECK:STDOUT:   %.39: <witness> = interface_witness (%Convert.17) [template]
-// CHECK:STDOUT:   %.40: <bound method> = bound_method %.38, %Convert.17 [template]
-// CHECK:STDOUT:   %.41: <specific function> = specific_function %.40, @Convert.5(%.3) [template]
-// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.43: type = array_type %.42, %i32 [template]
+// CHECK:STDOUT:   %.45: <witness> = interface_witness (%Convert.17) [template]
+// CHECK:STDOUT:   %.46: <bound method> = bound_method %.44, %Convert.17 [template]
+// CHECK:STDOUT:   %.47: <specific function> = specific_function %.46, @Convert.5(%.4) [template]
+// CHECK:STDOUT:   %.48: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.49: type = array_type %.48, %i32 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -81,79 +83,79 @@ var arr: [i32; (1 as i32).(I.F)(2)];
 // CHECK:STDOUT:   %Core.import = import Core
 // CHECK:STDOUT:   %I.decl: type = interface_decl @I [template = constants.%I.type] {} {}
 // CHECK:STDOUT:   impl_decl @impl.1 [template] {} {
-// CHECK:STDOUT:     %.loc15_6.1: Core.IntLiteral = int_value 32 [template = constants.%.3]
+// CHECK:STDOUT:     %.loc15_6.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc15_6.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc15_6.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc15_6.3: type = converted %int.make_type_signed, %.loc15_6.2 [template = constants.%i32]
 // CHECK:STDOUT:     %I.ref: type = name_ref I, file.%I.decl [template = constants.%I.type]
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc19_11.1: Core.IntLiteral = int_value 32 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc19_11.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
 // CHECK:STDOUT:   %int.make_type_signed.loc19_11: init type = call constants.%Int(%.loc19_11.1) [template = constants.%i32]
-// CHECK:STDOUT:   %.loc19_17: Core.IntLiteral = int_value 1 [template = constants.%.5]
-// CHECK:STDOUT:   %.loc19_22.1: Core.IntLiteral = int_value 32 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc19_17: Core.IntLiteral = int_value 1 [template = constants.%.7]
+// CHECK:STDOUT:   %.loc19_22.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
 // CHECK:STDOUT:   %int.make_type_signed.loc19_22: init type = call constants.%Int(%.loc19_22.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc19_22.2: type = value_of_initializer %int.make_type_signed.loc19_22 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc19_22.3: type = converted %int.make_type_signed.loc19_22, %.loc19_22.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc19_19.1: %Convert.type.2 = interface_witness_access constants.%.25, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc19_19.2: <bound method> = bound_method %.loc19_17, %.loc19_19.1 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc19_19.3: <specific function> = specific_function %.loc19_19.2, @Convert.7(constants.%.3) [template = constants.%.27]
-// CHECK:STDOUT:   %int.convert_checked.loc19_19: init %i32 = call %.loc19_19.3(%.loc19_17) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc19_19.4: %i32 = value_of_initializer %int.convert_checked.loc19_19 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc19_19.5: %i32 = converted %.loc19_17, %.loc19_19.4 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc19_19.1: %Convert.type.2 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc19_19.2: <bound method> = bound_method %.loc19_17, %.loc19_19.1 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc19_19.3: <specific function> = specific_function %.loc19_19.2, @Convert.7(constants.%.4) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc19_19: init %i32 = call %.loc19_19.3(%.loc19_17) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_19.4: %i32 = value_of_initializer %int.convert_checked.loc19_19 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc19_19.5: %i32 = converted %.loc19_17, %.loc19_19.4 [template = constants.%.34]
 // CHECK:STDOUT:   %I.ref: type = name_ref I, %I.decl [template = constants.%I.type]
-// CHECK:STDOUT:   %F.ref: %.1 = name_ref F, @I.%.loc12 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc19_26.1: %F.type.1 = interface_witness_access constants.%.4, element0 [template = constants.%F.2]
-// CHECK:STDOUT:   %.loc19_26.2: <bound method> = bound_method %.loc19_19.5, %.loc19_26.1 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc19_33.1: Core.IntLiteral = int_value 2 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc19_33.2: %Convert.type.15 = interface_witness_access constants.%.34, element0 [template = constants.%Convert.16]
-// CHECK:STDOUT:   %.loc19_33.3: <bound method> = bound_method %.loc19_33.1, %.loc19_33.2 [template = constants.%.35]
-// CHECK:STDOUT:   %.loc19_33.4: <specific function> = specific_function %.loc19_33.3, @Convert.3(constants.%.3) [template = constants.%.36]
-// CHECK:STDOUT:   %int.convert_checked.loc19_33: init %i32 = call %.loc19_33.4(%.loc19_33.1) [template = constants.%.37]
-// CHECK:STDOUT:   %.loc19_33.5: %i32 = value_of_initializer %int.convert_checked.loc19_33 [template = constants.%.37]
-// CHECK:STDOUT:   %.loc19_33.6: %i32 = converted %.loc19_33.1, %.loc19_33.5 [template = constants.%.37]
-// CHECK:STDOUT:   %int.sadd: init %i32 = call %.loc19_26.2(%.loc19_19.5, %.loc19_33.6) [template = constants.%.38]
+// CHECK:STDOUT:   %F.ref: %.2 = name_ref F, @I.%.loc12 [template = constants.%.3]
+// CHECK:STDOUT:   %.loc19_26.1: %F.type.1 = interface_witness_access constants.%.6, element0 [template = constants.%F.2]
+// CHECK:STDOUT:   %.loc19_26.2: <bound method> = bound_method %.loc19_19.5, %.loc19_26.1 [template = constants.%.35]
+// CHECK:STDOUT:   %.loc19_33.1: Core.IntLiteral = int_value 2 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc19_33.2: %Convert.type.15 = interface_witness_access constants.%.40, element0 [template = constants.%Convert.16]
+// CHECK:STDOUT:   %.loc19_33.3: <bound method> = bound_method %.loc19_33.1, %.loc19_33.2 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc19_33.4: <specific function> = specific_function %.loc19_33.3, @Convert.3(constants.%.4) [template = constants.%.42]
+// CHECK:STDOUT:   %int.convert_checked.loc19_33: init %i32 = call %.loc19_33.4(%.loc19_33.1) [template = constants.%.43]
+// CHECK:STDOUT:   %.loc19_33.5: %i32 = value_of_initializer %int.convert_checked.loc19_33 [template = constants.%.43]
+// CHECK:STDOUT:   %.loc19_33.6: %i32 = converted %.loc19_33.1, %.loc19_33.5 [template = constants.%.43]
+// CHECK:STDOUT:   %int.sadd: init %i32 = call %.loc19_26.2(%.loc19_19.5, %.loc19_33.6) [template = constants.%.44]
 // CHECK:STDOUT:   %.loc19_11.2: type = value_of_initializer %int.make_type_signed.loc19_11 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc19_11.3: type = converted %int.make_type_signed.loc19_11, %.loc19_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc19_32.1: %Convert.type.7 = interface_witness_access constants.%.39, element0 [template = constants.%Convert.17]
-// CHECK:STDOUT:   %.loc19_32.2: <bound method> = bound_method %int.sadd, %.loc19_32.1 [template = constants.%.40]
-// CHECK:STDOUT:   %.loc19_32.3: <specific function> = specific_function %.loc19_32.2, @Convert.5(constants.%.3) [template = constants.%.41]
-// CHECK:STDOUT:   %.loc19_32.4: %i32 = value_of_initializer %int.sadd [template = constants.%.38]
-// CHECK:STDOUT:   %.loc19_32.5: %i32 = converted %int.sadd, %.loc19_32.4 [template = constants.%.38]
-// CHECK:STDOUT:   %int.convert_checked.loc19_32: init Core.IntLiteral = call %.loc19_32.3(%.loc19_32.5) [template = constants.%.42]
-// CHECK:STDOUT:   %.loc19_32.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc19_32 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc19_32.7: Core.IntLiteral = converted %int.sadd, %.loc19_32.6 [template = constants.%.42]
-// CHECK:STDOUT:   %.loc19_35: type = array_type %.loc19_32.7, %i32 [template = constants.%.43]
-// CHECK:STDOUT:   %arr.var: ref %.43 = var arr
-// CHECK:STDOUT:   %arr: ref %.43 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc19_32.1: %Convert.type.7 = interface_witness_access constants.%.45, element0 [template = constants.%Convert.17]
+// CHECK:STDOUT:   %.loc19_32.2: <bound method> = bound_method %int.sadd, %.loc19_32.1 [template = constants.%.46]
+// CHECK:STDOUT:   %.loc19_32.3: <specific function> = specific_function %.loc19_32.2, @Convert.5(constants.%.4) [template = constants.%.47]
+// CHECK:STDOUT:   %.loc19_32.4: %i32 = value_of_initializer %int.sadd [template = constants.%.44]
+// CHECK:STDOUT:   %.loc19_32.5: %i32 = converted %int.sadd, %.loc19_32.4 [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc19_32: init Core.IntLiteral = call %.loc19_32.3(%.loc19_32.5) [template = constants.%.48]
+// CHECK:STDOUT:   %.loc19_32.6: Core.IntLiteral = value_of_initializer %int.convert_checked.loc19_32 [template = constants.%.48]
+// CHECK:STDOUT:   %.loc19_32.7: Core.IntLiteral = converted %int.sadd, %.loc19_32.6 [template = constants.%.48]
+// CHECK:STDOUT:   %.loc19_35: type = array_type %.loc19_32.7, %i32 [template = constants.%.49]
+// CHECK:STDOUT:   %arr.var: ref %.49 = var arr
+// CHECK:STDOUT:   %arr: ref %.49 = bind_name arr, %arr.var
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: interface @I {
 // CHECK:STDOUT:   %Self: %I.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.1]
 // CHECK:STDOUT:   %F.decl: %F.type.1 = fn_decl @F.1 [template = constants.%F.1] {
-// CHECK:STDOUT:     %self.patt: @F.1.%Self (%Self.1) = binding_pattern self
-// CHECK:STDOUT:     %self.param_patt: @F.1.%Self (%Self.1) = value_param_pattern %self.patt, runtime_param0
-// CHECK:STDOUT:     %other.patt: @F.1.%Self (%Self.1) = binding_pattern other
-// CHECK:STDOUT:     %other.param_patt: @F.1.%Self (%Self.1) = value_param_pattern %other.patt, runtime_param1
-// CHECK:STDOUT:     %return.patt: @F.1.%Self (%Self.1) = return_slot_pattern
-// CHECK:STDOUT:     %return.param_patt: @F.1.%Self (%Self.1) = out_param_pattern %return.patt, runtime_param2
+// CHECK:STDOUT:     %self.patt: @F.1.%.loc12_14.1 (%.1) = binding_pattern self
+// CHECK:STDOUT:     %self.param_patt: @F.1.%.loc12_14.1 (%.1) = value_param_pattern %self.patt, runtime_param0
+// CHECK:STDOUT:     %other.patt: @F.1.%.loc12_14.1 (%.1) = binding_pattern other
+// CHECK:STDOUT:     %other.param_patt: @F.1.%.loc12_14.1 (%.1) = value_param_pattern %other.patt, runtime_param1
+// CHECK:STDOUT:     %return.patt: @F.1.%.loc12_14.1 (%.1) = return_slot_pattern
+// CHECK:STDOUT:     %return.param_patt: @F.1.%.loc12_14.1 (%.1) = out_param_pattern %return.patt, runtime_param2
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Self.ref.loc12_14: %I.type = name_ref Self, @I.%Self [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc12_14.1: type = facet_type_access %Self.ref.loc12_14 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc12_14.2: type = converted %Self.ref.loc12_14, %.loc12_14.1 [symbolic = %Self (constants.%Self.1)]
+// CHECK:STDOUT:     %.loc12_14.2: type = facet_access_type %Self.ref.loc12_14 [symbolic = %.loc12_14.1 (constants.%.1)]
+// CHECK:STDOUT:     %.loc12_14.3: type = converted %Self.ref.loc12_14, %.loc12_14.2 [symbolic = %.loc12_14.1 (constants.%.1)]
 // CHECK:STDOUT:     %Self.ref.loc12_27: %I.type = name_ref Self, @I.%Self [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc12_27.1: type = facet_type_access %Self.ref.loc12_27 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc12_27.2: type = converted %Self.ref.loc12_27, %.loc12_27.1 [symbolic = %Self (constants.%Self.1)]
+// CHECK:STDOUT:     %.loc12_27.1: type = facet_access_type %Self.ref.loc12_27 [symbolic = %.loc12_14.1 (constants.%.1)]
+// CHECK:STDOUT:     %.loc12_27.2: type = converted %Self.ref.loc12_27, %.loc12_27.1 [symbolic = %.loc12_14.1 (constants.%.1)]
 // CHECK:STDOUT:     %Self.ref.loc12_36: %I.type = name_ref Self, @I.%Self [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc12_36.1: type = facet_type_access %Self.ref.loc12_36 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc12_36.2: type = converted %Self.ref.loc12_36, %.loc12_36.1 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %self.param: @F.1.%Self (%Self.1) = value_param runtime_param0
-// CHECK:STDOUT:     %self: @F.1.%Self (%Self.1) = bind_name self, %self.param
-// CHECK:STDOUT:     %other.param: @F.1.%Self (%Self.1) = value_param runtime_param1
-// CHECK:STDOUT:     %other: @F.1.%Self (%Self.1) = bind_name other, %other.param
-// CHECK:STDOUT:     %return.param: ref @F.1.%Self (%Self.1) = out_param runtime_param2
-// CHECK:STDOUT:     %return: ref @F.1.%Self (%Self.1) = return_slot %return.param
+// CHECK:STDOUT:     %.loc12_36.1: type = facet_access_type %Self.ref.loc12_36 [symbolic = %.loc12_14.1 (constants.%.1)]
+// CHECK:STDOUT:     %.loc12_36.2: type = converted %Self.ref.loc12_36, %.loc12_36.1 [symbolic = %.loc12_14.1 (constants.%.1)]
+// CHECK:STDOUT:     %self.param: @F.1.%.loc12_14.1 (%.1) = value_param runtime_param0
+// CHECK:STDOUT:     %self: @F.1.%.loc12_14.1 (%.1) = bind_name self, %self.param
+// CHECK:STDOUT:     %other.param: @F.1.%.loc12_14.1 (%.1) = value_param runtime_param1
+// CHECK:STDOUT:     %other: @F.1.%.loc12_14.1 (%.1) = bind_name other, %other.param
+// CHECK:STDOUT:     %return.param: ref @F.1.%.loc12_14.1 (%.1) = out_param runtime_param2
+// CHECK:STDOUT:     %return: ref @F.1.%.loc12_14.1 (%.1) = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc12: %.1 = assoc_entity element0, %F.decl [template = constants.%.2]
+// CHECK:STDOUT:   %.loc12: %.2 = assoc_entity element0, %F.decl [template = constants.%.3]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = %Self
@@ -170,15 +172,15 @@ var arr: [i32; (1 as i32).(I.F)(2)];
 // CHECK:STDOUT:     %return.patt: %i32 = return_slot_pattern
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param2
 // CHECK:STDOUT:   } {
-// CHECK:STDOUT:     %.loc16_14.1: Core.IntLiteral = int_value 32 [template = constants.%.3]
+// CHECK:STDOUT:     %.loc16_14.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
 // CHECK:STDOUT:     %int.make_type_signed.loc16_14: init type = call constants.%Int(%.loc16_14.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_14.2: type = value_of_initializer %int.make_type_signed.loc16_14 [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_14.3: type = converted %int.make_type_signed.loc16_14, %.loc16_14.2 [template = constants.%i32]
-// CHECK:STDOUT:     %.loc16_26.1: Core.IntLiteral = int_value 32 [template = constants.%.3]
+// CHECK:STDOUT:     %.loc16_26.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
 // CHECK:STDOUT:     %int.make_type_signed.loc16_26: init type = call constants.%Int(%.loc16_26.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_26.2: type = value_of_initializer %int.make_type_signed.loc16_26 [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_26.3: type = converted %int.make_type_signed.loc16_26, %.loc16_26.2 [template = constants.%i32]
-// CHECK:STDOUT:     %.loc16_34.1: Core.IntLiteral = int_value 32 [template = constants.%.3]
+// CHECK:STDOUT:     %.loc16_34.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
 // CHECK:STDOUT:     %int.make_type_signed.loc16_34: init type = call constants.%Int(%.loc16_34.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_34.2: type = value_of_initializer %int.make_type_signed.loc16_34 [template = constants.%i32]
 // CHECK:STDOUT:     %.loc16_34.3: type = converted %int.make_type_signed.loc16_34, %.loc16_34.2 [template = constants.%i32]
@@ -189,7 +191,7 @@ var arr: [i32; (1 as i32).(I.F)(2)];
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param2
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc15_15: <witness> = interface_witness (%F.decl) [template = constants.%.4]
+// CHECK:STDOUT:   %.loc15_15: <witness> = interface_witness (%F.decl) [template = constants.%.6]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .F = %F.decl
@@ -198,17 +200,20 @@ var arr: [i32; (1 as i32).(I.F)(2)];
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic fn @F.1(@I.%Self: %I.type) {
 // CHECK:STDOUT:   %Self: %I.type = bind_symbolic_name Self, 0 [symbolic = %Self (constants.%Self.1)]
+// CHECK:STDOUT:   %.loc12_14.1: type = facet_access_type %Self [symbolic = %.loc12_14.1 (constants.%.1)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @F.1.%Self (%Self.1)](%other.param_patt: @F.1.%Self (%Self.1)) -> @F.1.%Self (%Self.1);
+// CHECK:STDOUT:   fn[%self.param_patt: @F.1.%.loc12_14.1 (%.1)](%other.param_patt: @F.1.%.loc12_14.1 (%.1)) -> @F.1.%.loc12_14.1 (%.1);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F.2[%self.param_patt: %i32](%other.param_patt: %i32) -> %i32 = "int.sadd";
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @F.1(constants.%Self.1) {
 // CHECK:STDOUT:   %Self => constants.%Self.1
+// CHECK:STDOUT:   %.loc12_14.1 => constants.%.1
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @F.1(constants.%i32) {
-// CHECK:STDOUT:   %Self => constants.%i32
+// CHECK:STDOUT: specific @F.1(constants.%.5) {
+// CHECK:STDOUT:   %Self => constants.%.5
+// CHECK:STDOUT:   %.loc12_14.1 => constants.%i32
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/function/builtin/no_prelude/call_from_operator.carbon

@@ -58,57 +58,64 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Int: %Int.type = struct_value () [template]
 // CHECK:STDOUT:   %Add.type: type = facet_type <@Add> [template]
 // CHECK:STDOUT:   %Self.1: %Add.type = bind_symbolic_name Self, 0 [symbolic]
+// CHECK:STDOUT:   %.1: type = facet_access_type %Self.1 [symbolic]
 // CHECK:STDOUT:   %Op.type.1: type = fn_type @Op.1 [template]
 // CHECK:STDOUT:   %Op.1: %Op.type.1 = struct_value () [template]
-// CHECK:STDOUT:   %.1: type = assoc_entity_type %Add.type, %Op.type.1 [template]
-// CHECK:STDOUT:   %.2: %.1 = assoc_entity element0, @Add.%Op.decl [template]
+// CHECK:STDOUT:   %.2: type = assoc_entity_type %Add.type, %Op.type.1 [template]
+// CHECK:STDOUT:   %.3: %.2 = assoc_entity element0, @Add.%Op.decl [template]
 // CHECK:STDOUT:   %T: type = bind_symbolic_name T, 0 [symbolic]
 // CHECK:STDOUT:   %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
 // CHECK:STDOUT:   %As.type.1: type = generic_interface_type @As [template]
 // CHECK:STDOUT:   %As: %As.type.1 = struct_value () [template]
 // CHECK:STDOUT:   %As.type.2: type = facet_type <@As, @As(%T)> [symbolic]
 // CHECK:STDOUT:   %Self.2: %As.type.2 = bind_symbolic_name Self, 1 [symbolic]
+// CHECK:STDOUT:   %.4: type = facet_access_type %Self.2 [symbolic]
 // CHECK:STDOUT:   %Convert.type.1: type = fn_type @Convert.1, @As(%T) [symbolic]
 // CHECK:STDOUT:   %Convert.1: %Convert.type.1 = struct_value () [symbolic]
-// CHECK:STDOUT:   %.3: type = assoc_entity_type %As.type.2, %Convert.type.1 [symbolic]
-// CHECK:STDOUT:   %.4: %.3 = assoc_entity element0, @As.%Convert.decl [symbolic]
+// CHECK:STDOUT:   %.5: type = assoc_entity_type %As.type.2, %Convert.type.1 [symbolic]
+// CHECK:STDOUT:   %.6: %.5 = assoc_entity element0, @As.%Convert.decl [symbolic]
 // CHECK:STDOUT:   %ImplicitAs.type.1: type = generic_interface_type @ImplicitAs [template]
 // CHECK:STDOUT:   %ImplicitAs: %ImplicitAs.type.1 = struct_value () [template]
 // CHECK:STDOUT:   %ImplicitAs.type.2: type = facet_type <@ImplicitAs, @ImplicitAs(%T)> [symbolic]
 // CHECK:STDOUT:   %Self.3: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic]
+// CHECK:STDOUT:   %.7: type = facet_access_type %Self.3 [symbolic]
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.2, @ImplicitAs(%T) [symbolic]
 // CHECK:STDOUT:   %Convert.2: %Convert.type.2 = struct_value () [symbolic]
-// CHECK:STDOUT:   %.5: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.2 [symbolic]
-// CHECK:STDOUT:   %.6: %.5 = assoc_entity element0, @ImplicitAs.%Convert.decl [symbolic]
-// CHECK:STDOUT:   %.7: Core.IntLiteral = int_value 32 [template]
-// CHECK:STDOUT:   %i32: type = int_type signed, %.7 [template]
+// CHECK:STDOUT:   %.8: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.2 [symbolic]
+// CHECK:STDOUT:   %.9: %.8 = assoc_entity element0, @ImplicitAs.%Convert.decl [symbolic]
+// CHECK:STDOUT:   %.10: Core.IntLiteral = int_value 32 [template]
+// CHECK:STDOUT:   %i32: type = int_type signed, %.10 [template]
 // CHECK:STDOUT:   %Op.type.2: type = fn_type @Op.2 [template]
 // CHECK:STDOUT:   %Op.2: %Op.type.2 = struct_value () [template]
-// CHECK:STDOUT:   %.8: <witness> = interface_witness (%Op.2) [template]
+// CHECK:STDOUT:   %.11: %Add.type = facet_value %i32, %i32 [template]
+// CHECK:STDOUT:   %.12: <witness> = interface_witness (%Op.2) [template]
 // CHECK:STDOUT:   %As.type.3: type = facet_type <@As, @As(%i32)> [template]
 // CHECK:STDOUT:   %Convert.type.3: type = fn_type @Convert.3 [template]
 // CHECK:STDOUT:   %Convert.3: %Convert.type.3 = struct_value () [template]
 // CHECK:STDOUT:   %Convert.type.4: type = fn_type @Convert.1, @As(%i32) [template]
 // CHECK:STDOUT:   %Convert.4: %Convert.type.4 = struct_value () [template]
-// CHECK:STDOUT:   %.9: type = assoc_entity_type %As.type.3, %Convert.type.4 [template]
-// CHECK:STDOUT:   %.10: %.9 = assoc_entity element0, @As.%Convert.decl [template]
-// CHECK:STDOUT:   %.11: <witness> = interface_witness (%Convert.3) [template]
+// CHECK:STDOUT:   %.13: type = assoc_entity_type %As.type.3, %Convert.type.4 [template]
+// CHECK:STDOUT:   %.14: %.13 = assoc_entity element0, @As.%Convert.decl [template]
+// CHECK:STDOUT:   %.15: %As.type.2 = facet_value Core.IntLiteral, Core.IntLiteral [symbolic]
+// CHECK:STDOUT:   %.16: <witness> = interface_witness (%Convert.3) [template]
 // CHECK:STDOUT:   %ImplicitAs.type.3: type = facet_type <@ImplicitAs, @ImplicitAs(%i32)> [template]
 // CHECK:STDOUT:   %Convert.type.5: type = fn_type @Convert.4 [template]
 // CHECK:STDOUT:   %Convert.5: %Convert.type.5 = struct_value () [template]
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.2, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.6: %Convert.type.6 = struct_value () [template]
-// CHECK:STDOUT:   %.12: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.6 [template]
-// CHECK:STDOUT:   %.13: %.12 = assoc_entity element0, @ImplicitAs.%Convert.decl [template]
-// CHECK:STDOUT:   %.14: <witness> = interface_witness (%Convert.5) [template]
+// CHECK:STDOUT:   %.17: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.6 [template]
+// CHECK:STDOUT:   %.18: %.17 = assoc_entity element0, @ImplicitAs.%Convert.decl [template]
+// CHECK:STDOUT:   %.19: %ImplicitAs.type.2 = facet_value Core.IntLiteral, Core.IntLiteral [symbolic]
+// CHECK:STDOUT:   %.20: <witness> = interface_witness (%Convert.5) [template]
 // CHECK:STDOUT:   %ImplicitAs.type.4: type = facet_type <@ImplicitAs, @ImplicitAs(Core.IntLiteral)> [template]
 // CHECK:STDOUT:   %Convert.type.7: type = fn_type @Convert.5 [template]
 // CHECK:STDOUT:   %Convert.7: %Convert.type.7 = struct_value () [template]
 // CHECK:STDOUT:   %Convert.type.8: type = fn_type @Convert.2, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.8: %Convert.type.8 = struct_value () [template]
-// CHECK:STDOUT:   %.15: type = assoc_entity_type %ImplicitAs.type.4, %Convert.type.8 [template]
-// CHECK:STDOUT:   %.16: %.15 = assoc_entity element0, @ImplicitAs.%Convert.decl [template]
-// CHECK:STDOUT:   %.17: <witness> = interface_witness (%Convert.7) [template]
+// CHECK:STDOUT:   %.21: type = assoc_entity_type %ImplicitAs.type.4, %Convert.type.8 [template]
+// CHECK:STDOUT:   %.22: %.21 = assoc_entity element0, @ImplicitAs.%Convert.decl [template]
+// CHECK:STDOUT:   %.23: %ImplicitAs.type.2 = facet_value %i32, %i32 [symbolic]
+// CHECK:STDOUT:   %.24: <witness> = interface_witness (%Convert.7) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
@@ -157,7 +164,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %T.loc15_22.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc15_22.2 (constants.%T)]
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   impl_decl @impl.1 [template] {} {
-// CHECK:STDOUT:     %.loc19_6.1: Core.IntLiteral = int_value 32 [template = constants.%.7]
+// CHECK:STDOUT:     %.loc19_6.1: Core.IntLiteral = int_value 32 [template = constants.%.10]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc19_6.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc19_6.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc19_6.3: type = converted %int.make_type_signed, %.loc19_6.2 [template = constants.%i32]
@@ -169,7 +176,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %.loc23_17.1: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral]
 // CHECK:STDOUT:     %.loc23_17.2: type = converted %int_literal.make_type, %.loc23_17.1 [template = Core.IntLiteral]
 // CHECK:STDOUT:     %As.ref: %As.type.1 = name_ref As, file.%As.decl [template = constants.%As]
-// CHECK:STDOUT:     %.loc23_25: Core.IntLiteral = int_value 32 [template = constants.%.7]
+// CHECK:STDOUT:     %.loc23_25: Core.IntLiteral = int_value 32 [template = constants.%.10]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc23_25) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc23_24.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc23_24.2: type = converted %int.make_type_signed, %.loc23_24.1 [template = constants.%i32]
@@ -181,14 +188,14 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %.loc27_17.1: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral]
 // CHECK:STDOUT:     %.loc27_17.2: type = converted %int_literal.make_type, %.loc27_17.1 [template = Core.IntLiteral]
 // CHECK:STDOUT:     %ImplicitAs.ref: %ImplicitAs.type.1 = name_ref ImplicitAs, file.%ImplicitAs.decl [template = constants.%ImplicitAs]
-// CHECK:STDOUT:     %.loc27_33: Core.IntLiteral = int_value 32 [template = constants.%.7]
+// CHECK:STDOUT:     %.loc27_33: Core.IntLiteral = int_value 32 [template = constants.%.10]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc27_33) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc27_32.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc27_32.2: type = converted %int.make_type_signed, %.loc27_32.1 [template = constants.%i32]
 // CHECK:STDOUT:     %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(constants.%i32)> [template = constants.%ImplicitAs.type.3]
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   impl_decl @impl.4 [template] {} {
-// CHECK:STDOUT:     %.loc31_6.1: Core.IntLiteral = int_value 32 [template = constants.%.7]
+// CHECK:STDOUT:     %.loc31_6.1: Core.IntLiteral = int_value 32 [template = constants.%.10]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc31_6.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc31_6.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc31_6.3: type = converted %int.make_type_signed, %.loc31_6.2 [template = constants.%i32]
@@ -204,30 +211,30 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT: interface @Add {
 // CHECK:STDOUT:   %Self: %Add.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.1]
 // CHECK:STDOUT:   %Op.decl: %Op.type.1 = fn_decl @Op.1 [template = constants.%Op.1] {
-// CHECK:STDOUT:     %self.patt: @Op.1.%Self (%Self.1) = binding_pattern self
-// CHECK:STDOUT:     %self.param_patt: @Op.1.%Self (%Self.1) = value_param_pattern %self.patt, runtime_param0
-// CHECK:STDOUT:     %other.patt: @Op.1.%Self (%Self.1) = binding_pattern other
-// CHECK:STDOUT:     %other.param_patt: @Op.1.%Self (%Self.1) = value_param_pattern %other.patt, runtime_param1
-// CHECK:STDOUT:     %return.patt: @Op.1.%Self (%Self.1) = return_slot_pattern
-// CHECK:STDOUT:     %return.param_patt: @Op.1.%Self (%Self.1) = out_param_pattern %return.patt, runtime_param2
+// CHECK:STDOUT:     %self.patt: @Op.1.%.loc8_15.1 (%.1) = binding_pattern self
+// CHECK:STDOUT:     %self.param_patt: @Op.1.%.loc8_15.1 (%.1) = value_param_pattern %self.patt, runtime_param0
+// CHECK:STDOUT:     %other.patt: @Op.1.%.loc8_15.1 (%.1) = binding_pattern other
+// CHECK:STDOUT:     %other.param_patt: @Op.1.%.loc8_15.1 (%.1) = value_param_pattern %other.patt, runtime_param1
+// CHECK:STDOUT:     %return.patt: @Op.1.%.loc8_15.1 (%.1) = return_slot_pattern
+// CHECK:STDOUT:     %return.param_patt: @Op.1.%.loc8_15.1 (%.1) = out_param_pattern %return.patt, runtime_param2
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Self.ref.loc8_15: %Add.type = name_ref Self, @Add.%Self [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc8_15.1: type = facet_type_access %Self.ref.loc8_15 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc8_15.2: type = converted %Self.ref.loc8_15, %.loc8_15.1 [symbolic = %Self (constants.%Self.1)]
+// CHECK:STDOUT:     %.loc8_15.2: type = facet_access_type %Self.ref.loc8_15 [symbolic = %.loc8_15.1 (constants.%.1)]
+// CHECK:STDOUT:     %.loc8_15.3: type = converted %Self.ref.loc8_15, %.loc8_15.2 [symbolic = %.loc8_15.1 (constants.%.1)]
 // CHECK:STDOUT:     %Self.ref.loc8_28: %Add.type = name_ref Self, @Add.%Self [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc8_28.1: type = facet_type_access %Self.ref.loc8_28 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc8_28.2: type = converted %Self.ref.loc8_28, %.loc8_28.1 [symbolic = %Self (constants.%Self.1)]
+// CHECK:STDOUT:     %.loc8_28.1: type = facet_access_type %Self.ref.loc8_28 [symbolic = %.loc8_15.1 (constants.%.1)]
+// CHECK:STDOUT:     %.loc8_28.2: type = converted %Self.ref.loc8_28, %.loc8_28.1 [symbolic = %.loc8_15.1 (constants.%.1)]
 // CHECK:STDOUT:     %Self.ref.loc8_37: %Add.type = name_ref Self, @Add.%Self [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc8_37.1: type = facet_type_access %Self.ref.loc8_37 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %.loc8_37.2: type = converted %Self.ref.loc8_37, %.loc8_37.1 [symbolic = %Self (constants.%Self.1)]
-// CHECK:STDOUT:     %self.param: @Op.1.%Self (%Self.1) = value_param runtime_param0
-// CHECK:STDOUT:     %self: @Op.1.%Self (%Self.1) = bind_name self, %self.param
-// CHECK:STDOUT:     %other.param: @Op.1.%Self (%Self.1) = value_param runtime_param1
-// CHECK:STDOUT:     %other: @Op.1.%Self (%Self.1) = bind_name other, %other.param
-// CHECK:STDOUT:     %return.param: ref @Op.1.%Self (%Self.1) = out_param runtime_param2
-// CHECK:STDOUT:     %return: ref @Op.1.%Self (%Self.1) = return_slot %return.param
+// CHECK:STDOUT:     %.loc8_37.1: type = facet_access_type %Self.ref.loc8_37 [symbolic = %.loc8_15.1 (constants.%.1)]
+// CHECK:STDOUT:     %.loc8_37.2: type = converted %Self.ref.loc8_37, %.loc8_37.1 [symbolic = %.loc8_15.1 (constants.%.1)]
+// CHECK:STDOUT:     %self.param: @Op.1.%.loc8_15.1 (%.1) = value_param runtime_param0
+// CHECK:STDOUT:     %self: @Op.1.%.loc8_15.1 (%.1) = bind_name self, %self.param
+// CHECK:STDOUT:     %other.param: @Op.1.%.loc8_15.1 (%.1) = value_param runtime_param1
+// CHECK:STDOUT:     %other: @Op.1.%.loc8_15.1 (%.1) = bind_name other, %other.param
+// CHECK:STDOUT:     %return.param: ref @Op.1.%.loc8_15.1 (%.1) = out_param runtime_param2
+// CHECK:STDOUT:     %return: ref @Op.1.%.loc8_15.1 (%.1) = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc8: %.1 = assoc_entity element0, %Op.decl [template = constants.%.2]
+// CHECK:STDOUT:   %.loc8: %.2 = assoc_entity element0, %Op.decl [template = constants.%.3]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Self = %Self
@@ -244,28 +251,28 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.2: %As.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.2)]
 // CHECK:STDOUT:   %Convert.type: type = fn_type @Convert.1, @As(%T.loc11_14.2) [symbolic = %Convert.type (constants.%Convert.type.1)]
 // CHECK:STDOUT:   %Convert: @As.%Convert.type (%Convert.type.1) = struct_value () [symbolic = %Convert (constants.%Convert.1)]
-// CHECK:STDOUT:   %.loc12_32.2: type = assoc_entity_type @As.%As.type (%As.type.2), @As.%Convert.type (%Convert.type.1) [symbolic = %.loc12_32.2 (constants.%.3)]
-// CHECK:STDOUT:   %.loc12_32.3: @As.%.loc12_32.2 (%.3) = assoc_entity element0, %Convert.decl [symbolic = %.loc12_32.3 (constants.%.4)]
+// CHECK:STDOUT:   %.loc12_32.2: type = assoc_entity_type @As.%As.type (%As.type.2), @As.%Convert.type (%Convert.type.1) [symbolic = %.loc12_32.2 (constants.%.5)]
+// CHECK:STDOUT:   %.loc12_32.3: @As.%.loc12_32.2 (%.5) = assoc_entity element0, %Convert.decl [symbolic = %.loc12_32.3 (constants.%.6)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   interface {
 // CHECK:STDOUT:     %Self.1: @As.%As.type (%As.type.2) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.2)]
 // CHECK:STDOUT:     %Convert.decl: @As.%Convert.type (%Convert.type.1) = fn_decl @Convert.1 [symbolic = @As.%Convert (constants.%Convert.1)] {
-// CHECK:STDOUT:       %self.patt: @Convert.1.%Self (%Self.2) = binding_pattern self
-// CHECK:STDOUT:       %self.param_patt: @Convert.1.%Self (%Self.2) = value_param_pattern %self.patt, runtime_param0
+// CHECK:STDOUT:       %self.patt: @Convert.1.%.loc12_20.1 (%.4) = binding_pattern self
+// CHECK:STDOUT:       %self.param_patt: @Convert.1.%.loc12_20.1 (%.4) = value_param_pattern %self.patt, runtime_param0
 // CHECK:STDOUT:       %return.patt: @Convert.1.%T (%T) = return_slot_pattern
 // CHECK:STDOUT:       %return.param_patt: @Convert.1.%T (%T) = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:     } {
-// CHECK:STDOUT:       %.loc12_20.1: @Convert.1.%As.type (%As.type.2) = specific_constant @As.%Self.1, @As(constants.%T) [symbolic = %Self (constants.%Self.2)]
-// CHECK:STDOUT:       %Self.ref: @Convert.1.%As.type (%As.type.2) = name_ref Self, %.loc12_20.1 [symbolic = %Self (constants.%Self.2)]
-// CHECK:STDOUT:       %.loc12_20.2: type = facet_type_access %Self.ref [symbolic = %Self (constants.%Self.2)]
-// CHECK:STDOUT:       %.loc12_20.3: type = converted %Self.ref, %.loc12_20.2 [symbolic = %Self (constants.%Self.2)]
+// CHECK:STDOUT:       %.loc12_20.2: @Convert.1.%As.type (%As.type.2) = specific_constant @As.%Self.1, @As(constants.%T) [symbolic = %Self (constants.%Self.2)]
+// CHECK:STDOUT:       %Self.ref: @Convert.1.%As.type (%As.type.2) = name_ref Self, %.loc12_20.2 [symbolic = %Self (constants.%Self.2)]
+// CHECK:STDOUT:       %.loc12_20.3: type = facet_access_type %Self.ref [symbolic = %.loc12_20.1 (constants.%.4)]
+// CHECK:STDOUT:       %.loc12_20.4: type = converted %Self.ref, %.loc12_20.3 [symbolic = %.loc12_20.1 (constants.%.4)]
 // CHECK:STDOUT:       %T.ref: type = name_ref T, @As.%T.loc11_14.1 [symbolic = %T (constants.%T)]
-// CHECK:STDOUT:       %self.param: @Convert.1.%Self (%Self.2) = value_param runtime_param0
-// CHECK:STDOUT:       %self: @Convert.1.%Self (%Self.2) = bind_name self, %self.param
+// CHECK:STDOUT:       %self.param: @Convert.1.%.loc12_20.1 (%.4) = value_param runtime_param0
+// CHECK:STDOUT:       %self: @Convert.1.%.loc12_20.1 (%.4) = bind_name self, %self.param
 // CHECK:STDOUT:       %return.param: ref @Convert.1.%T (%T) = out_param runtime_param1
 // CHECK:STDOUT:       %return: ref @Convert.1.%T (%T) = return_slot %return.param
 // CHECK:STDOUT:     }
-// CHECK:STDOUT:     %.loc12_32.1: @As.%.loc12_32.2 (%.3) = assoc_entity element0, %Convert.decl [symbolic = %.loc12_32.3 (constants.%.4)]
+// CHECK:STDOUT:     %.loc12_32.1: @As.%.loc12_32.2 (%.5) = assoc_entity element0, %Convert.decl [symbolic = %.loc12_32.3 (constants.%.6)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   !members:
 // CHECK:STDOUT:     .Self = %Self.1
@@ -283,28 +290,28 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.2: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.3)]
 // CHECK:STDOUT:   %Convert.type: type = fn_type @Convert.2, @ImplicitAs(%T.loc15_22.2) [symbolic = %Convert.type (constants.%Convert.type.2)]
 // CHECK:STDOUT:   %Convert: @ImplicitAs.%Convert.type (%Convert.type.2) = struct_value () [symbolic = %Convert (constants.%Convert.2)]
-// CHECK:STDOUT:   %.loc16_32.2: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2), @ImplicitAs.%Convert.type (%Convert.type.2) [symbolic = %.loc16_32.2 (constants.%.5)]
-// CHECK:STDOUT:   %.loc16_32.3: @ImplicitAs.%.loc16_32.2 (%.5) = assoc_entity element0, %Convert.decl [symbolic = %.loc16_32.3 (constants.%.6)]
+// CHECK:STDOUT:   %.loc16_32.2: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2), @ImplicitAs.%Convert.type (%Convert.type.2) [symbolic = %.loc16_32.2 (constants.%.8)]
+// CHECK:STDOUT:   %.loc16_32.3: @ImplicitAs.%.loc16_32.2 (%.8) = assoc_entity element0, %Convert.decl [symbolic = %.loc16_32.3 (constants.%.9)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   interface {
 // CHECK:STDOUT:     %Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.3)]
 // CHECK:STDOUT:     %Convert.decl: @ImplicitAs.%Convert.type (%Convert.type.2) = fn_decl @Convert.2 [symbolic = @ImplicitAs.%Convert (constants.%Convert.2)] {
-// CHECK:STDOUT:       %self.patt: @Convert.2.%Self (%Self.3) = binding_pattern self
-// CHECK:STDOUT:       %self.param_patt: @Convert.2.%Self (%Self.3) = value_param_pattern %self.patt, runtime_param0
+// CHECK:STDOUT:       %self.patt: @Convert.2.%.loc16_20.1 (%.7) = binding_pattern self
+// CHECK:STDOUT:       %self.param_patt: @Convert.2.%.loc16_20.1 (%.7) = value_param_pattern %self.patt, runtime_param0
 // CHECK:STDOUT:       %return.patt: @Convert.2.%T (%T) = return_slot_pattern
 // CHECK:STDOUT:       %return.param_patt: @Convert.2.%T (%T) = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:     } {
-// CHECK:STDOUT:       %.loc16_20.1: @Convert.2.%ImplicitAs.type (%ImplicitAs.type.2) = specific_constant @ImplicitAs.%Self.1, @ImplicitAs(constants.%T) [symbolic = %Self (constants.%Self.3)]
-// CHECK:STDOUT:       %Self.ref: @Convert.2.%ImplicitAs.type (%ImplicitAs.type.2) = name_ref Self, %.loc16_20.1 [symbolic = %Self (constants.%Self.3)]
-// CHECK:STDOUT:       %.loc16_20.2: type = facet_type_access %Self.ref [symbolic = %Self (constants.%Self.3)]
-// CHECK:STDOUT:       %.loc16_20.3: type = converted %Self.ref, %.loc16_20.2 [symbolic = %Self (constants.%Self.3)]
+// CHECK:STDOUT:       %.loc16_20.2: @Convert.2.%ImplicitAs.type (%ImplicitAs.type.2) = specific_constant @ImplicitAs.%Self.1, @ImplicitAs(constants.%T) [symbolic = %Self (constants.%Self.3)]
+// CHECK:STDOUT:       %Self.ref: @Convert.2.%ImplicitAs.type (%ImplicitAs.type.2) = name_ref Self, %.loc16_20.2 [symbolic = %Self (constants.%Self.3)]
+// CHECK:STDOUT:       %.loc16_20.3: type = facet_access_type %Self.ref [symbolic = %.loc16_20.1 (constants.%.7)]
+// CHECK:STDOUT:       %.loc16_20.4: type = converted %Self.ref, %.loc16_20.3 [symbolic = %.loc16_20.1 (constants.%.7)]
 // CHECK:STDOUT:       %T.ref: type = name_ref T, @ImplicitAs.%T.loc15_22.1 [symbolic = %T (constants.%T)]
-// CHECK:STDOUT:       %self.param: @Convert.2.%Self (%Self.3) = value_param runtime_param0
-// CHECK:STDOUT:       %self: @Convert.2.%Self (%Self.3) = bind_name self, %self.param
+// CHECK:STDOUT:       %self.param: @Convert.2.%.loc16_20.1 (%.7) = value_param runtime_param0
+// CHECK:STDOUT:       %self: @Convert.2.%.loc16_20.1 (%.7) = bind_name self, %self.param
 // CHECK:STDOUT:       %return.param: ref @Convert.2.%T (%T) = out_param runtime_param1
 // CHECK:STDOUT:       %return: ref @Convert.2.%T (%T) = return_slot %return.param
 // CHECK:STDOUT:     }
-// CHECK:STDOUT:     %.loc16_32.1: @ImplicitAs.%.loc16_32.2 (%.5) = assoc_entity element0, %Convert.decl [symbolic = %.loc16_32.3 (constants.%.6)]
+// CHECK:STDOUT:     %.loc16_32.1: @ImplicitAs.%.loc16_32.2 (%.8) = assoc_entity element0, %Convert.decl [symbolic = %.loc16_32.3 (constants.%.9)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   !members:
 // CHECK:STDOUT:     .Self = %Self.1
@@ -332,7 +339,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param2
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc19_17: <witness> = interface_witness (%Op.decl) [template = constants.%.8]
+// CHECK:STDOUT:   %.loc19_17: <witness> = interface_witness (%Op.decl) [template = constants.%.12]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Op = %Op.decl
@@ -347,7 +354,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Self.ref: type = name_ref Self, @impl.2.%.loc23_17.2 [template = Core.IntLiteral]
-// CHECK:STDOUT:     %.loc24_31.1: Core.IntLiteral = int_value 32 [template = constants.%.7]
+// CHECK:STDOUT:     %.loc24_31.1: Core.IntLiteral = int_value 32 [template = constants.%.10]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc24_31.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc24_31.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc24_31.3: type = converted %int.make_type_signed, %.loc24_31.2 [template = constants.%i32]
@@ -356,7 +363,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc23_30: <witness> = interface_witness (%Convert.decl) [template = constants.%.11]
+// CHECK:STDOUT:   %.loc23_30: <witness> = interface_witness (%Convert.decl) [template = constants.%.16]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Convert = %Convert.decl
@@ -371,7 +378,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1
 // CHECK:STDOUT:   } {
 // CHECK:STDOUT:     %Self.ref: type = name_ref Self, @impl.3.%.loc27_17.2 [template = Core.IntLiteral]
-// CHECK:STDOUT:     %.loc28_31.1: Core.IntLiteral = int_value 32 [template = constants.%.7]
+// CHECK:STDOUT:     %.loc28_31.1: Core.IntLiteral = int_value 32 [template = constants.%.10]
 // CHECK:STDOUT:     %int.make_type_signed: init type = call constants.%Int(%.loc28_31.1) [template = constants.%i32]
 // CHECK:STDOUT:     %.loc28_31.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
 // CHECK:STDOUT:     %.loc28_31.3: type = converted %int.make_type_signed, %.loc28_31.2 [template = constants.%i32]
@@ -380,7 +387,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %return.param: ref %i32 = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref %i32 = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc27_38: <witness> = interface_witness (%Convert.decl) [template = constants.%.14]
+// CHECK:STDOUT:   %.loc27_38: <witness> = interface_witness (%Convert.decl) [template = constants.%.20]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Convert = %Convert.decl
@@ -404,7 +411,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     %return.param: ref Core.IntLiteral = out_param runtime_param1
 // CHECK:STDOUT:     %return: ref Core.IntLiteral = return_slot %return.param
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %.loc31_38: <witness> = interface_witness (%Convert.decl) [template = constants.%.17]
+// CHECK:STDOUT:   %.loc31_38: <witness> = interface_witness (%Convert.decl) [template = constants.%.24]
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .Convert = %Convert.decl
@@ -417,24 +424,27 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic fn @Op.1(@Add.%Self: %Add.type) {
 // CHECK:STDOUT:   %Self: %Add.type = bind_symbolic_name Self, 0 [symbolic = %Self (constants.%Self.1)]
+// CHECK:STDOUT:   %.loc8_15.1: type = facet_access_type %Self [symbolic = %.loc8_15.1 (constants.%.1)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @Op.1.%Self (%Self.1)](%other.param_patt: @Op.1.%Self (%Self.1)) -> @Op.1.%Self (%Self.1);
+// CHECK:STDOUT:   fn[%self.param_patt: @Op.1.%.loc8_15.1 (%.1)](%other.param_patt: @Op.1.%.loc8_15.1 (%.1)) -> @Op.1.%.loc8_15.1 (%.1);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic fn @Convert.1(@As.%T.loc11_14.1: type, @As.%Self.1: @As.%As.type (%As.type.2)) {
 // CHECK:STDOUT:   %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)]
 // CHECK:STDOUT:   %As.type: type = facet_type <@As, @As(%T)> [symbolic = %As.type (constants.%As.type.2)]
 // CHECK:STDOUT:   %Self: %As.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
+// CHECK:STDOUT:   %.loc12_20.1: type = facet_access_type %Self [symbolic = %.loc12_20.1 (constants.%.4)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @Convert.1.%Self (%Self.2)]() -> @Convert.1.%T (%T);
+// CHECK:STDOUT:   fn[%self.param_patt: @Convert.1.%.loc12_20.1 (%.4)]() -> @Convert.1.%T (%T);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic fn @Convert.2(@ImplicitAs.%T.loc15_22.1: type, @ImplicitAs.%Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2)) {
 // CHECK:STDOUT:   %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)]
 // CHECK:STDOUT:   %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%T)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
 // CHECK:STDOUT:   %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.3)]
+// CHECK:STDOUT:   %.loc16_20.1: type = facet_access_type %Self [symbolic = %.loc16_20.1 (constants.%.7)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @Convert.2.%Self (%Self.3)]() -> @Convert.2.%T (%T);
+// CHECK:STDOUT:   fn[%self.param_patt: @Convert.2.%.loc16_20.1 (%.7)]() -> @Convert.2.%T (%T);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Op.2[%self.param_patt: %i32](%other.param_patt: %i32) -> %i32 = "int.sadd";
@@ -447,6 +457,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @Op.1(constants.%Self.1) {
 // CHECK:STDOUT:   %Self => constants.%Self.1
+// CHECK:STDOUT:   %.loc8_15.1 => constants.%.1
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @As(constants.%T) {
@@ -463,6 +474,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %T => constants.%T
 // CHECK:STDOUT:   %As.type => constants.%As.type.2
 // CHECK:STDOUT:   %Self => constants.%Self.2
+// CHECK:STDOUT:   %.loc12_20.1 => constants.%.4
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @As(%T.loc11_14.2) {
@@ -484,6 +496,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %T => constants.%T
 // CHECK:STDOUT:   %ImplicitAs.type => constants.%ImplicitAs.type.2
 // CHECK:STDOUT:   %Self => constants.%Self.3
+// CHECK:STDOUT:   %.loc16_20.1 => constants.%.7
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @ImplicitAs(%T.loc15_22.2) {
@@ -491,8 +504,9 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %T.patt.loc15_22.2 => constants.%T
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @Op.1(constants.%i32) {
-// CHECK:STDOUT:   %Self => constants.%i32
+// CHECK:STDOUT: specific @Op.1(constants.%.11) {
+// CHECK:STDOUT:   %Self => constants.%.11
+// CHECK:STDOUT:   %.loc8_15.1 => constants.%i32
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @As(constants.%i32) {
@@ -504,14 +518,15 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.2 => constants.%Self.2
 // CHECK:STDOUT:   %Convert.type => constants.%Convert.type.4
 // CHECK:STDOUT:   %Convert => constants.%Convert.4
-// CHECK:STDOUT:   %.loc12_32.2 => constants.%.9
-// CHECK:STDOUT:   %.loc12_32.3 => constants.%.10
+// CHECK:STDOUT:   %.loc12_32.2 => constants.%.13
+// CHECK:STDOUT:   %.loc12_32.3 => constants.%.14
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @Convert.1(constants.%i32, Core.IntLiteral) {
+// CHECK:STDOUT: specific @Convert.1(constants.%i32, constants.%.15) {
 // CHECK:STDOUT:   %T => constants.%i32
 // CHECK:STDOUT:   %As.type => constants.%As.type.3
-// CHECK:STDOUT:   %Self => Core.IntLiteral
+// CHECK:STDOUT:   %Self => constants.%.15
+// CHECK:STDOUT:   %.loc12_20.1 => Core.IntLiteral
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @ImplicitAs(constants.%i32) {
@@ -523,14 +538,15 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.2 => constants.%Self.3
 // CHECK:STDOUT:   %Convert.type => constants.%Convert.type.6
 // CHECK:STDOUT:   %Convert => constants.%Convert.6
-// CHECK:STDOUT:   %.loc16_32.2 => constants.%.12
-// CHECK:STDOUT:   %.loc16_32.3 => constants.%.13
+// CHECK:STDOUT:   %.loc16_32.2 => constants.%.17
+// CHECK:STDOUT:   %.loc16_32.3 => constants.%.18
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @Convert.2(constants.%i32, Core.IntLiteral) {
+// CHECK:STDOUT: specific @Convert.2(constants.%i32, constants.%.19) {
 // CHECK:STDOUT:   %T => constants.%i32
 // CHECK:STDOUT:   %ImplicitAs.type => constants.%ImplicitAs.type.3
-// CHECK:STDOUT:   %Self => Core.IntLiteral
+// CHECK:STDOUT:   %Self => constants.%.19
+// CHECK:STDOUT:   %.loc16_20.1 => Core.IntLiteral
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @ImplicitAs(Core.IntLiteral) {
@@ -542,14 +558,15 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.2 => constants.%Self.3
 // CHECK:STDOUT:   %Convert.type => constants.%Convert.type.8
 // CHECK:STDOUT:   %Convert => constants.%Convert.8
-// CHECK:STDOUT:   %.loc16_32.2 => constants.%.15
-// CHECK:STDOUT:   %.loc16_32.3 => constants.%.16
+// CHECK:STDOUT:   %.loc16_32.2 => constants.%.21
+// CHECK:STDOUT:   %.loc16_32.3 => constants.%.22
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: specific @Convert.2(Core.IntLiteral, constants.%i32) {
+// CHECK:STDOUT: specific @Convert.2(Core.IntLiteral, constants.%.23) {
 // CHECK:STDOUT:   %T => Core.IntLiteral
 // CHECK:STDOUT:   %ImplicitAs.type => constants.%ImplicitAs.type.4
-// CHECK:STDOUT:   %Self => constants.%i32
+// CHECK:STDOUT:   %Self => constants.%.23
+// CHECK:STDOUT:   %.loc16_20.1 => constants.%i32
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- user.carbon
@@ -567,14 +584,16 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.2: %As.type.2 = bind_symbolic_name Self, 1 [symbolic]
 // CHECK:STDOUT:   %Convert.type.1: type = fn_type @Convert.1, @As(%T) [symbolic]
 // CHECK:STDOUT:   %Convert.1: %Convert.type.1 = struct_value () [symbolic]
-// CHECK:STDOUT:   %.3: type = assoc_entity_type %As.type.2, %Convert.type.1 [symbolic]
-// CHECK:STDOUT:   %.4: %.3 = assoc_entity element0, imports.%import_ref.6 [symbolic]
+// CHECK:STDOUT:   %.3: type = facet_access_type %Self.2 [symbolic]
+// CHECK:STDOUT:   %.4: type = assoc_entity_type %As.type.2, %Convert.type.1 [symbolic]
+// CHECK:STDOUT:   %.5: %.4 = assoc_entity element0, imports.%import_ref.6 [symbolic]
+// CHECK:STDOUT:   %.6: type = facet_access_type %Self.1 [symbolic]
 // CHECK:STDOUT:   %As.type.3: type = facet_type <@As, @As(%i32)> [template]
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
 // CHECK:STDOUT:   %Convert.2: %Convert.type.2 = struct_value () [template]
-// CHECK:STDOUT:   %.5: type = assoc_entity_type %As.type.3, %Convert.type.2 [template]
-// CHECK:STDOUT:   %.6: %.5 = assoc_entity element0, imports.%import_ref.6 [template]
-// CHECK:STDOUT:   %.7: %.3 = assoc_entity element0, imports.%import_ref.7 [symbolic]
+// CHECK:STDOUT:   %.7: type = assoc_entity_type %As.type.3, %Convert.type.2 [template]
+// CHECK:STDOUT:   %.8: %.7 = assoc_entity element0, imports.%import_ref.6 [template]
+// CHECK:STDOUT:   %.9: %.4 = assoc_entity element0, imports.%import_ref.7 [symbolic]
 // CHECK:STDOUT:   %Add.type: type = facet_type <@Add> [template]
 // CHECK:STDOUT:   %Self.3: %Add.type = bind_symbolic_name Self, 0 [symbolic]
 // CHECK:STDOUT:   %ImplicitAs.type.2: type = facet_type <@ImplicitAs, @ImplicitAs(%T)> [symbolic]
@@ -583,54 +602,57 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self.5: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic]
 // CHECK:STDOUT:   %Convert.type.3: type = fn_type @Convert.2, @ImplicitAs(%T) [symbolic]
 // CHECK:STDOUT:   %Convert.3: %Convert.type.3 = struct_value () [symbolic]
-// CHECK:STDOUT:   %.8: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.3 [symbolic]
-// CHECK:STDOUT:   %.9: %.8 = assoc_entity element0, imports.%import_ref.23 [symbolic]
+// CHECK:STDOUT:   %.10: type = facet_access_type %Self.5 [symbolic]
+// CHECK:STDOUT:   %.11: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.3 [symbolic]
+// CHECK:STDOUT:   %.12: %.11 = assoc_entity element0, imports.%import_ref.23 [symbolic]
+// CHECK:STDOUT:   %.13: type = facet_access_type %Self.4 [symbolic]
 // CHECK:STDOUT:   %Convert.type.4: type = fn_type @Convert.2, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.4: %Convert.type.4 = struct_value () [template]
-// CHECK:STDOUT:   %.10: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.4 [template]
-// CHECK:STDOUT:   %.11: %.10 = assoc_entity element0, imports.%import_ref.24 [template]
+// CHECK:STDOUT:   %.14: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.4 [template]
+// CHECK:STDOUT:   %.15: %.14 = assoc_entity element0, imports.%import_ref.24 [template]
 // CHECK:STDOUT:   %ImplicitAs.type.4: type = facet_type <@ImplicitAs, @ImplicitAs(Core.IntLiteral)> [template]
 // CHECK:STDOUT:   %Convert.type.5: type = fn_type @Convert.2, @ImplicitAs(Core.IntLiteral) [template]
 // CHECK:STDOUT:   %Convert.5: %Convert.type.5 = struct_value () [template]
-// CHECK:STDOUT:   %.12: type = assoc_entity_type %ImplicitAs.type.4, %Convert.type.5 [template]
-// CHECK:STDOUT:   %.13: %.12 = assoc_entity element0, imports.%import_ref.28 [template]
+// CHECK:STDOUT:   %.16: type = assoc_entity_type %ImplicitAs.type.4, %Convert.type.5 [template]
+// CHECK:STDOUT:   %.17: %.16 = assoc_entity element0, imports.%import_ref.28 [template]
 // CHECK:STDOUT:   %Convert.type.6: type = fn_type @Convert.3 [template]
 // CHECK:STDOUT:   %Convert.6: %Convert.type.6 = struct_value () [template]
-// CHECK:STDOUT:   %.14: <witness> = interface_witness (%Convert.6) [template]
-// CHECK:STDOUT:   %.15: <bound method> = bound_method %.2, %Convert.6 [template]
-// CHECK:STDOUT:   %.16: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.17: Core.IntLiteral = int_value 2 [template]
-// CHECK:STDOUT:   %.18: <bound method> = bound_method %.17, %Convert.6 [template]
-// CHECK:STDOUT:   %.19: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.18: <witness> = interface_witness (%Convert.6) [template]
+// CHECK:STDOUT:   %.19: <bound method> = bound_method %.2, %Convert.6 [template]
+// CHECK:STDOUT:   %.20: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.21: Core.IntLiteral = int_value 2 [template]
+// CHECK:STDOUT:   %.22: <bound method> = bound_method %.21, %Convert.6 [template]
+// CHECK:STDOUT:   %.23: %i32 = int_value 2 [template]
 // CHECK:STDOUT:   %Op.type.1: type = fn_type @Op.1 [template]
-// CHECK:STDOUT:   %.20: type = assoc_entity_type %Add.type, %Op.type.1 [template]
-// CHECK:STDOUT:   %.21: %.20 = assoc_entity element0, imports.%import_ref.30 [template]
+// CHECK:STDOUT:   %.24: type = facet_access_type %Self.3 [symbolic]
+// CHECK:STDOUT:   %.25: type = assoc_entity_type %Add.type, %Op.type.1 [template]
+// CHECK:STDOUT:   %.26: %.25 = assoc_entity element0, imports.%import_ref.30 [template]
 // CHECK:STDOUT:   %Op.type.2: type = fn_type @Op.2 [template]
 // CHECK:STDOUT:   %Op.2: %Op.type.2 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Op.2) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.16, %Op.2 [template]
-// CHECK:STDOUT:   %.24: %i32 = int_value 3 [template]
-// CHECK:STDOUT:   %.25: %.8 = assoc_entity element0, imports.%import_ref.32 [symbolic]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Op.2) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.20, %Op.2 [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 3 [template]
+// CHECK:STDOUT:   %.30: %.11 = assoc_entity element0, imports.%import_ref.32 [symbolic]
 // CHECK:STDOUT:   %Convert.type.7: type = fn_type @Convert.4 [template]
 // CHECK:STDOUT:   %Convert.7: %Convert.type.7 = struct_value () [template]
-// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.7) [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.24, %Convert.7 [template]
-// CHECK:STDOUT:   %.28: Core.IntLiteral = int_value 3 [template]
-// CHECK:STDOUT:   %.29: type = array_type %.28, %i32 [template]
-// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 4 [template]
-// CHECK:STDOUT:   %.32: <bound method> = bound_method %.28, %Convert.6 [template]
-// CHECK:STDOUT:   %.33: <bound method> = bound_method %.31, %Convert.6 [template]
-// CHECK:STDOUT:   %.34: %i32 = int_value 4 [template]
-// CHECK:STDOUT:   %.35: <bound method> = bound_method %.24, %Op.2 [template]
-// CHECK:STDOUT:   %.36: %i32 = int_value 7 [template]
+// CHECK:STDOUT:   %.31: <witness> = interface_witness (%Convert.7) [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.29, %Convert.7 [template]
+// CHECK:STDOUT:   %.33: Core.IntLiteral = int_value 3 [template]
+// CHECK:STDOUT:   %.34: type = array_type %.33, %i32 [template]
+// CHECK:STDOUT:   %.36: Core.IntLiteral = int_value 4 [template]
+// CHECK:STDOUT:   %.37: <bound method> = bound_method %.33, %Convert.6 [template]
+// CHECK:STDOUT:   %.38: <bound method> = bound_method %.36, %Convert.6 [template]
+// CHECK:STDOUT:   %.39: %i32 = int_value 4 [template]
+// CHECK:STDOUT:   %.40: <bound method> = bound_method %.29, %Op.2 [template]
+// CHECK:STDOUT:   %.41: %i32 = int_value 7 [template]
 // CHECK:STDOUT:   %tuple.type: type = tuple_type (Core.IntLiteral, Core.IntLiteral, %i32) [template]
-// CHECK:STDOUT:   %.37: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.42: Core.IntLiteral = int_value 0 [template]
 // CHECK:STDOUT:   %Convert.type.8: type = fn_type @Convert.5 [template]
 // CHECK:STDOUT:   %Convert.8: %Convert.type.8 = struct_value () [template]
-// CHECK:STDOUT:   %.38: <witness> = interface_witness (%Convert.8) [template]
-// CHECK:STDOUT:   %.39: <bound method> = bound_method %.28, %Convert.8 [template]
-// CHECK:STDOUT:   %.40: <bound method> = bound_method %.31, %Convert.8 [template]
-// CHECK:STDOUT:   %array: %.29 = tuple_value (%.24, %.34, %.36) [template]
+// CHECK:STDOUT:   %.43: <witness> = interface_witness (%Convert.8) [template]
+// CHECK:STDOUT:   %.44: <bound method> = bound_method %.33, %Convert.8 [template]
+// CHECK:STDOUT:   %.45: <bound method> = bound_method %.36, %Convert.8 [template]
+// CHECK:STDOUT:   %array: %.34 = tuple_value (%.29, %.39, %.41) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -641,29 +663,29 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:     .ImplicitAs = %import_ref.31
 // CHECK:STDOUT:     import Core//default
 // CHECK:STDOUT:   }
-// CHECK:STDOUT:   %import_ref.3 = import_ref Core//default, inst+68, unloaded
-// CHECK:STDOUT:   %import_ref.4: @As.%.1 (%.3) = import_ref Core//default, inst+90, loaded [symbolic = @As.%.2 (constants.%.7)]
-// CHECK:STDOUT:   %import_ref.5 = import_ref Core//default, inst+83, unloaded
-// CHECK:STDOUT:   %import_ref.6 = import_ref Core//default, inst+83, unloaded
+// CHECK:STDOUT:   %import_ref.3 = import_ref Core//default, inst+70, unloaded
+// CHECK:STDOUT:   %import_ref.4: @As.%.1 (%.4) = import_ref Core//default, inst+94, loaded [symbolic = @As.%.2 (constants.%.9)]
+// CHECK:STDOUT:   %import_ref.5 = import_ref Core//default, inst+86, unloaded
+// CHECK:STDOUT:   %import_ref.6 = import_ref Core//default, inst+86, unloaded
 // CHECK:STDOUT:   %import_ref.8 = import_ref Core//default, inst+26, unloaded
-// CHECK:STDOUT:   %import_ref.9: %.20 = import_ref Core//default, inst+54, loaded [template = constants.%.21]
-// CHECK:STDOUT:   %import_ref.10 = import_ref Core//default, inst+49, unloaded
-// CHECK:STDOUT:   %import_ref.11: type = import_ref Core//default, inst+143, loaded [template = constants.%i32]
-// CHECK:STDOUT:   %import_ref.12: type = import_ref Core//default, inst+144, loaded [template = constants.%Add.type]
-// CHECK:STDOUT:   %import_ref.13: <witness> = import_ref Core//default, inst+164, loaded [template = constants.%.22]
-// CHECK:STDOUT:   %import_ref.14: type = import_ref Core//default, inst+169, loaded [template = Core.IntLiteral]
-// CHECK:STDOUT:   %import_ref.15: type = import_ref Core//default, inst+175, loaded [template = constants.%As.type.3]
-// CHECK:STDOUT:   %import_ref.16: <witness> = import_ref Core//default, inst+198, loaded [template = constants.%.14]
-// CHECK:STDOUT:   %import_ref.17 = import_ref Core//default, inst+108, unloaded
-// CHECK:STDOUT:   %import_ref.18: @ImplicitAs.%.1 (%.8) = import_ref Core//default, inst+130, loaded [symbolic = @ImplicitAs.%.2 (constants.%.25)]
-// CHECK:STDOUT:   %import_ref.19 = import_ref Core//default, inst+123, unloaded
-// CHECK:STDOUT:   %import_ref.20: type = import_ref Core//default, inst+203, loaded [template = Core.IntLiteral]
-// CHECK:STDOUT:   %import_ref.21: type = import_ref Core//default, inst+209, loaded [template = constants.%ImplicitAs.type.3]
-// CHECK:STDOUT:   %import_ref.22: <witness> = import_ref Core//default, inst+232, loaded [template = constants.%.38]
-// CHECK:STDOUT:   %import_ref.23 = import_ref Core//default, inst+123, unloaded
-// CHECK:STDOUT:   %import_ref.25: type = import_ref Core//default, inst+237, loaded [template = constants.%i32]
-// CHECK:STDOUT:   %import_ref.26: type = import_ref Core//default, inst+243, loaded [template = constants.%ImplicitAs.type.4]
-// CHECK:STDOUT:   %import_ref.27: <witness> = import_ref Core//default, inst+266, loaded [template = constants.%.26]
+// CHECK:STDOUT:   %import_ref.9: %.25 = import_ref Core//default, inst+56, loaded [template = constants.%.26]
+// CHECK:STDOUT:   %import_ref.10 = import_ref Core//default, inst+50, unloaded
+// CHECK:STDOUT:   %import_ref.11: type = import_ref Core//default, inst+149, loaded [template = constants.%i32]
+// CHECK:STDOUT:   %import_ref.12: type = import_ref Core//default, inst+150, loaded [template = constants.%Add.type]
+// CHECK:STDOUT:   %import_ref.13: <witness> = import_ref Core//default, inst+171, loaded [template = constants.%.27]
+// CHECK:STDOUT:   %import_ref.14: type = import_ref Core//default, inst+176, loaded [template = Core.IntLiteral]
+// CHECK:STDOUT:   %import_ref.15: type = import_ref Core//default, inst+182, loaded [template = constants.%As.type.3]
+// CHECK:STDOUT:   %import_ref.16: <witness> = import_ref Core//default, inst+206, loaded [template = constants.%.18]
+// CHECK:STDOUT:   %import_ref.17 = import_ref Core//default, inst+112, unloaded
+// CHECK:STDOUT:   %import_ref.18: @ImplicitAs.%.1 (%.11) = import_ref Core//default, inst+136, loaded [symbolic = @ImplicitAs.%.2 (constants.%.30)]
+// CHECK:STDOUT:   %import_ref.19 = import_ref Core//default, inst+128, unloaded
+// CHECK:STDOUT:   %import_ref.20: type = import_ref Core//default, inst+211, loaded [template = Core.IntLiteral]
+// CHECK:STDOUT:   %import_ref.21: type = import_ref Core//default, inst+217, loaded [template = constants.%ImplicitAs.type.3]
+// CHECK:STDOUT:   %import_ref.22: <witness> = import_ref Core//default, inst+241, loaded [template = constants.%.43]
+// CHECK:STDOUT:   %import_ref.23 = import_ref Core//default, inst+128, unloaded
+// CHECK:STDOUT:   %import_ref.25: type = import_ref Core//default, inst+246, loaded [template = constants.%i32]
+// CHECK:STDOUT:   %import_ref.26: type = import_ref Core//default, inst+252, loaded [template = constants.%ImplicitAs.type.4]
+// CHECK:STDOUT:   %import_ref.27: <witness> = import_ref Core//default, inst+276, loaded [template = constants.%.31]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: file {
@@ -679,36 +701,36 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %int.make_type_signed.loc4_22: init type = call constants.%Int(%.loc4_22.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_22.2: type = value_of_initializer %int.make_type_signed.loc4_22 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_22.3: type = converted %int.make_type_signed.loc4_22, %.loc4_22.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.2 = interface_witness_access constants.%.14, element0 [template = constants.%Convert.6]
-// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %.loc4_17, %.loc4_19.1 [template = constants.%.15]
-// CHECK:STDOUT:   %int.convert_checked.loc4_19: init %i32 = call %.loc4_19.2(%.loc4_17) [template = constants.%.16]
-// CHECK:STDOUT:   %.loc4_19.3: %i32 = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.16]
-// CHECK:STDOUT:   %.loc4_19.4: %i32 = converted %.loc4_17, %.loc4_19.3 [template = constants.%.16]
-// CHECK:STDOUT:   %.loc4_30: Core.IntLiteral = int_value 2 [template = constants.%.17]
+// CHECK:STDOUT:   %.loc4_19.1: %Convert.type.2 = interface_witness_access constants.%.18, element0 [template = constants.%Convert.6]
+// CHECK:STDOUT:   %.loc4_19.2: <bound method> = bound_method %.loc4_17, %.loc4_19.1 [template = constants.%.19]
+// CHECK:STDOUT:   %int.convert_checked.loc4_19: init %i32 = call %.loc4_19.2(%.loc4_17) [template = constants.%.20]
+// CHECK:STDOUT:   %.loc4_19.3: %i32 = value_of_initializer %int.convert_checked.loc4_19 [template = constants.%.20]
+// CHECK:STDOUT:   %.loc4_19.4: %i32 = converted %.loc4_17, %.loc4_19.3 [template = constants.%.20]
+// CHECK:STDOUT:   %.loc4_30: Core.IntLiteral = int_value 2 [template = constants.%.21]
 // CHECK:STDOUT:   %.loc4_35.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc4_35: init type = call constants.%Int(%.loc4_35.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_35.2: type = value_of_initializer %int.make_type_signed.loc4_35 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_35.3: type = converted %int.make_type_signed.loc4_35, %.loc4_35.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_32.1: %Convert.type.2 = interface_witness_access constants.%.14, element0 [template = constants.%Convert.6]
-// CHECK:STDOUT:   %.loc4_32.2: <bound method> = bound_method %.loc4_30, %.loc4_32.1 [template = constants.%.18]
-// CHECK:STDOUT:   %int.convert_checked.loc4_32: init %i32 = call %.loc4_32.2(%.loc4_30) [template = constants.%.19]
-// CHECK:STDOUT:   %.loc4_32.3: %i32 = value_of_initializer %int.convert_checked.loc4_32 [template = constants.%.19]
-// CHECK:STDOUT:   %.loc4_32.4: %i32 = converted %.loc4_30, %.loc4_32.3 [template = constants.%.19]
-// CHECK:STDOUT:   %.loc4_27.1: %Op.type.1 = interface_witness_access constants.%.22, element0 [template = constants.%Op.2]
-// CHECK:STDOUT:   %.loc4_27.2: <bound method> = bound_method %.loc4_19.4, %.loc4_27.1 [template = constants.%.23]
-// CHECK:STDOUT:   %int.sadd: init %i32 = call %.loc4_27.2(%.loc4_19.4, %.loc4_32.4) [template = constants.%.24]
+// CHECK:STDOUT:   %.loc4_32.1: %Convert.type.2 = interface_witness_access constants.%.18, element0 [template = constants.%Convert.6]
+// CHECK:STDOUT:   %.loc4_32.2: <bound method> = bound_method %.loc4_30, %.loc4_32.1 [template = constants.%.22]
+// CHECK:STDOUT:   %int.convert_checked.loc4_32: init %i32 = call %.loc4_32.2(%.loc4_30) [template = constants.%.23]
+// CHECK:STDOUT:   %.loc4_32.3: %i32 = value_of_initializer %int.convert_checked.loc4_32 [template = constants.%.23]
+// CHECK:STDOUT:   %.loc4_32.4: %i32 = converted %.loc4_30, %.loc4_32.3 [template = constants.%.23]
+// CHECK:STDOUT:   %.loc4_27.1: %Op.type.1 = interface_witness_access constants.%.27, element0 [template = constants.%Op.2]
+// CHECK:STDOUT:   %.loc4_27.2: <bound method> = bound_method %.loc4_19.4, %.loc4_27.1 [template = constants.%.28]
+// CHECK:STDOUT:   %int.sadd: init %i32 = call %.loc4_27.2(%.loc4_19.4, %.loc4_32.4) [template = constants.%.29]
 // CHECK:STDOUT:   %.loc4_11.2: type = value_of_initializer %int.make_type_signed.loc4_11 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_11.3: type = converted %int.make_type_signed.loc4_11, %.loc4_11.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_27.3: %Convert.type.5 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.7]
-// CHECK:STDOUT:   %.loc4_27.4: <bound method> = bound_method %int.sadd, %.loc4_27.3 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc4_27.5: %i32 = value_of_initializer %int.sadd [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_27.6: %i32 = converted %int.sadd, %.loc4_27.5 [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc4_27: init Core.IntLiteral = call %.loc4_27.4(%.loc4_27.6) [template = constants.%.28]
-// CHECK:STDOUT:   %.loc4_27.7: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_27 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc4_27.8: Core.IntLiteral = converted %int.sadd, %.loc4_27.7 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc4_39: type = array_type %.loc4_27.8, %i32 [template = constants.%.29]
-// CHECK:STDOUT:   %arr.var: ref %.29 = var arr
-// CHECK:STDOUT:   %arr: ref %.29 = bind_name arr, %arr.var
+// CHECK:STDOUT:   %.loc4_27.3: %Convert.type.5 = interface_witness_access constants.%.31, element0 [template = constants.%Convert.7]
+// CHECK:STDOUT:   %.loc4_27.4: <bound method> = bound_method %int.sadd, %.loc4_27.3 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc4_27.5: %i32 = value_of_initializer %int.sadd [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_27.6: %i32 = converted %int.sadd, %.loc4_27.5 [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc4_27: init Core.IntLiteral = call %.loc4_27.4(%.loc4_27.6) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_27.7: Core.IntLiteral = value_of_initializer %int.convert_checked.loc4_27 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_27.8: Core.IntLiteral = converted %int.sadd, %.loc4_27.7 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_39: type = array_type %.loc4_27.8, %i32 [template = constants.%.34]
+// CHECK:STDOUT:   %arr.var: ref %.34 = var arr
+// CHECK:STDOUT:   %arr: ref %.34 = bind_name arr, %arr.var
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic interface @As(constants.%T: type) {
@@ -720,8 +742,8 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self: %As.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
 // CHECK:STDOUT:   %Convert.type: type = fn_type @Convert.1, @As(%T) [symbolic = %Convert.type (constants.%Convert.type.1)]
 // CHECK:STDOUT:   %Convert: @As.%Convert.type (%Convert.type.1) = struct_value () [symbolic = %Convert (constants.%Convert.1)]
-// CHECK:STDOUT:   %.1: type = assoc_entity_type @As.%As.type (%As.type.2), @As.%Convert.type (%Convert.type.1) [symbolic = %.1 (constants.%.3)]
-// CHECK:STDOUT:   %.2: @As.%.1 (%.3) = assoc_entity element0, imports.%import_ref.6 [symbolic = %.2 (constants.%.4)]
+// CHECK:STDOUT:   %.1: type = assoc_entity_type @As.%As.type (%As.type.2), @As.%Convert.type (%Convert.type.1) [symbolic = %.1 (constants.%.4)]
+// CHECK:STDOUT:   %.2: @As.%.1 (%.4) = assoc_entity element0, imports.%import_ref.6 [symbolic = %.2 (constants.%.5)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   interface {
 // CHECK:STDOUT:   !members:
@@ -747,8 +769,8 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.5)]
 // CHECK:STDOUT:   %Convert.type: type = fn_type @Convert.2, @ImplicitAs(%T) [symbolic = %Convert.type (constants.%Convert.type.3)]
 // CHECK:STDOUT:   %Convert: @ImplicitAs.%Convert.type (%Convert.type.3) = struct_value () [symbolic = %Convert (constants.%Convert.3)]
-// CHECK:STDOUT:   %.1: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2), @ImplicitAs.%Convert.type (%Convert.type.3) [symbolic = %.1 (constants.%.8)]
-// CHECK:STDOUT:   %.2: @ImplicitAs.%.1 (%.8) = assoc_entity element0, imports.%import_ref.23 [symbolic = %.2 (constants.%.9)]
+// CHECK:STDOUT:   %.1: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2), @ImplicitAs.%Convert.type (%Convert.type.3) [symbolic = %.1 (constants.%.11)]
+// CHECK:STDOUT:   %.2: @ImplicitAs.%.1 (%.11) = assoc_entity element0, imports.%import_ref.23 [symbolic = %.2 (constants.%.12)]
 // CHECK:STDOUT:
 // CHECK:STDOUT:   interface {
 // CHECK:STDOUT:   !members:
@@ -784,24 +806,27 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)]
 // CHECK:STDOUT:   %As.type: type = facet_type <@As, @As(%T)> [symbolic = %As.type (constants.%As.type.2)]
 // CHECK:STDOUT:   %Self: %As.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
+// CHECK:STDOUT:   %.1: type = facet_access_type %Self [symbolic = %.1 (constants.%.3)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @Convert.1.%Self (%Self.2)]() -> @Convert.1.%T (%T);
+// CHECK:STDOUT:   fn[%self.param_patt: @Convert.1.%.1 (%.3)]() -> @Convert.1.%T (%T);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic fn @Convert.2(constants.%T: type, constants.%Self.4: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2)) {
 // CHECK:STDOUT:   %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)]
 // CHECK:STDOUT:   %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%T)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
 // CHECK:STDOUT:   %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.5)]
+// CHECK:STDOUT:   %.1: type = facet_access_type %Self [symbolic = %.1 (constants.%.10)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @Convert.2.%Self (%Self.5)]() -> @Convert.2.%T (%T);
+// CHECK:STDOUT:   fn[%self.param_patt: @Convert.2.%.1 (%.10)]() -> @Convert.2.%T (%T);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Convert.3[%self.param_patt: Core.IntLiteral]() -> %i32 = "int.convert_checked";
 // CHECK:STDOUT:
 // CHECK:STDOUT: generic fn @Op.1(constants.%Self.3: %Add.type) {
 // CHECK:STDOUT:   %Self: %Add.type = bind_symbolic_name Self, 0 [symbolic = %Self (constants.%Self.3)]
+// CHECK:STDOUT:   %.1: type = facet_access_type %Self [symbolic = %.1 (constants.%.24)]
 // CHECK:STDOUT:
-// CHECK:STDOUT:   fn[%self.param_patt: @Op.1.%Self (%Self.3)](%other.param_patt: @Op.1.%Self (%Self.3)) -> @Op.1.%Self (%Self.3);
+// CHECK:STDOUT:   fn[%self.param_patt: @Op.1.%.1 (%.24)](%other.param_patt: @Op.1.%.1 (%.24)) -> @Op.1.%.1 (%.24);
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Op.2[%self.param_patt: %i32](%other.param_patt: %i32) -> %i32 = "int.sadd";
@@ -812,51 +837,51 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @__global_init() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc4_44: Core.IntLiteral = int_value 3 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc4_47: Core.IntLiteral = int_value 4 [template = constants.%.31]
-// CHECK:STDOUT:   %.loc4_51: Core.IntLiteral = int_value 3 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc4_44: Core.IntLiteral = int_value 3 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc4_47: Core.IntLiteral = int_value 4 [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_51: Core.IntLiteral = int_value 3 [template = constants.%.33]
 // CHECK:STDOUT:   %.loc4_56.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc4_56: init type = call constants.%Int(%.loc4_56.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_56.2: type = value_of_initializer %int.make_type_signed.loc4_56 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_56.3: type = converted %int.make_type_signed.loc4_56, %.loc4_56.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_53.1: %Convert.type.2 = interface_witness_access constants.%.14, element0 [template = constants.%Convert.6]
-// CHECK:STDOUT:   %.loc4_53.2: <bound method> = bound_method %.loc4_51, %.loc4_53.1 [template = constants.%.32]
-// CHECK:STDOUT:   %int.convert_checked.loc4_53: init %i32 = call %.loc4_53.2(%.loc4_51) [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_53.3: %i32 = value_of_initializer %int.convert_checked.loc4_53 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_53.4: %i32 = converted %.loc4_51, %.loc4_53.3 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_64: Core.IntLiteral = int_value 4 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc4_53.1: %Convert.type.2 = interface_witness_access constants.%.18, element0 [template = constants.%Convert.6]
+// CHECK:STDOUT:   %.loc4_53.2: <bound method> = bound_method %.loc4_51, %.loc4_53.1 [template = constants.%.37]
+// CHECK:STDOUT:   %int.convert_checked.loc4_53: init %i32 = call %.loc4_53.2(%.loc4_51) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_53.3: %i32 = value_of_initializer %int.convert_checked.loc4_53 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_53.4: %i32 = converted %.loc4_51, %.loc4_53.3 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_64: Core.IntLiteral = int_value 4 [template = constants.%.36]
 // CHECK:STDOUT:   %.loc4_69.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
 // CHECK:STDOUT:   %int.make_type_signed.loc4_69: init type = call constants.%Int(%.loc4_69.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_69.2: type = value_of_initializer %int.make_type_signed.loc4_69 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc4_69.3: type = converted %int.make_type_signed.loc4_69, %.loc4_69.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc4_66.1: %Convert.type.2 = interface_witness_access constants.%.14, element0 [template = constants.%Convert.6]
-// CHECK:STDOUT:   %.loc4_66.2: <bound method> = bound_method %.loc4_64, %.loc4_66.1 [template = constants.%.33]
-// CHECK:STDOUT:   %int.convert_checked.loc4_66: init %i32 = call %.loc4_66.2(%.loc4_64) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_66.3: %i32 = value_of_initializer %int.convert_checked.loc4_66 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_66.4: %i32 = converted %.loc4_64, %.loc4_66.3 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_61.1: %Op.type.1 = interface_witness_access constants.%.22, element0 [template = constants.%Op.2]
-// CHECK:STDOUT:   %.loc4_61.2: <bound method> = bound_method %.loc4_53.4, %.loc4_61.1 [template = constants.%.35]
-// CHECK:STDOUT:   %int.sadd: init %i32 = call %.loc4_61.2(%.loc4_53.4, %.loc4_66.4) [template = constants.%.36]
+// CHECK:STDOUT:   %.loc4_66.1: %Convert.type.2 = interface_witness_access constants.%.18, element0 [template = constants.%Convert.6]
+// CHECK:STDOUT:   %.loc4_66.2: <bound method> = bound_method %.loc4_64, %.loc4_66.1 [template = constants.%.38]
+// CHECK:STDOUT:   %int.convert_checked.loc4_66: init %i32 = call %.loc4_66.2(%.loc4_64) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc4_66.3: %i32 = value_of_initializer %int.convert_checked.loc4_66 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc4_66.4: %i32 = converted %.loc4_64, %.loc4_66.3 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc4_61.1: %Op.type.1 = interface_witness_access constants.%.27, element0 [template = constants.%Op.2]
+// CHECK:STDOUT:   %.loc4_61.2: <bound method> = bound_method %.loc4_53.4, %.loc4_61.1 [template = constants.%.40]
+// CHECK:STDOUT:   %int.sadd: init %i32 = call %.loc4_61.2(%.loc4_53.4, %.loc4_66.4) [template = constants.%.41]
 // CHECK:STDOUT:   %.loc4_73.1: %tuple.type = tuple_literal (%.loc4_44, %.loc4_47, %int.sadd)
-// CHECK:STDOUT:   %.loc4_73.2: %Convert.type.4 = interface_witness_access constants.%.38, element0 [template = constants.%Convert.8]
-// CHECK:STDOUT:   %.loc4_73.3: <bound method> = bound_method %.loc4_44, %.loc4_73.2 [template = constants.%.39]
-// CHECK:STDOUT:   %int.convert_checked.loc4_73.1: init %i32 = call %.loc4_73.3(%.loc4_44) [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_73.4: init %i32 = converted %.loc4_44, %int.convert_checked.loc4_73.1 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_73.5: Core.IntLiteral = int_value 0 [template = constants.%.37]
+// CHECK:STDOUT:   %.loc4_73.2: %Convert.type.4 = interface_witness_access constants.%.43, element0 [template = constants.%Convert.8]
+// CHECK:STDOUT:   %.loc4_73.3: <bound method> = bound_method %.loc4_44, %.loc4_73.2 [template = constants.%.44]
+// CHECK:STDOUT:   %int.convert_checked.loc4_73.1: init %i32 = call %.loc4_73.3(%.loc4_44) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_73.4: init %i32 = converted %.loc4_44, %int.convert_checked.loc4_73.1 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_73.5: Core.IntLiteral = int_value 0 [template = constants.%.42]
 // CHECK:STDOUT:   %.loc4_73.6: ref %i32 = array_index file.%arr.var, %.loc4_73.5
-// CHECK:STDOUT:   %.loc4_73.7: init %i32 = initialize_from %.loc4_73.4 to %.loc4_73.6 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc4_73.8: %Convert.type.4 = interface_witness_access constants.%.38, element0 [template = constants.%Convert.8]
-// CHECK:STDOUT:   %.loc4_73.9: <bound method> = bound_method %.loc4_47, %.loc4_73.8 [template = constants.%.40]
-// CHECK:STDOUT:   %int.convert_checked.loc4_73.2: init %i32 = call %.loc4_73.9(%.loc4_47) [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_73.10: init %i32 = converted %.loc4_47, %int.convert_checked.loc4_73.2 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc4_73.7: init %i32 = initialize_from %.loc4_73.4 to %.loc4_73.6 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc4_73.8: %Convert.type.4 = interface_witness_access constants.%.43, element0 [template = constants.%Convert.8]
+// CHECK:STDOUT:   %.loc4_73.9: <bound method> = bound_method %.loc4_47, %.loc4_73.8 [template = constants.%.45]
+// CHECK:STDOUT:   %int.convert_checked.loc4_73.2: init %i32 = call %.loc4_73.9(%.loc4_47) [template = constants.%.39]
+// CHECK:STDOUT:   %.loc4_73.10: init %i32 = converted %.loc4_47, %int.convert_checked.loc4_73.2 [template = constants.%.39]
 // CHECK:STDOUT:   %.loc4_73.11: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc4_73.12: ref %i32 = array_index file.%arr.var, %.loc4_73.11
-// CHECK:STDOUT:   %.loc4_73.13: init %i32 = initialize_from %.loc4_73.10 to %.loc4_73.12 [template = constants.%.34]
-// CHECK:STDOUT:   %.loc4_73.14: Core.IntLiteral = int_value 2 [template = constants.%.17]
+// CHECK:STDOUT:   %.loc4_73.13: init %i32 = initialize_from %.loc4_73.10 to %.loc4_73.12 [template = constants.%.39]
+// CHECK:STDOUT:   %.loc4_73.14: Core.IntLiteral = int_value 2 [template = constants.%.21]
 // CHECK:STDOUT:   %.loc4_73.15: ref %i32 = array_index file.%arr.var, %.loc4_73.14
-// CHECK:STDOUT:   %.loc4_73.16: init %i32 = initialize_from %int.sadd to %.loc4_73.15 [template = constants.%.36]
-// CHECK:STDOUT:   %.loc4_73.17: init %.29 = array_init (%.loc4_73.7, %.loc4_73.13, %.loc4_73.16) to file.%arr.var [template = constants.%array]
-// CHECK:STDOUT:   %.loc4_74: init %.29 = converted %.loc4_73.1, %.loc4_73.17 [template = constants.%array]
+// CHECK:STDOUT:   %.loc4_73.16: init %i32 = initialize_from %int.sadd to %.loc4_73.15 [template = constants.%.41]
+// CHECK:STDOUT:   %.loc4_73.17: init %.34 = array_init (%.loc4_73.7, %.loc4_73.13, %.loc4_73.16) to file.%arr.var [template = constants.%array]
+// CHECK:STDOUT:   %.loc4_74: init %.34 = converted %.loc4_73.1, %.loc4_73.17 [template = constants.%array]
 // CHECK:STDOUT:   assign file.%arr.var, %.loc4_74
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
@@ -880,6 +905,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %T => constants.%T
 // CHECK:STDOUT:   %As.type => constants.%As.type.2
 // CHECK:STDOUT:   %Self => constants.%Self.1
+// CHECK:STDOUT:   %.1 => constants.%.6
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @As(constants.%i32) {
@@ -891,8 +917,8 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self => constants.%Self.2
 // CHECK:STDOUT:   %Convert.type => constants.%Convert.type.2
 // CHECK:STDOUT:   %Convert => constants.%Convert.2
-// CHECK:STDOUT:   %.1 => constants.%.5
-// CHECK:STDOUT:   %.2 => constants.%.6
+// CHECK:STDOUT:   %.1 => constants.%.7
+// CHECK:STDOUT:   %.2 => constants.%.8
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @ImplicitAs(constants.%T) {
@@ -909,8 +935,8 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self => constants.%Self.5
 // CHECK:STDOUT:   %Convert.type => constants.%Convert.type.4
 // CHECK:STDOUT:   %Convert => constants.%Convert.4
-// CHECK:STDOUT:   %.1 => constants.%.10
-// CHECK:STDOUT:   %.2 => constants.%.11
+// CHECK:STDOUT:   %.1 => constants.%.14
+// CHECK:STDOUT:   %.2 => constants.%.15
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @ImplicitAs(%T) {
@@ -927,6 +953,7 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %T => constants.%T
 // CHECK:STDOUT:   %ImplicitAs.type => constants.%ImplicitAs.type.2
 // CHECK:STDOUT:   %Self => constants.%Self.4
+// CHECK:STDOUT:   %.1 => constants.%.13
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @ImplicitAs(Core.IntLiteral) {
@@ -938,11 +965,12 @@ var arr: [i32; (1 as i32) + (2 as i32)] = (3, 4, (3 as i32) + (4 as i32));
 // CHECK:STDOUT:   %Self => constants.%Self.5
 // CHECK:STDOUT:   %Convert.type => constants.%Convert.type.5
 // CHECK:STDOUT:   %Convert => constants.%Convert.5
-// CHECK:STDOUT:   %.1 => constants.%.12
-// CHECK:STDOUT:   %.2 => constants.%.13
+// CHECK:STDOUT:   %.1 => constants.%.16
+// CHECK:STDOUT:   %.2 => constants.%.17
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: specific @Op.1(constants.%Self.3) {
 // CHECK:STDOUT:   %Self => constants.%Self.3
+// CHECK:STDOUT:   %.1 => constants.%.24
 // CHECK:STDOUT: }
 // CHECK:STDOUT:

toolchain/check/testdata/function/call/i32.carbon

@@ -31,10 +31,10 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -91,12 +91,12 @@ fn Main() {
 // CHECK:STDOUT:   %b: ref %i32 = bind_name b, %b.var
 // CHECK:STDOUT:   %Echo.ref: %Echo.type = name_ref Echo, file.%Echo.decl [template = constants.%Echo]
 // CHECK:STDOUT:   %.loc16_21.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc16_21.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_21.3: <bound method> = bound_method %.loc16_21.1, %.loc16_21.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc16_21.4: <specific function> = specific_function %.loc16_21.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc16_21.4(%.loc16_21.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc16_21.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc16_21.6: %i32 = converted %.loc16_21.1, %.loc16_21.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc16_21.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_21.3: <bound method> = bound_method %.loc16_21.1, %.loc16_21.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc16_21.4: <specific function> = specific_function %.loc16_21.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc16_21.4(%.loc16_21.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc16_21.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc16_21.6: %i32 = converted %.loc16_21.1, %.loc16_21.5 [template = constants.%.29]
 // CHECK:STDOUT:   %Echo.call: init %i32 = call %Echo.ref(%.loc16_21.6)
 // CHECK:STDOUT:   assign %b.var, %Echo.call
 // CHECK:STDOUT:   return

toolchain/check/testdata/function/call/more_param_ir.carbon

@@ -35,16 +35,16 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.25) [template]
-// CHECK:STDOUT:   %.26: Core.IntLiteral = int_value 0 [template]
-// CHECK:STDOUT:   %.27: Core.IntLiteral = int_value 6 [template]
-// CHECK:STDOUT:   %.28: <bound method> = bound_method %.27, %Convert.14 [template]
-// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.30: %i32 = int_value 6 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.29) [template]
+// CHECK:STDOUT:   %.30: Core.IntLiteral = int_value 0 [template]
+// CHECK:STDOUT:   %.31: Core.IntLiteral = int_value 6 [template]
+// CHECK:STDOUT:   %.32: <bound method> = bound_method %.31, %Convert.14 [template]
+// CHECK:STDOUT:   %.33: <specific function> = specific_function %.32, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.34: %i32 = int_value 6 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -102,26 +102,26 @@ fn Main() {
 // CHECK:STDOUT:   %x: ref %tuple.type.2 = bind_name x, %x.var
 // CHECK:STDOUT:   %.loc14_20: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_22.1: %tuple.type.3 = tuple_literal (%.loc14_20)
-// CHECK:STDOUT:   %.loc14_22.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_22.3: <bound method> = bound_method %.loc14_20, %.loc14_22.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc14_22.4: <specific function> = specific_function %.loc14_22.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_22.4(%.loc14_20) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_22.5: init %i32 = converted %.loc14_20, %int.convert_checked.loc14 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc14_22.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_22.3: <bound method> = bound_method %.loc14_20, %.loc14_22.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc14_22.4: <specific function> = specific_function %.loc14_22.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_22.4(%.loc14_20) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_22.5: init %i32 = converted %.loc14_20, %int.convert_checked.loc14 [template = constants.%.29]
 // CHECK:STDOUT:   %.loc14_22.6: init %tuple.type.2 = tuple_init (%.loc14_22.5) to %x.var [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc14_23: init %tuple.type.2 = converted %.loc14_22.1, %.loc14_22.6 [template = constants.%tuple]
 // CHECK:STDOUT:   assign %x.var, %.loc14_23
 // CHECK:STDOUT:   %Foo.ref: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %x.ref: ref %tuple.type.2 = name_ref x, %x
-// CHECK:STDOUT:   %.loc16_9: Core.IntLiteral = int_value 0 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc16_9: Core.IntLiteral = int_value 0 [template = constants.%.30]
 // CHECK:STDOUT:   %.loc16_8.1: ref %i32 = tuple_access %x.ref, element0
-// CHECK:STDOUT:   %.loc16_12.1: Core.IntLiteral = int_value 6 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc16_12.1: Core.IntLiteral = int_value 6 [template = constants.%.31]
 // CHECK:STDOUT:   %.loc16_8.2: %i32 = bind_value %.loc16_8.1
-// CHECK:STDOUT:   %.loc16_12.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc16_12.3: <bound method> = bound_method %.loc16_12.1, %.loc16_12.2 [template = constants.%.28]
-// CHECK:STDOUT:   %.loc16_12.4: <specific function> = specific_function %.loc16_12.3, @Convert.2(constants.%.1) [template = constants.%.29]
-// CHECK:STDOUT:   %int.convert_checked.loc16: init %i32 = call %.loc16_12.4(%.loc16_12.1) [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_12.5: %i32 = value_of_initializer %int.convert_checked.loc16 [template = constants.%.30]
-// CHECK:STDOUT:   %.loc16_12.6: %i32 = converted %.loc16_12.1, %.loc16_12.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc16_12.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc16_12.3: <bound method> = bound_method %.loc16_12.1, %.loc16_12.2 [template = constants.%.32]
+// CHECK:STDOUT:   %.loc16_12.4: <specific function> = specific_function %.loc16_12.3, @Convert.2(constants.%.1) [template = constants.%.33]
+// CHECK:STDOUT:   %int.convert_checked.loc16: init %i32 = call %.loc16_12.4(%.loc16_12.1) [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_12.5: %i32 = value_of_initializer %int.convert_checked.loc16 [template = constants.%.34]
+// CHECK:STDOUT:   %.loc16_12.6: %i32 = converted %.loc16_12.1, %.loc16_12.5 [template = constants.%.34]
 // CHECK:STDOUT:   %Foo.call: init %empty_tuple.type = call %Foo.ref(%.loc16_8.2, %.loc16_12.6)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/params_one.carbon

@@ -30,10 +30,10 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -75,12 +75,12 @@ fn Main() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %Foo.ref: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %.loc14_7.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.29]
 // CHECK:STDOUT:   %Foo.call: init %empty_tuple.type = call %Foo.ref(%.loc14_7.6)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/params_one_comma.carbon

@@ -31,10 +31,10 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -76,21 +76,21 @@ fn Main() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %Foo.ref.loc14: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %.loc14_7.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked.loc14 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked.loc14 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.29]
 // CHECK:STDOUT:   %Foo.call.loc14: init %empty_tuple.type = call %Foo.ref.loc14(%.loc14_7.6)
 // CHECK:STDOUT:   %Foo.ref.loc15: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %.loc15_7.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc15_7.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_7.3: <bound method> = bound_method %.loc15_7.1, %.loc15_7.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc15_7.4: <specific function> = specific_function %.loc15_7.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_7.4(%.loc15_7.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_7.5: %i32 = value_of_initializer %int.convert_checked.loc15 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc15_7.6: %i32 = converted %.loc15_7.1, %.loc15_7.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc15_7.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_7.3: <bound method> = bound_method %.loc15_7.1, %.loc15_7.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc15_7.4: <specific function> = specific_function %.loc15_7.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc15: init %i32 = call %.loc15_7.4(%.loc15_7.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_7.5: %i32 = value_of_initializer %int.convert_checked.loc15 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_7.6: %i32 = converted %.loc15_7.1, %.loc15_7.5 [template = constants.%.29]
 // CHECK:STDOUT:   %Foo.call.loc15: init %empty_tuple.type = call %Foo.ref.loc15(%.loc15_7.6)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/params_two.carbon

@@ -31,13 +31,13 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -88,18 +88,18 @@ fn Main() {
 // CHECK:STDOUT:   %Foo.ref: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %.loc14_7.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_10.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc14_7: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked.loc14_7 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_10.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_10.3: <bound method> = bound_method %.loc14_10.1, %.loc14_10.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc14_10.4: <specific function> = specific_function %.loc14_10.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc14_10: init %i32 = call %.loc14_10.4(%.loc14_10.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_10.5: %i32 = value_of_initializer %int.convert_checked.loc14_10 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_10.6: %i32 = converted %.loc14_10.1, %.loc14_10.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc14_7: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked.loc14_7 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_10.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_10.3: <bound method> = bound_method %.loc14_10.1, %.loc14_10.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc14_10.4: <specific function> = specific_function %.loc14_10.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc14_10: init %i32 = call %.loc14_10.4(%.loc14_10.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_10.5: %i32 = value_of_initializer %int.convert_checked.loc14_10 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_10.6: %i32 = converted %.loc14_10.1, %.loc14_10.5 [template = constants.%.33]
 // CHECK:STDOUT:   %Foo.call: init %empty_tuple.type = call %Foo.ref(%.loc14_7.6, %.loc14_10.6)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/params_two_comma.carbon

@@ -32,13 +32,13 @@ fn Main() {
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.27: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.29: %i32 = int_value 2 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.31: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.32: <specific function> = specific_function %.31, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.33: %i32 = int_value 2 [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -89,34 +89,34 @@ fn Main() {
 // CHECK:STDOUT:   %Foo.ref.loc14: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %.loc14_7.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc14_10.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc14_7: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked.loc14_7 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_10.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_10.3: <bound method> = bound_method %.loc14_10.1, %.loc14_10.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc14_10.4: <specific function> = specific_function %.loc14_10.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc14_10: init %i32 = call %.loc14_10.4(%.loc14_10.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_10.5: %i32 = value_of_initializer %int.convert_checked.loc14_10 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc14_10.6: %i32 = converted %.loc14_10.1, %.loc14_10.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc14_7.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_7.3: <bound method> = bound_method %.loc14_7.1, %.loc14_7.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc14_7.4: <specific function> = specific_function %.loc14_7.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc14_7: init %i32 = call %.loc14_7.4(%.loc14_7.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_7.5: %i32 = value_of_initializer %int.convert_checked.loc14_7 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_7.6: %i32 = converted %.loc14_7.1, %.loc14_7.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_10.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_10.3: <bound method> = bound_method %.loc14_10.1, %.loc14_10.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc14_10.4: <specific function> = specific_function %.loc14_10.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc14_10: init %i32 = call %.loc14_10.4(%.loc14_10.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_10.5: %i32 = value_of_initializer %int.convert_checked.loc14_10 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc14_10.6: %i32 = converted %.loc14_10.1, %.loc14_10.5 [template = constants.%.33]
 // CHECK:STDOUT:   %Foo.call.loc14: init %empty_tuple.type = call %Foo.ref.loc14(%.loc14_7.6, %.loc14_10.6)
 // CHECK:STDOUT:   %Foo.ref.loc15: %Foo.type = name_ref Foo, file.%Foo.decl [template = constants.%Foo]
 // CHECK:STDOUT:   %.loc15_7.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc15_10.1: Core.IntLiteral = int_value 2 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc15_7.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_7.3: <bound method> = bound_method %.loc15_7.1, %.loc15_7.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc15_7.4: <specific function> = specific_function %.loc15_7.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc15_7: init %i32 = call %.loc15_7.4(%.loc15_7.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_7.5: %i32 = value_of_initializer %int.convert_checked.loc15_7 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_7.6: %i32 = converted %.loc15_7.1, %.loc15_7.5 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc15_10.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc15_10.3: <bound method> = bound_method %.loc15_10.1, %.loc15_10.2 [template = constants.%.27]
-// CHECK:STDOUT:   %.loc15_10.4: <specific function> = specific_function %.loc15_10.3, @Convert.2(constants.%.1) [template = constants.%.28]
-// CHECK:STDOUT:   %int.convert_checked.loc15_10: init %i32 = call %.loc15_10.4(%.loc15_10.1) [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_10.5: %i32 = value_of_initializer %int.convert_checked.loc15_10 [template = constants.%.29]
-// CHECK:STDOUT:   %.loc15_10.6: %i32 = converted %.loc15_10.1, %.loc15_10.5 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc15_7.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_7.3: <bound method> = bound_method %.loc15_7.1, %.loc15_7.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc15_7.4: <specific function> = specific_function %.loc15_7.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc15_7: init %i32 = call %.loc15_7.4(%.loc15_7.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_7.5: %i32 = value_of_initializer %int.convert_checked.loc15_7 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_7.6: %i32 = converted %.loc15_7.1, %.loc15_7.5 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc15_10.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc15_10.3: <bound method> = bound_method %.loc15_10.1, %.loc15_10.2 [template = constants.%.31]
+// CHECK:STDOUT:   %.loc15_10.4: <specific function> = specific_function %.loc15_10.3, @Convert.2(constants.%.1) [template = constants.%.32]
+// CHECK:STDOUT:   %int.convert_checked.loc15_10: init %i32 = call %.loc15_10.4(%.loc15_10.1) [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_10.5: %i32 = value_of_initializer %int.convert_checked.loc15_10 [template = constants.%.33]
+// CHECK:STDOUT:   %.loc15_10.6: %i32 = converted %.loc15_10.1, %.loc15_10.5 [template = constants.%.33]
 // CHECK:STDOUT:   %Foo.call.loc15: init %empty_tuple.type = call %Foo.ref.loc15(%.loc15_7.6, %.loc15_10.6)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/declaration/import.carbon

@@ -469,16 +469,16 @@ import library "extern_api";
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: type = struct_type {.c: %i32} [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {.c: %i32} [template]
 // CHECK:STDOUT:   %C.type: type = fn_type @C [template]
 // CHECK:STDOUT:   %C: %C.type = struct_value () [template]
 // CHECK:STDOUT:   %tuple.type.1: type = tuple_type (%i32) [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (Core.IntLiteral) [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.25) [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.29) [template]
 // CHECK:STDOUT:   %D.type: type = fn_type @D [template]
 // CHECK:STDOUT:   %D: %D.type = struct_value () [template]
 // CHECK:STDOUT:   %E.type: type = fn_type @E [template]
@@ -533,9 +533,9 @@ import library "extern_api";
 // CHECK:STDOUT:   %int.make_type_signed.loc8: init type = call constants.%Int(%.loc8_13.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc8_13.2: type = value_of_initializer %int.make_type_signed.loc8 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc8_13.3: type = converted %int.make_type_signed.loc8, %.loc8_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc8_16: type = struct_type {.c: %i32} [template = constants.%.26]
-// CHECK:STDOUT:   %c.var: ref %.26 = var c
-// CHECK:STDOUT:   %c: ref %.26 = bind_name c, %c.var
+// CHECK:STDOUT:   %.loc8_16: type = struct_type {.c: %i32} [template = constants.%.30]
+// CHECK:STDOUT:   %c.var: ref %.30 = var c
+// CHECK:STDOUT:   %c: ref %.30 = bind_name c, %c.var
 // CHECK:STDOUT:   %.loc9_9.1: %empty_tuple.type = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_9.2: type = converted %.loc9_9.1, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
 // CHECK:STDOUT:   %d.var: ref %empty_tuple.type = var d
@@ -550,7 +550,7 @@ import library "extern_api";
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @B(%b.param_patt: %i32) -> %i32;
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @C(%c.param_patt: %tuple.type.1) -> %.26;
+// CHECK:STDOUT: fn @C(%c.param_patt: %tuple.type.1) -> %.30;
 // CHECK:STDOUT:
 // CHECK:STDOUT: extern fn @D();
 // CHECK:STDOUT:
@@ -563,26 +563,26 @@ import library "extern_api";
 // CHECK:STDOUT:   assign file.%a.var, %A.call
 // CHECK:STDOUT:   %B.ref: %B.type = name_ref B, imports.%import_ref.2 [template = constants.%B]
 // CHECK:STDOUT:   %.loc7_16.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc7_16.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc7_16.3: <bound method> = bound_method %.loc7_16.1, %.loc7_16.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc7_16.4: <specific function> = specific_function %.loc7_16.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc7: init %i32 = call %.loc7_16.4(%.loc7_16.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc7_16.5: %i32 = value_of_initializer %int.convert_checked.loc7 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc7_16.6: %i32 = converted %.loc7_16.1, %.loc7_16.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc7_16.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc7_16.3: <bound method> = bound_method %.loc7_16.1, %.loc7_16.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc7_16.4: <specific function> = specific_function %.loc7_16.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc7: init %i32 = call %.loc7_16.4(%.loc7_16.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc7_16.5: %i32 = value_of_initializer %int.convert_checked.loc7 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc7_16.6: %i32 = converted %.loc7_16.1, %.loc7_16.5 [template = constants.%.29]
 // CHECK:STDOUT:   %B.call: init %i32 = call %B.ref(%.loc7_16.6)
 // CHECK:STDOUT:   assign file.%b.var, %B.call
 // CHECK:STDOUT:   %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
 // CHECK:STDOUT:   %.loc8_23: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc8_25.1: %tuple.type.2 = tuple_literal (%.loc8_23)
-// CHECK:STDOUT:   %.loc8_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc8_25.3: <bound method> = bound_method %.loc8_23, %.loc8_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc8_25.4: <specific function> = specific_function %.loc8_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_25.4(%.loc8_23) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_25.5: %i32 = value_of_initializer %int.convert_checked.loc8 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc8_25.6: %i32 = converted %.loc8_23, %.loc8_25.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc8_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc8_25.3: <bound method> = bound_method %.loc8_23, %.loc8_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc8_25.4: <specific function> = specific_function %.loc8_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc8: init %i32 = call %.loc8_25.4(%.loc8_23) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_25.5: %i32 = value_of_initializer %int.convert_checked.loc8 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc8_25.6: %i32 = converted %.loc8_23, %.loc8_25.5 [template = constants.%.29]
 // CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.loc8_25.6) [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc8_25.7: %tuple.type.1 = converted %.loc8_25.1, %tuple [template = constants.%tuple]
-// CHECK:STDOUT:   %C.call: init %.26 = call %C.ref(%.loc8_25.7)
+// CHECK:STDOUT:   %C.call: init %.30 = call %C.ref(%.loc8_25.7)
 // CHECK:STDOUT:   assign file.%c.var, %C.call
 // CHECK:STDOUT:   %D.ref: %D.type = name_ref D, imports.%import_ref.4 [template = constants.%D]
 // CHECK:STDOUT:   %D.call: init %empty_tuple.type = call %D.ref()
@@ -619,12 +619,12 @@ import library "extern_api";
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %tuple.type.3: type = tuple_type (Core.IntLiteral) [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.26) [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.30) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -734,23 +734,23 @@ import library "extern_api";
 // CHECK:STDOUT:   assign file.%a.var, %A.call
 // CHECK:STDOUT:   %B.ref: %B.type = name_ref B, file.%B.decl [template = constants.%B]
 // CHECK:STDOUT:   %.loc53_16.1: Core.IntLiteral = int_value 1 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc53_16.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc53_16.3: <bound method> = bound_method %.loc53_16.1, %.loc53_16.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc53_16.4: <specific function> = specific_function %.loc53_16.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc53: init %i32 = call %.loc53_16.4(%.loc53_16.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc53_16.5: %i32 = value_of_initializer %int.convert_checked.loc53 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc53_16.6: %i32 = converted %.loc53_16.1, %.loc53_16.5 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc53_16.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc53_16.3: <bound method> = bound_method %.loc53_16.1, %.loc53_16.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc53_16.4: <specific function> = specific_function %.loc53_16.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc53: init %i32 = call %.loc53_16.4(%.loc53_16.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc53_16.5: %i32 = value_of_initializer %int.convert_checked.loc53 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc53_16.6: %i32 = converted %.loc53_16.1, %.loc53_16.5 [template = constants.%.30]
 // CHECK:STDOUT:   %B.call: init %i32 = call %B.ref(%.loc53_16.6)
 // CHECK:STDOUT:   assign file.%b.var, %B.call
 // CHECK:STDOUT:   %C.ref: %C.type = name_ref C, file.%C.decl [template = constants.%C]
 // CHECK:STDOUT:   %.loc54_23: Core.IntLiteral = int_value 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc54_25.1: %tuple.type.3 = tuple_literal (%.loc54_23)
-// CHECK:STDOUT:   %.loc54_25.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc54_25.3: <bound method> = bound_method %.loc54_23, %.loc54_25.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc54_25.4: <specific function> = specific_function %.loc54_25.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc54: init %i32 = call %.loc54_25.4(%.loc54_23) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc54_25.5: %i32 = value_of_initializer %int.convert_checked.loc54 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc54_25.6: %i32 = converted %.loc54_23, %.loc54_25.5 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc54_25.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc54_25.3: <bound method> = bound_method %.loc54_23, %.loc54_25.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc54_25.4: <specific function> = specific_function %.loc54_25.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc54: init %i32 = call %.loc54_25.4(%.loc54_23) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc54_25.5: %i32 = value_of_initializer %int.convert_checked.loc54 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc54_25.6: %i32 = converted %.loc54_23, %.loc54_25.5 [template = constants.%.30]
 // CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.loc54_25.6) [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc54_25.7: %tuple.type.2 = converted %.loc54_25.1, %tuple [template = constants.%tuple]
 // CHECK:STDOUT:   %C.call: init %.2 = call %C.ref(%.loc54_25.7)
@@ -790,12 +790,12 @@ import library "extern_api";
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.23: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.24: <bound method> = bound_method %.3, %Convert.14 [template]
-// CHECK:STDOUT:   %.25: <specific function> = specific_function %.24, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.26: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.27: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.28: <bound method> = bound_method %.3, %Convert.14 [template]
+// CHECK:STDOUT:   %.29: <specific function> = specific_function %.28, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.30: %i32 = int_value 1 [template]
 // CHECK:STDOUT:   %tuple.type.3: type = tuple_type (Core.IntLiteral) [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.26) [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.30) [template]
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: imports {
@@ -905,23 +905,23 @@ import library "extern_api";
 // CHECK:STDOUT:   assign file.%a.var, %A.call
 // CHECK:STDOUT:   %B.ref: %B.type = name_ref B, file.%B.decl [template = constants.%B]
 // CHECK:STDOUT:   %.loc13_16.1: Core.IntLiteral = int_value 1 [template = constants.%.3]
-// CHECK:STDOUT:   %.loc13_16.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc13_16.3: <bound method> = bound_method %.loc13_16.1, %.loc13_16.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc13_16.4: <specific function> = specific_function %.loc13_16.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc13: init %i32 = call %.loc13_16.4(%.loc13_16.1) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_16.5: %i32 = value_of_initializer %int.convert_checked.loc13 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc13_16.6: %i32 = converted %.loc13_16.1, %.loc13_16.5 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc13_16.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc13_16.3: <bound method> = bound_method %.loc13_16.1, %.loc13_16.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc13_16.4: <specific function> = specific_function %.loc13_16.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc13: init %i32 = call %.loc13_16.4(%.loc13_16.1) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_16.5: %i32 = value_of_initializer %int.convert_checked.loc13 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc13_16.6: %i32 = converted %.loc13_16.1, %.loc13_16.5 [template = constants.%.30]
 // CHECK:STDOUT:   %B.call: init %i32 = call %B.ref(%.loc13_16.6)
 // CHECK:STDOUT:   assign file.%b.var, %B.call
 // CHECK:STDOUT:   %C.ref: %C.type = name_ref C, file.%C.decl [template = constants.%C]
 // CHECK:STDOUT:   %.loc14_23: Core.IntLiteral = int_value 1 [template = constants.%.3]
 // CHECK:STDOUT:   %.loc14_25.1: %tuple.type.3 = tuple_literal (%.loc14_23)
-// CHECK:STDOUT:   %.loc14_25.2: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc14_25.3: <bound method> = bound_method %.loc14_23, %.loc14_25.2 [template = constants.%.24]
-// CHECK:STDOUT:   %.loc14_25.4: <specific function> = specific_function %.loc14_25.3, @Convert.2(constants.%.1) [template = constants.%.25]
-// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_25.4(%.loc14_23) [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_25.5: %i32 = value_of_initializer %int.convert_checked.loc14 [template = constants.%.26]
-// CHECK:STDOUT:   %.loc14_25.6: %i32 = converted %.loc14_23, %.loc14_25.5 [template = constants.%.26]
+// CHECK:STDOUT:   %.loc14_25.2: %Convert.type.2 = interface_witness_access constants.%.27, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc14_25.3: <bound method> = bound_method %.loc14_23, %.loc14_25.2 [template = constants.%.28]
+// CHECK:STDOUT:   %.loc14_25.4: <specific function> = specific_function %.loc14_25.3, @Convert.2(constants.%.1) [template = constants.%.29]
+// CHECK:STDOUT:   %int.convert_checked.loc14: init %i32 = call %.loc14_25.4(%.loc14_23) [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_25.5: %i32 = value_of_initializer %int.convert_checked.loc14 [template = constants.%.30]
+// CHECK:STDOUT:   %.loc14_25.6: %i32 = converted %.loc14_23, %.loc14_25.5 [template = constants.%.30]
 // CHECK:STDOUT:   %tuple: %tuple.type.2 = tuple_value (%.loc14_25.6) [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc14_25.7: %tuple.type.2 = converted %.loc14_25.1, %tuple [template = constants.%tuple]
 // CHECK:STDOUT:   %C.call: init %.2 = call %C.ref(%.loc14_25.7)
@@ -952,16 +952,16 @@ import library "extern_api";
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: type = struct_type {.c: %i32} [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {.c: %i32} [template]
 // CHECK:STDOUT:   %C.type: type = fn_type @C [template]
 // CHECK:STDOUT:   %C: %C.type = struct_value () [template]
 // CHECK:STDOUT:   %tuple.type.1: type = tuple_type (%i32) [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (Core.IntLiteral) [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.25) [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.29) [template]
 // CHECK:STDOUT:   %D.type: type = fn_type @D [template]
 // CHECK:STDOUT:   %D: %D.type = struct_value () [template]
 // CHECK:STDOUT:   %E.type: type = fn_type @E [template]
@@ -1016,9 +1016,9 @@ import library "extern_api";
 // CHECK:STDOUT:   %int.make_type_signed.loc54: init type = call constants.%Int(%.loc54_13.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc54_13.2: type = value_of_initializer %int.make_type_signed.loc54 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc54_13.3: type = converted %int.make_type_signed.loc54, %.loc54_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc54_16: type = struct_type {.c: %i32} [template = constants.%.26]
-// CHECK:STDOUT:   %c.var: ref %.26 = var c
-// CHECK:STDOUT:   %c: ref %.26 = bind_name c, %c.var
+// CHECK:STDOUT:   %.loc54_16: type = struct_type {.c: %i32} [template = constants.%.30]
+// CHECK:STDOUT:   %c.var: ref %.30 = var c
+// CHECK:STDOUT:   %c: ref %.30 = bind_name c, %c.var
 // CHECK:STDOUT:   %.loc55_9.1: %empty_tuple.type = tuple_literal ()
 // CHECK:STDOUT:   %.loc55_9.2: type = converted %.loc55_9.1, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
 // CHECK:STDOUT:   %d.var: ref %empty_tuple.type = var d
@@ -1033,7 +1033,7 @@ import library "extern_api";
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @B(%b.param_patt: %i32) -> %i32;
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @C(%c.param_patt: %tuple.type.1) -> %.26;
+// CHECK:STDOUT: fn @C(%c.param_patt: %tuple.type.1) -> %.30;
 // CHECK:STDOUT:
 // CHECK:STDOUT: extern fn @D();
 // CHECK:STDOUT:
@@ -1046,26 +1046,26 @@ import library "extern_api";
 // CHECK:STDOUT:   assign file.%a.var, %A.call
 // CHECK:STDOUT:   %B.ref: %B.type = name_ref B, imports.%import_ref.2 [template = constants.%B]
 // CHECK:STDOUT:   %.loc53_16.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc53_16.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc53_16.3: <bound method> = bound_method %.loc53_16.1, %.loc53_16.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc53_16.4: <specific function> = specific_function %.loc53_16.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc53: init %i32 = call %.loc53_16.4(%.loc53_16.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc53_16.5: %i32 = value_of_initializer %int.convert_checked.loc53 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc53_16.6: %i32 = converted %.loc53_16.1, %.loc53_16.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc53_16.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc53_16.3: <bound method> = bound_method %.loc53_16.1, %.loc53_16.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc53_16.4: <specific function> = specific_function %.loc53_16.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc53: init %i32 = call %.loc53_16.4(%.loc53_16.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc53_16.5: %i32 = value_of_initializer %int.convert_checked.loc53 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc53_16.6: %i32 = converted %.loc53_16.1, %.loc53_16.5 [template = constants.%.29]
 // CHECK:STDOUT:   %B.call: init %i32 = call %B.ref(%.loc53_16.6)
 // CHECK:STDOUT:   assign file.%b.var, %B.call
 // CHECK:STDOUT:   %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
 // CHECK:STDOUT:   %.loc54_23: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc54_25.1: %tuple.type.2 = tuple_literal (%.loc54_23)
-// CHECK:STDOUT:   %.loc54_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc54_25.3: <bound method> = bound_method %.loc54_23, %.loc54_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc54_25.4: <specific function> = specific_function %.loc54_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc54: init %i32 = call %.loc54_25.4(%.loc54_23) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc54_25.5: %i32 = value_of_initializer %int.convert_checked.loc54 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc54_25.6: %i32 = converted %.loc54_23, %.loc54_25.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc54_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc54_25.3: <bound method> = bound_method %.loc54_23, %.loc54_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc54_25.4: <specific function> = specific_function %.loc54_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc54: init %i32 = call %.loc54_25.4(%.loc54_23) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc54_25.5: %i32 = value_of_initializer %int.convert_checked.loc54 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc54_25.6: %i32 = converted %.loc54_23, %.loc54_25.5 [template = constants.%.29]
 // CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.loc54_25.6) [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc54_25.7: %tuple.type.1 = converted %.loc54_25.1, %tuple [template = constants.%tuple]
-// CHECK:STDOUT:   %C.call: init %.26 = call %C.ref(%.loc54_25.7)
+// CHECK:STDOUT:   %C.call: init %.30 = call %C.ref(%.loc54_25.7)
 // CHECK:STDOUT:   assign file.%c.var, %C.call
 // CHECK:STDOUT:   %D.ref: %D.type = name_ref D, imports.%import_ref.4 [template = constants.%D]
 // CHECK:STDOUT:   %D.call: init %empty_tuple.type = call %D.ref()
@@ -1093,16 +1093,16 @@ import library "extern_api";
 // CHECK:STDOUT:   %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template]
 // CHECK:STDOUT:   %Convert.type.14: type = fn_type @Convert.2, @impl.1(%.1) [template]
 // CHECK:STDOUT:   %Convert.14: %Convert.type.14 = struct_value () [template]
-// CHECK:STDOUT:   %.22: <witness> = interface_witness (%Convert.14) [template]
-// CHECK:STDOUT:   %.23: <bound method> = bound_method %.2, %Convert.14 [template]
-// CHECK:STDOUT:   %.24: <specific function> = specific_function %.23, @Convert.2(%.1) [template]
-// CHECK:STDOUT:   %.25: %i32 = int_value 1 [template]
-// CHECK:STDOUT:   %.26: type = struct_type {.c: %i32} [template]
+// CHECK:STDOUT:   %.26: <witness> = interface_witness (%Convert.14) [template]
+// CHECK:STDOUT:   %.27: <bound method> = bound_method %.2, %Convert.14 [template]
+// CHECK:STDOUT:   %.28: <specific function> = specific_function %.27, @Convert.2(%.1) [template]
+// CHECK:STDOUT:   %.29: %i32 = int_value 1 [template]
+// CHECK:STDOUT:   %.30: type = struct_type {.c: %i32} [template]
 // CHECK:STDOUT:   %C.type: type = fn_type @C [template]
 // CHECK:STDOUT:   %C: %C.type = struct_value () [template]
 // CHECK:STDOUT:   %tuple.type.1: type = tuple_type (%i32) [template]
 // CHECK:STDOUT:   %tuple.type.2: type = tuple_type (Core.IntLiteral) [template]
-// CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.25) [template]
+// CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.29) [template]
 // CHECK:STDOUT:   %D.type: type = fn_type @D [template]
 // CHECK:STDOUT:   %D: %D.type = struct_value () [template]
 // CHECK:STDOUT:   %E.type: type = fn_type @E [template]
@@ -1157,9 +1157,9 @@ import library "extern_api";
 // CHECK:STDOUT:   %int.make_type_signed.loc53: init type = call constants.%Int(%.loc53_13.1) [template = constants.%i32]
 // CHECK:STDOUT:   %.loc53_13.2: type = value_of_initializer %int.make_type_signed.loc53 [template = constants.%i32]
 // CHECK:STDOUT:   %.loc53_13.3: type = converted %int.make_type_signed.loc53, %.loc53_13.2 [template = constants.%i32]
-// CHECK:STDOUT:   %.loc53_16: type = struct_type {.c: %i32} [template = constants.%.26]
-// CHECK:STDOUT:   %c.var: ref %.26 = var c
-// CHECK:STDOUT:   %c: ref %.26 = bind_name c, %c.var
+// CHECK:STDOUT:   %.loc53_16: type = struct_type {.c: %i32} [template = constants.%.30]
+// CHECK:STDOUT:   %c.var: ref %.30 = var c
+// CHECK:STDOUT:   %c: ref %.30 = bind_name c, %c.var
 // CHECK:STDOUT:   %.loc54_9.1: %empty_tuple.type = tuple_literal ()
 // CHECK:STDOUT:   %.loc54_9.2: type = converted %.loc54_9.1, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
 // CHECK:STDOUT:   %d.var: ref %empty_tuple.type = var d
@@ -1174,7 +1174,7 @@ import library "extern_api";
 // CHECK:STDOUT:
 // CHECK:STDOUT: extern fn @B(%b.param_patt: %i32) -> %i32;
 // CHECK:STDOUT:
-// CHECK:STDOUT: extern fn @C(%c.param_patt: %tuple.type.1) -> %.26;
+// CHECK:STDOUT: extern fn @C(%c.param_patt: %tuple.type.1) -> %.30;
 // CHECK:STDOUT:
 // CHECK:STDOUT: extern fn @D();
 // CHECK:STDOUT:
@@ -1187,26 +1187,26 @@ import library "extern_api";
 // CHECK:STDOUT:   assign file.%a.var, %A.call
 // CHECK:STDOUT:   %B.ref: %B.type = name_ref B, imports.%import_ref.2 [template = constants.%B]
 // CHECK:STDOUT:   %.loc52_16.1: Core.IntLiteral = int_value 1 [template = constants.%.2]
-// CHECK:STDOUT:   %.loc52_16.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc52_16.3: <bound method> = bound_method %.loc52_16.1, %.loc52_16.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc52_16.4: <specific function> = specific_function %.loc52_16.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc52: init %i32 = call %.loc52_16.4(%.loc52_16.1) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc52_16.5: %i32 = value_of_initializer %int.convert_checked.loc52 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc52_16.6: %i32 = converted %.loc52_16.1, %.loc52_16.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc52_16.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc52_16.3: <bound method> = bound_method %.loc52_16.1, %.loc52_16.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc52_16.4: <specific function> = specific_function %.loc52_16.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc52: init %i32 = call %.loc52_16.4(%.loc52_16.1) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc52_16.5: %i32 = value_of_initializer %int.convert_checked.loc52 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc52_16.6: %i32 = converted %.loc52_16.1, %.loc52_16.5 [template = constants.%.29]
 // CHECK:STDOUT:   %B.call: init %i32 = call %B.ref(%.loc52_16.6)
 // CHECK:STDOUT:   assign file.%b.var, %B.call
 // CHECK:STDOUT:   %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
 // CHECK:STDOUT:   %.loc53_23: Core.IntLiteral = int_value 1 [template = constants.%.2]
 // CHECK:STDOUT:   %.loc53_25.1: %tuple.type.2 = tuple_literal (%.loc53_23)
-// CHECK:STDOUT:   %.loc53_25.2: %Convert.type.2 = interface_witness_access constants.%.22, element0 [template = constants.%Convert.14]
-// CHECK:STDOUT:   %.loc53_25.3: <bound method> = bound_method %.loc53_23, %.loc53_25.2 [template = constants.%.23]
-// CHECK:STDOUT:   %.loc53_25.4: <specific function> = specific_function %.loc53_25.3, @Convert.2(constants.%.1) [template = constants.%.24]
-// CHECK:STDOUT:   %int.convert_checked.loc53: init %i32 = call %.loc53_25.4(%.loc53_23) [template = constants.%.25]
-// CHECK:STDOUT:   %.loc53_25.5: %i32 = value_of_initializer %int.convert_checked.loc53 [template = constants.%.25]
-// CHECK:STDOUT:   %.loc53_25.6: %i32 = converted %.loc53_23, %.loc53_25.5 [template = constants.%.25]
+// CHECK:STDOUT:   %.loc53_25.2: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
+// CHECK:STDOUT:   %.loc53_25.3: <bound method> = bound_method %.loc53_23, %.loc53_25.2 [template = constants.%.27]
+// CHECK:STDOUT:   %.loc53_25.4: <specific function> = specific_function %.loc53_25.3, @Convert.2(constants.%.1) [template = constants.%.28]
+// CHECK:STDOUT:   %int.convert_checked.loc53: init %i32 = call %.loc53_25.4(%.loc53_23) [template = constants.%.29]
+// CHECK:STDOUT:   %.loc53_25.5: %i32 = value_of_initializer %int.convert_checked.loc53 [template = constants.%.29]
+// CHECK:STDOUT:   %.loc53_25.6: %i32 = converted %.loc53_23, %.loc53_25.5 [template = constants.%.29]
 // CHECK:STDOUT:   %tuple: %tuple.type.1 = tuple_value (%.loc53_25.6) [template = constants.%tuple]
 // CHECK:STDOUT:   %.loc53_25.7: %tuple.type.1 = converted %.loc53_25.1, %tuple [template = constants.%tuple]
-// CHECK:STDOUT:   %C.call: init %.26 = call %C.ref(%.loc53_25.7)
+// CHECK:STDOUT:   %C.call: init %.30 = call %C.ref(%.loc53_25.7)
 // CHECK:STDOUT:   assign file.%c.var, %C.call
 // CHECK:STDOUT:   %D.ref: %D.type = name_ref D, imports.%import_ref.4 [template = constants.%D]
 // CHECK:STDOUT:   %D.call: init %empty_tuple.type = call %D.ref()