diff --git a/toolchain/check/pattern.cpp b/toolchain/check/pattern.cpp index 751c4cbd00a1..2d8627d5ddab 100644 --- a/toolchain/check/pattern.cpp +++ b/toolchain/check/pattern.cpp @@ -103,16 +103,15 @@ auto AddBindingPattern(Context& context, SemIR::LocId name_loc, } // Returns a VarStorage inst for the given `var` pattern. If the pattern -// is the body of a returned var, this reuses the return slot, and otherwise it -// adds a new inst. +// is the body of a returned var, this reuses the return parameter, and +// otherwise it adds a new inst. static auto GetOrAddVarStorage(Context& context, SemIR::InstId var_pattern_id, bool is_returned_var) -> SemIR::InstId { if (is_returned_var) { - auto& function = GetCurrentFunctionForReturn(context); - auto return_info = - SemIR::ReturnTypeInfo::ForFunction(context.sem_ir(), function); - if (return_info.has_return_slot()) { - return GetCurrentReturnSlot(context); + if (auto return_param_id = + GetReturnedVarParam(context, GetCurrentFunctionForReturn(context)); + return_param_id.has_value()) { + return return_param_id; } } auto pattern = context.insts().GetWithLocId(var_pattern_id); diff --git a/toolchain/check/return.cpp b/toolchain/check/return.cpp index 0532e3fdee53..4a52cd9ca04a 100644 --- a/toolchain/check/return.cpp +++ b/toolchain/check/return.cpp @@ -22,17 +22,24 @@ auto GetCurrentFunctionForReturn(Context& context) -> SemIR::Function& { return context.functions().Get(function_id); } -auto GetCurrentReturnSlot(Context& context) -> SemIR::InstId { - // TODO: this does some unnecessary work to compute non-lexical scopes, - // so a separate API on ScopeStack could be more efficient. - auto return_slot_id = context.scope_stack() - .LookupInLexicalScopes(SemIR::NameId::ReturnSlot) - .first; - return return_slot_id; +auto GetReturnedVarParam(Context& context, const SemIR::Function& function) + -> SemIR::InstId { + auto return_form_id = function.GetDeclaredReturnForm(context.sem_ir()); + if (auto return_form = + context.insts().TryGetAsIfValid(return_form_id)) { + auto call_params = context.inst_blocks().Get(function.call_params_id); + auto return_param_id = call_params[return_form->index.index]; + auto return_type_id = context.insts().Get(return_param_id).type_id(); + if (SemIR::InitRepr::ForType(context.sem_ir(), return_type_id) + .MightBeInPlace()) { + return return_param_id; + } + } + return SemIR::InstId::None; } -// Gets the currently in scope `returned var`, if any, that would be returned -// by a `return var;`. +// Gets the currently in scope `returned var` binding, if any, that would be +// returned by a `return var;`. static auto GetCurrentReturnedVar(Context& context) -> SemIR::InstId { CARBON_CHECK(context.scope_stack().IsInFunctionScope(), "Handling return but not in a function"); @@ -128,7 +135,7 @@ auto BuildReturnWithExpr(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id) -> void { const auto& function = GetCurrentFunctionForReturn(context); auto returned_var_id = GetCurrentReturnedVar(context); - auto return_slot_id = SemIR::InstId::None; + auto out_param_id = SemIR::InstId::None; auto return_type_id = SemIR::TypeId::None; if (function.return_type_inst_id.has_value()) { @@ -161,10 +168,12 @@ auto BuildReturnWithExpr(Context& context, SemIR::LocId loc_id, auto return_form = context.insts().Get(function.GetDeclaredReturnForm(context.sem_ir())); CARBON_KIND_SWITCH(return_form) { - case CARBON_KIND(SemIR::InitForm _): { - return_slot_id = GetCurrentReturnSlot(context); - CARBON_CHECK(return_slot_id.has_value()); - expr_id = Initialize(context, loc_id, return_slot_id, expr_id); + case CARBON_KIND(SemIR::InitForm init_form): { + auto call_params = context.inst_blocks().Get( + GetCurrentFunctionForReturn(context).call_params_id); + out_param_id = call_params[init_form.index.index]; + CARBON_CHECK(out_param_id.has_value()); + expr_id = Initialize(context, loc_id, out_param_id, expr_id); break; } case CARBON_KIND(SemIR::RefForm ref_form): { @@ -180,8 +189,8 @@ auto BuildReturnWithExpr(Context& context, SemIR::LocId loc_id, } } - AddReturnCleanupBlockWithExpr( - context, loc_id, {.expr_id = expr_id, .dest_id = return_slot_id}); + AddReturnCleanupBlockWithExpr(context, loc_id, + {.expr_id = expr_id, .dest_id = out_param_id}); } auto BuildReturnVar(Context& context, Parse::ReturnStatementId node_id) @@ -196,18 +205,16 @@ auto BuildReturnVar(Context& context, Parse::ReturnStatementId node_id) returned_var_id = SemIR::ErrorInst::InstId; } - auto return_slot_id = GetCurrentReturnSlot(context); - if (!SemIR::ReturnTypeInfo::ForFunction(context.sem_ir(), function) - .has_return_slot()) { + auto return_param_id = GetReturnedVarParam(context, function); + if (!return_param_id.has_value()) { // If we don't have a return slot, we're returning by value. Convert to a // value expression. returned_var_id = ConvertToValueExpr(context, returned_var_id); - return_slot_id = SemIR::InstId::None; } AddReturnCleanupBlockWithExpr( context, node_id, - {.expr_id = returned_var_id, .dest_id = return_slot_id}); + {.expr_id = returned_var_id, .dest_id = return_param_id}); } } // namespace Carbon::Check diff --git a/toolchain/check/return.h b/toolchain/check/return.h index 810f7f64d93d..7cf75ef7336d 100644 --- a/toolchain/check/return.h +++ b/toolchain/check/return.h @@ -14,9 +14,11 @@ namespace Carbon::Check { // return from. auto GetCurrentFunctionForReturn(Context& context) -> SemIR::Function&; -// Gets the return slot of the function that lexically encloses the current -// location. -auto GetCurrentReturnSlot(Context& context) -> SemIR::InstId; +// Gets the return parameter corresponding to `function`'s `returned var`. +// Returns None if the `returned var` doesn't correspond to a return parameter +// (e.g. because it doesn't have an in-place init representation). +auto GetReturnedVarParam(Context& context, const SemIR::Function& function) + -> SemIR::InstId; // Checks a `returned var` binding and registers it as the current `returned // var` in this scope. diff --git a/toolchain/check/testdata/array/import.carbon b/toolchain/check/testdata/array/import.carbon index 8f32adf55dfd..13a5eec42193 100644 --- a/toolchain/check/testdata/array/import.carbon +++ b/toolchain/check/testdata/array/import.carbon @@ -106,7 +106,7 @@ fn F() -> array(i32, 1) { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_15.2(%.loc6_15.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc6_12.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc6_12.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type) = "no_op"; @@ -132,6 +132,6 @@ fn F() -> array(i32, 1) { // CHECK:STDOUT: %C.ref: type = name_ref C, imports.%Main.C [concrete = constants.%C] // CHECK:STDOUT: %I.ref: type = name_ref I, imports.%Main.I [concrete = constants.%I.type] // CHECK:STDOUT: %val.ref: = name_ref val, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/array/index_not_literal.carbon b/toolchain/check/testdata/array/index_not_literal.carbon index dd1a6a0614b4..208ac0d4e2d1 100644 --- a/toolchain/check/testdata/array/index_not_literal.carbon +++ b/toolchain/check/testdata/array/index_not_literal.carbon @@ -118,7 +118,7 @@ fn F(a: array({}, 3)) -> {} { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc4_15.2: = bound_method %.loc4_15.3, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc4_15.2(%.loc4_15.3) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G() -> %i32 { @@ -171,7 +171,7 @@ fn F(a: array({}, 3)) -> {} { // CHECK:STDOUT: %F.call: init %i32 = call %F.ref(%.loc10_20.15, %.loc10_23.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc10_20.14, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc10_20.14) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type) = "no_op"; @@ -230,8 +230,8 @@ fn F(a: array({}, 3)) -> {} { // CHECK:STDOUT: %.loc6_30.2: ref %empty_struct_type = array_index %.loc6_30.1, %.loc6_24.3 // CHECK:STDOUT: %empty_struct: %empty_struct_type = struct_value () [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc6_30.3: %empty_struct_type = converted %.loc6_30.2, %empty_struct [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc6_30.4: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc6_30.4: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc6_31: init %empty_struct_type = converted %.loc6_30.3, %.loc6_30.4 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc6_31 to %return +// CHECK:STDOUT: return %.loc6_31 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/as/basics.carbon b/toolchain/check/testdata/as/basics.carbon index 1f3195def460..7b9c4c008756 100644 --- a/toolchain/check/testdata/as/basics.carbon +++ b/toolchain/check/testdata/as/basics.carbon @@ -159,16 +159,16 @@ let n: {.x: ()} = {.x = ()} as {.x = ()}; // CHECK:STDOUT: %struct: %struct_type.x.y = struct_value (%.loc6_27.2, %.loc6_27.3) [concrete = constants.%struct.005] // CHECK:STDOUT: %.loc6_29.1: %struct_type.x.y = converted %.loc6_27.1, %struct [concrete = constants.%struct.005] // CHECK:STDOUT: %.loc6_29.2: %empty_tuple.type = struct_access %.loc6_29.1, element0 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc6_29.3: ref %empty_tuple.type = struct_access %return, element0 +// CHECK:STDOUT: %.loc6_29.3: ref %empty_tuple.type = struct_access %return.param, element0 // CHECK:STDOUT: %.loc6_29.4: init %empty_tuple.type = tuple_init () to %.loc6_29.3 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc6_29.5: init %empty_tuple.type = converted %.loc6_29.2, %.loc6_29.4 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc6_29.6: %empty_tuple.type = struct_access %.loc6_29.1, element1 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc6_29.7: ref %empty_tuple.type = struct_access %return, element1 +// CHECK:STDOUT: %.loc6_29.7: ref %empty_tuple.type = struct_access %return.param, element1 // CHECK:STDOUT: %.loc6_29.8: init %empty_tuple.type = tuple_init () to %.loc6_29.7 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc6_29.9: init %empty_tuple.type = converted %.loc6_29.6, %.loc6_29.8 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc6_29.10: init %struct_type.x.y = struct_init (%.loc6_29.5, %.loc6_29.9) to %return [concrete = constants.%struct.005] +// CHECK:STDOUT: %.loc6_29.10: init %struct_type.x.y = struct_init (%.loc6_29.5, %.loc6_29.9) to %return.param [concrete = constants.%struct.005] // CHECK:STDOUT: %.loc6_48: init %struct_type.x.y = converted %.loc6_29.1, %.loc6_29.10 [concrete = constants.%struct.005] -// CHECK:STDOUT: return %.loc6_48 to %return +// CHECK:STDOUT: return %.loc6_48 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- as_type.carbon diff --git a/toolchain/check/testdata/basics/dump_sem_ir_ranges.carbon b/toolchain/check/testdata/basics/dump_sem_ir_ranges.carbon index c056d9f6ea1d..dbf00bfbd883 100644 --- a/toolchain/check/testdata/basics/dump_sem_ir_ranges.carbon +++ b/toolchain/check/testdata/basics/dump_sem_ir_ranges.carbon @@ -157,11 +157,11 @@ library "[[@TEST_NAME]]"; // CHECK:STDOUT: %B.call: init %empty_tuple.type = call %B.ref() // CHECK:STDOUT: assign %c.ref.loc19, %B.call // CHECK:STDOUT: %c.ref.loc20: ref %empty_tuple.type = name_ref c, %c -// CHECK:STDOUT: %.loc20_10: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc20_10: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc20_11: init %empty_tuple.type = converted %c.ref.loc20, %.loc20_10 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %DestroyOp.bound: = bound_method %c.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%c.var) -// CHECK:STDOUT: return %.loc20_11 to %return +// CHECK:STDOUT: return %.loc20_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- class.carbon diff --git a/toolchain/check/testdata/basics/raw_identifier.carbon b/toolchain/check/testdata/basics/raw_identifier.carbon index 00726063e03a..9f81efc2280b 100644 --- a/toolchain/check/testdata/basics/raw_identifier.carbon +++ b/toolchain/check/testdata/basics/raw_identifier.carbon @@ -103,24 +103,24 @@ fn C(r#if: ()) -> () { // CHECK:STDOUT: fn @A(%n.param: %empty_tuple.type) -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %n.ref: %empty_tuple.type = name_ref n, %n -// CHECK:STDOUT: %.loc15_10: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc15_10: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc15_13: init %empty_tuple.type = converted %n.ref, %.loc15_10 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc15_13 to %return +// CHECK:STDOUT: return %.loc15_13 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B(%n.param: %empty_tuple.type) -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %n.ref: %empty_tuple.type = name_ref n, %n -// CHECK:STDOUT: %.loc19_10: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc19_10: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc19_11: init %empty_tuple.type = converted %n.ref, %.loc19_10 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc19_11 to %return +// CHECK:STDOUT: return %.loc19_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C(%if.param: %empty_tuple.type) -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %if.ref: %empty_tuple.type = name_ref r#if, %if -// CHECK:STDOUT: %.loc23_10: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc23_10: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc23_14: init %empty_tuple.type = converted %if.ref, %.loc23_10 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc23_14 to %return +// CHECK:STDOUT: return %.loc23_14 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/basics/raw_sem_ir/one_file.carbon b/toolchain/check/testdata/basics/raw_sem_ir/one_file.carbon index 2aec33ca4780..76a250dbea96 100644 --- a/toolchain/check/testdata/basics/raw_sem_ir/one_file.carbon +++ b/toolchain/check/testdata/basics/raw_sem_ir/one_file.carbon @@ -465,7 +465,7 @@ fn Foo[T:! type](p: T*) -> (T*, ()) { // CHECK:STDOUT: inst60000048: {kind: TupleLiteral, arg0: inst_block_empty, type: type(inst60000025)} // CHECK:STDOUT: inst60000049: {kind: TupleLiteral, arg0: inst_block60000018, type: type(symbolic_constantA)} // CHECK:STDOUT: inst6000004A: {kind: RequireCompleteType, arg0: inst6000002E, type: type(inst(WitnessType))} -// CHECK:STDOUT: inst6000004B: {kind: TupleAccess, arg0: inst6000003B, arg1: element0, type: type(symbolic_constant4)} +// CHECK:STDOUT: inst6000004B: {kind: TupleAccess, arg0: inst6000003A, arg1: element0, type: type(symbolic_constant4)} // CHECK:STDOUT: inst6000004C: {kind: RequireCompleteType, arg0: inst6000001C, type: type(inst(WitnessType))} // CHECK:STDOUT: inst6000004D: {kind: ImportRefLoaded, arg0: import_ir_inst0, arg1: entity_name60000003, type: type(TypeType)} // CHECK:STDOUT: inst6000004E: {kind: InterfaceDecl, arg0: interface60000000, arg1: inst_block_empty, type: type(TypeType)} @@ -759,12 +759,12 @@ fn Foo[T:! type](p: T*) -> (T*, ()) { // CHECK:STDOUT: inst6000016E: {kind: RequireCompleteType, arg0: inst6000001C, type: type(inst(WitnessType))} // CHECK:STDOUT: inst6000016F: {kind: Call, arg0: inst6000016D, arg1: inst_block60000079, type: type(symbolic_constant4)} // CHECK:STDOUT: inst60000170: {kind: InitializeFrom, arg0: inst6000016F, arg1: inst6000004B, type: type(symbolic_constant4)} -// CHECK:STDOUT: inst60000171: {kind: TupleAccess, arg0: inst6000003B, arg1: element1, type: type(inst60000025)} +// CHECK:STDOUT: inst60000171: {kind: TupleAccess, arg0: inst6000003A, arg1: element1, type: type(inst60000025)} // CHECK:STDOUT: inst60000172: {kind: TupleInit, arg0: inst_block_empty, arg1: inst60000171, type: type(inst60000025)} // CHECK:STDOUT: inst60000173: {kind: Converted, arg0: inst60000048, arg1: inst60000172, type: type(inst60000025)} -// CHECK:STDOUT: inst60000174: {kind: TupleInit, arg0: inst_block6000007A, arg1: inst6000003B, type: type(symbolic_constantA)} +// CHECK:STDOUT: inst60000174: {kind: TupleInit, arg0: inst_block6000007A, arg1: inst6000003A, type: type(symbolic_constantA)} // CHECK:STDOUT: inst60000175: {kind: Converted, arg0: inst60000049, arg1: inst60000174, type: type(symbolic_constantA)} -// CHECK:STDOUT: inst60000176: {kind: ReturnExpr, arg0: inst60000175, arg1: inst6000003B} +// CHECK:STDOUT: inst60000176: {kind: ReturnExpr, arg0: inst60000175, arg1: inst6000003A} // CHECK:STDOUT: constant_values: // CHECK:STDOUT: values: // CHECK:STDOUT: instF: concrete_constant(instF) diff --git a/toolchain/check/testdata/basics/raw_sem_ir/one_file_with_textual_ir.carbon b/toolchain/check/testdata/basics/raw_sem_ir/one_file_with_textual_ir.carbon index 4f2944ffd902..708f578fd8b8 100644 --- a/toolchain/check/testdata/basics/raw_sem_ir/one_file_with_textual_ir.carbon +++ b/toolchain/check/testdata/basics/raw_sem_ir/one_file_with_textual_ir.carbon @@ -88,15 +88,15 @@ fn Foo(n: ()) -> ((), ()) { // CHECK:STDOUT: inst6000002D: {kind: NameRef, arg0: name1, arg1: inst60000014, type: type(inst60000010)} // CHECK:STDOUT: inst6000002E: {kind: TupleLiteral, arg0: inst_block_empty, type: type(inst60000010)} // CHECK:STDOUT: inst6000002F: {kind: TupleLiteral, arg0: inst_block6000000F, type: type(inst6000001A)} -// CHECK:STDOUT: inst60000030: {kind: TupleAccess, arg0: inst60000029, arg1: element0, type: type(inst60000010)} +// CHECK:STDOUT: inst60000030: {kind: TupleAccess, arg0: inst60000028, arg1: element0, type: type(inst60000010)} // CHECK:STDOUT: inst60000031: {kind: TupleInit, arg0: inst_block60000010, arg1: inst60000030, type: type(inst60000010)} // CHECK:STDOUT: inst60000032: {kind: Converted, arg0: inst6000002D, arg1: inst60000031, type: type(inst60000010)} -// CHECK:STDOUT: inst60000033: {kind: TupleAccess, arg0: inst60000029, arg1: element1, type: type(inst60000010)} +// CHECK:STDOUT: inst60000033: {kind: TupleAccess, arg0: inst60000028, arg1: element1, type: type(inst60000010)} // CHECK:STDOUT: inst60000034: {kind: TupleInit, arg0: inst_block_empty, arg1: inst60000033, type: type(inst60000010)} // CHECK:STDOUT: inst60000035: {kind: Converted, arg0: inst6000002E, arg1: inst60000034, type: type(inst60000010)} -// CHECK:STDOUT: inst60000036: {kind: TupleInit, arg0: inst_block60000011, arg1: inst60000029, type: type(inst6000001A)} +// CHECK:STDOUT: inst60000036: {kind: TupleInit, arg0: inst_block60000011, arg1: inst60000028, type: type(inst6000001A)} // CHECK:STDOUT: inst60000037: {kind: Converted, arg0: inst6000002F, arg1: inst60000036, type: type(inst6000001A)} -// CHECK:STDOUT: inst60000038: {kind: ReturnExpr, arg0: inst60000037, arg1: inst60000029} +// CHECK:STDOUT: inst60000038: {kind: ReturnExpr, arg0: inst60000037, arg1: inst60000028} // CHECK:STDOUT: constant_values: // CHECK:STDOUT: values: // CHECK:STDOUT: instF: concrete_constant(instF) @@ -250,14 +250,14 @@ fn Foo(n: ()) -> ((), ()) { // CHECK:STDOUT: %n.ref: %empty_tuple.type = name_ref n, %n // CHECK:STDOUT: %.loc17_15.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc17_16.1: %tuple.type = tuple_literal (%n.ref, %.loc17_15.1) -// CHECK:STDOUT: %tuple.elem0: ref %empty_tuple.type = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0: ref %empty_tuple.type = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc17_11: init %empty_tuple.type = tuple_init () to %tuple.elem0 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc17_16.2: init %empty_tuple.type = converted %n.ref, %.loc17_11 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %tuple.elem1: ref %empty_tuple.type = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1: ref %empty_tuple.type = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc17_15.2: init %empty_tuple.type = tuple_init () to %tuple.elem1 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc17_16.3: init %empty_tuple.type = converted %.loc17_15.1, %.loc17_15.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc17_16.4: init %tuple.type = tuple_init (%.loc17_16.2, %.loc17_16.3) to %return [concrete = constants.%tuple] +// CHECK:STDOUT: %.loc17_16.4: init %tuple.type = tuple_init (%.loc17_16.2, %.loc17_16.3) to %return.param [concrete = constants.%tuple] // CHECK:STDOUT: %.loc17_17: init %tuple.type = converted %.loc17_16.1, %.loc17_16.4 [concrete = constants.%tuple] -// CHECK:STDOUT: return %.loc17_17 to %return +// CHECK:STDOUT: return %.loc17_17 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/add.carbon b/toolchain/check/testdata/builtins/float/add.carbon index 2de6f0d316f3..58bd89f1dea0 100644 --- a/toolchain/check/testdata/builtins/float/add.carbon +++ b/toolchain/check/testdata/builtins/float/add.carbon @@ -86,7 +86,7 @@ fn AddLiteral(a: Literal(), b: Literal()) -> Literal() = "float.add"; // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Add.call: init %f64.d77 = call %Add.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Add.call to %return +// CHECK:STDOUT: return %Add.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/float/div.carbon b/toolchain/check/testdata/builtins/float/div.carbon index 23a49aca1bea..6bea002314ef 100644 --- a/toolchain/check/testdata/builtins/float/div.carbon +++ b/toolchain/check/testdata/builtins/float/div.carbon @@ -97,7 +97,7 @@ fn DivLiteral(a: Literal(), b: Literal()) -> Literal() = "float.div"; // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Div.call: init %f64.d77 = call %Div.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Div.call to %return +// CHECK:STDOUT: return %Div.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/float/eq.carbon b/toolchain/check/testdata/builtins/float/eq.carbon index 2b62401af654..efea3125d595 100644 --- a/toolchain/check/testdata/builtins/float/eq.carbon +++ b/toolchain/check/testdata/builtins/float/eq.carbon @@ -66,6 +66,6 @@ fn Eq(a: Core.FloatLiteral(), b: Core.FloatLiteral()) -> bool = "float.eq"; // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Eq.call: init bool = call %Eq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Eq.call to %return +// CHECK:STDOUT: return %Eq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/greater.carbon b/toolchain/check/testdata/builtins/float/greater.carbon index d8b97c52901c..5a8dbd119ff0 100644 --- a/toolchain/check/testdata/builtins/float/greater.carbon +++ b/toolchain/check/testdata/builtins/float/greater.carbon @@ -50,6 +50,6 @@ fn RuntimeCallIsValid(a: f64, b: f64) -> bool { // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Greater.call: init bool = call %Greater.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Greater.call to %return +// CHECK:STDOUT: return %Greater.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/greater_eq.carbon b/toolchain/check/testdata/builtins/float/greater_eq.carbon index 6898fe221d60..eec9311a9539 100644 --- a/toolchain/check/testdata/builtins/float/greater_eq.carbon +++ b/toolchain/check/testdata/builtins/float/greater_eq.carbon @@ -50,6 +50,6 @@ fn RuntimeCallIsValid(a: f64, b: f64) -> bool { // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %GreaterEq.call: init bool = call %GreaterEq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %GreaterEq.call to %return +// CHECK:STDOUT: return %GreaterEq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/less.carbon b/toolchain/check/testdata/builtins/float/less.carbon index 684f48f5c532..a28569ab1405 100644 --- a/toolchain/check/testdata/builtins/float/less.carbon +++ b/toolchain/check/testdata/builtins/float/less.carbon @@ -50,6 +50,6 @@ fn RuntimeCallIsValid(a: f64, b: f64) -> bool { // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Less.call: init bool = call %Less.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Less.call to %return +// CHECK:STDOUT: return %Less.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/less_eq.carbon b/toolchain/check/testdata/builtins/float/less_eq.carbon index 1efd641c0bfc..2f2174130f73 100644 --- a/toolchain/check/testdata/builtins/float/less_eq.carbon +++ b/toolchain/check/testdata/builtins/float/less_eq.carbon @@ -60,6 +60,6 @@ fn LessEq(a: Core.FloatLiteral(), b: Core.FloatLiteral()) -> bool = "float.less_ // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %LessEq.call: init bool = call %LessEq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %LessEq.call to %return +// CHECK:STDOUT: return %LessEq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/make_type.carbon b/toolchain/check/testdata/builtins/float/make_type.carbon index 14fb85414818..113080e72e5d 100644 --- a/toolchain/check/testdata/builtins/float/make_type.carbon +++ b/toolchain/check/testdata/builtins/float/make_type.carbon @@ -76,6 +76,6 @@ var dyn: Float(dyn_size); // CHECK:STDOUT: %Float.ref: %Float.type = name_ref Float, imports.%Main.Float [concrete = constants.%Float] // CHECK:STDOUT: %dyn_size.ref: %i32 = name_ref dyn_size, %dyn_size // CHECK:STDOUT: %Float.call: init type = call %Float.ref(%dyn_size.ref) -// CHECK:STDOUT: return %Float.call to %return +// CHECK:STDOUT: return %Float.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/mul.carbon b/toolchain/check/testdata/builtins/float/mul.carbon index 0705dc23c3ed..131ae3e86a3d 100644 --- a/toolchain/check/testdata/builtins/float/mul.carbon +++ b/toolchain/check/testdata/builtins/float/mul.carbon @@ -95,7 +95,7 @@ fn MulLiteral(a: Literal(), b: Literal()) -> Literal() = "float.mul"; // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Mul.call: init %f64.d77 = call %Mul.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Mul.call to %return +// CHECK:STDOUT: return %Mul.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/float/negate.carbon b/toolchain/check/testdata/builtins/float/negate.carbon index 396086afa889..22f2c942fbdc 100644 --- a/toolchain/check/testdata/builtins/float/negate.carbon +++ b/toolchain/check/testdata/builtins/float/negate.carbon @@ -83,7 +83,7 @@ fn RuntimeCallIsValidBadReturnType(a: f64) -> bool { // CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [concrete = constants.%Negate] // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %Negate.call: init %f64.d77 = call %Negate.ref(%a.ref) -// CHECK:STDOUT: return %Negate.call to %return +// CHECK:STDOUT: return %Negate.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/float/neq.carbon b/toolchain/check/testdata/builtins/float/neq.carbon index 4f80b00235c7..7892bc4db8e5 100644 --- a/toolchain/check/testdata/builtins/float/neq.carbon +++ b/toolchain/check/testdata/builtins/float/neq.carbon @@ -58,6 +58,6 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq"; // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Neq.call: init bool = call %Neq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Neq.call to %return +// CHECK:STDOUT: return %Neq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/float/sub.carbon b/toolchain/check/testdata/builtins/float/sub.carbon index 5b8d16428204..e57629dd783a 100644 --- a/toolchain/check/testdata/builtins/float/sub.carbon +++ b/toolchain/check/testdata/builtins/float/sub.carbon @@ -95,7 +95,7 @@ fn SubLiteral(a: Literal(), b: Literal()) -> Literal() = "float.sub"; // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %b.ref: %f64.d77 = name_ref b, %b // CHECK:STDOUT: %Sub.call: init %f64.d77 = call %Sub.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Sub.call to %return +// CHECK:STDOUT: return %Sub.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/and.carbon b/toolchain/check/testdata/builtins/int/and.carbon index 9e1a969dc214..ad60729dbc93 100644 --- a/toolchain/check/testdata/builtins/int/and.carbon +++ b/toolchain/check/testdata/builtins/int/and.carbon @@ -141,7 +141,7 @@ fn Test(n: Core.IntLiteral()) { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %And.call: init %i32 = call %And.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %And.call to %return +// CHECK:STDOUT: return %And.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/complement.carbon b/toolchain/check/testdata/builtins/int/complement.carbon index a61a42ccb5e5..4f83440bef40 100644 --- a/toolchain/check/testdata/builtins/int/complement.carbon +++ b/toolchain/check/testdata/builtins/int/complement.carbon @@ -79,7 +79,7 @@ fn F(a: Core.IntLiteral()) -> Core.IntLiteral() { // CHECK:STDOUT: %Complement.ref: %Complement.type = name_ref Complement, file.%Complement.decl [concrete = constants.%Complement] // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %Complement.call: init %i32 = call %Complement.ref(%a.ref) -// CHECK:STDOUT: return %Complement.call to %return +// CHECK:STDOUT: return %Complement.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/convert.carbon b/toolchain/check/testdata/builtins/int/convert.carbon index 64ae546a701d..a23914b1ef2c 100644 --- a/toolchain/check/testdata/builtins/int/convert.carbon +++ b/toolchain/check/testdata/builtins/int/convert.carbon @@ -278,7 +278,7 @@ let convert_not_constant: i16 = IntLiteralToInt16(not_constant); // CHECK:STDOUT: %Int32ToUint32.ref: %Int32ToUint32.type = name_ref Int32ToUint32, imports.%Main.Int32ToUint32 [concrete = constants.%Int32ToUint32] // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %Int32ToUint32.call: init %u32 = call %Int32ToUint32.ref(%a.ref) -// CHECK:STDOUT: return %Int32ToUint32.call to %return +// CHECK:STDOUT: return %Int32ToUint32.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Narrowing(%a.param: %i32) -> %i16 { @@ -286,7 +286,7 @@ let convert_not_constant: i16 = IntLiteralToInt16(not_constant); // CHECK:STDOUT: %Int32ToInt16.ref: %Int32ToInt16.type = name_ref Int32ToInt16, imports.%Main.Int32ToInt16 [concrete = constants.%Int32ToInt16] // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %Int32ToInt16.call: init %i16 = call %Int32ToInt16.ref(%a.ref) -// CHECK:STDOUT: return %Int32ToInt16.call to %return +// CHECK:STDOUT: return %Int32ToInt16.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Widening(%a.param: %i32) -> %i64 { @@ -294,6 +294,6 @@ let convert_not_constant: i16 = IntLiteralToInt16(not_constant); // CHECK:STDOUT: %Int32ToInt64.ref: %Int32ToInt64.type = name_ref Int32ToInt64, imports.%Main.Int32ToInt64 [concrete = constants.%Int32ToInt64] // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %Int32ToInt64.call: init %i64 = call %Int32ToInt64.ref(%a.ref) -// CHECK:STDOUT: return %Int32ToInt64.call to %return +// CHECK:STDOUT: return %Int32ToInt64.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/eq.carbon b/toolchain/check/testdata/builtins/int/eq.carbon index 1ee86c28d6eb..dfade8d08522 100644 --- a/toolchain/check/testdata/builtins/int/eq.carbon +++ b/toolchain/check/testdata/builtins/int/eq.carbon @@ -125,6 +125,6 @@ fn Test(n: Core.IntLiteral()) { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Eq.call: init bool = call %Eq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Eq.call to %return +// CHECK:STDOUT: return %Eq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/greater.carbon b/toolchain/check/testdata/builtins/int/greater.carbon index 5ac5333a9ec5..0a510dadf49e 100644 --- a/toolchain/check/testdata/builtins/int/greater.carbon +++ b/toolchain/check/testdata/builtins/int/greater.carbon @@ -50,6 +50,6 @@ fn RuntimeCallIsValid(a: i32, b: i32) -> bool { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Greater.call: init bool = call %Greater.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Greater.call to %return +// CHECK:STDOUT: return %Greater.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/greater_eq.carbon b/toolchain/check/testdata/builtins/int/greater_eq.carbon index 596b0089da74..356baa086ebe 100644 --- a/toolchain/check/testdata/builtins/int/greater_eq.carbon +++ b/toolchain/check/testdata/builtins/int/greater_eq.carbon @@ -88,6 +88,6 @@ fn F() { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %GreaterEq.call: init bool = call %GreaterEq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %GreaterEq.call to %return +// CHECK:STDOUT: return %GreaterEq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/left_shift.carbon b/toolchain/check/testdata/builtins/int/left_shift.carbon index 0003f1e70468..6d9f021ecd73 100644 --- a/toolchain/check/testdata/builtins/int/left_shift.carbon +++ b/toolchain/check/testdata/builtins/int/left_shift.carbon @@ -246,7 +246,7 @@ let bad4: Core.IntLiteral() = LeftShiftOfLit(12, an_i32); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %LeftShift.call: init %i32 = call %LeftShift.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %LeftShift.call to %return +// CHECK:STDOUT: return %LeftShift.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- u32.carbon @@ -268,6 +268,6 @@ let bad4: Core.IntLiteral() = LeftShiftOfLit(12, an_i32); // CHECK:STDOUT: %a.ref: %u32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %LeftShift.call: init %u32 = call %LeftShift.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %LeftShift.call to %return +// CHECK:STDOUT: return %LeftShift.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/less.carbon b/toolchain/check/testdata/builtins/int/less.carbon index 0eea3a79f2b0..e948b9a27389 100644 --- a/toolchain/check/testdata/builtins/int/less.carbon +++ b/toolchain/check/testdata/builtins/int/less.carbon @@ -50,6 +50,6 @@ fn RuntimeCallIsValid(a: i32, b: i32) -> bool { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Less.call: init bool = call %Less.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Less.call to %return +// CHECK:STDOUT: return %Less.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/less_eq.carbon b/toolchain/check/testdata/builtins/int/less_eq.carbon index 87ab63fca95f..0add556863c4 100644 --- a/toolchain/check/testdata/builtins/int/less_eq.carbon +++ b/toolchain/check/testdata/builtins/int/less_eq.carbon @@ -123,6 +123,6 @@ fn Test(n: Core.IntLiteral()) { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %LessEq.call: init bool = call %LessEq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %LessEq.call to %return +// CHECK:STDOUT: return %LessEq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/neq.carbon b/toolchain/check/testdata/builtins/int/neq.carbon index 2e3019f04df2..139bd4862390 100644 --- a/toolchain/check/testdata/builtins/int/neq.carbon +++ b/toolchain/check/testdata/builtins/int/neq.carbon @@ -46,6 +46,6 @@ fn RuntimeCallIsValid(a: i32, b: i32) -> bool { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Neq.call: init bool = call %Neq.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Neq.call to %return +// CHECK:STDOUT: return %Neq.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/or.carbon b/toolchain/check/testdata/builtins/int/or.carbon index 2c1856edad53..7c0accb91270 100644 --- a/toolchain/check/testdata/builtins/int/or.carbon +++ b/toolchain/check/testdata/builtins/int/or.carbon @@ -41,7 +41,7 @@ fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Or.call: init %i32 = call %Or.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Or.call to %return +// CHECK:STDOUT: return %Or.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/right_shift.carbon b/toolchain/check/testdata/builtins/int/right_shift.carbon index 4d014e3a800a..d2adb0b05fe8 100644 --- a/toolchain/check/testdata/builtins/int/right_shift.carbon +++ b/toolchain/check/testdata/builtins/int/right_shift.carbon @@ -150,7 +150,7 @@ let negative_lit_zero: Core.IntLiteral() = RightShiftLit(0, -1); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %RightShift.call: init %i32 = call %RightShift.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %RightShift.call to %return +// CHECK:STDOUT: return %RightShift.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- u32.carbon @@ -172,6 +172,6 @@ let negative_lit_zero: Core.IntLiteral() = RightShiftLit(0, -1); // CHECK:STDOUT: %a.ref: %u32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %RightShift.call: init %u32 = call %RightShift.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %RightShift.call to %return +// CHECK:STDOUT: return %RightShift.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/sadd.carbon b/toolchain/check/testdata/builtins/int/sadd.carbon index d3b99bc7fd63..b37cc1497736 100644 --- a/toolchain/check/testdata/builtins/int/sadd.carbon +++ b/toolchain/check/testdata/builtins/int/sadd.carbon @@ -179,6 +179,6 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Add.call: init %i32 = call %Add.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Add.call to %return +// CHECK:STDOUT: return %Add.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/sdiv.carbon b/toolchain/check/testdata/builtins/int/sdiv.carbon index cb099913ede1..69263e1d60b9 100644 --- a/toolchain/check/testdata/builtins/int/sdiv.carbon +++ b/toolchain/check/testdata/builtins/int/sdiv.carbon @@ -110,7 +110,7 @@ let d: Core.IntLiteral() = DivLit(0, 0); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Div.call: init %i32 = call %Div.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Div.call to %return +// CHECK:STDOUT: return %Div.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/smod.carbon b/toolchain/check/testdata/builtins/int/smod.carbon index 778c692a241c..de9f284f6791 100644 --- a/toolchain/check/testdata/builtins/int/smod.carbon +++ b/toolchain/check/testdata/builtins/int/smod.carbon @@ -85,7 +85,7 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Mod.call: init %i32 = call %Mod.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Mod.call to %return +// CHECK:STDOUT: return %Mod.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/smul.carbon b/toolchain/check/testdata/builtins/int/smul.carbon index bca1668e18f0..42f361b7c17c 100644 --- a/toolchain/check/testdata/builtins/int/smul.carbon +++ b/toolchain/check/testdata/builtins/int/smul.carbon @@ -92,6 +92,6 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Mul.call: init %i32 = call %Mul.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Mul.call to %return +// CHECK:STDOUT: return %Mul.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtins/int/snegate.carbon b/toolchain/check/testdata/builtins/int/snegate.carbon index 892ba0ede682..5dbb32ba4932 100644 --- a/toolchain/check/testdata/builtins/int/snegate.carbon +++ b/toolchain/check/testdata/builtins/int/snegate.carbon @@ -152,7 +152,7 @@ let b: i32 = Negate(-0x8000_0000); // CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [concrete = constants.%Negate] // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %Negate.call: init %i32 = call %Negate.ref(%a.ref) -// CHECK:STDOUT: return %Negate.call to %return +// CHECK:STDOUT: return %Negate.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/ssub.carbon b/toolchain/check/testdata/builtins/int/ssub.carbon index 1e2e63c5d51a..6d9c0b3c8d6c 100644 --- a/toolchain/check/testdata/builtins/int/ssub.carbon +++ b/toolchain/check/testdata/builtins/int/ssub.carbon @@ -57,7 +57,7 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Sub.call: init %i32 = call %Sub.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Sub.call to %return +// CHECK:STDOUT: return %Sub.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/uadd.carbon b/toolchain/check/testdata/builtins/int/uadd.carbon index 0b969d0c5a9c..b8d96f7ec01c 100644 --- a/toolchain/check/testdata/builtins/int/uadd.carbon +++ b/toolchain/check/testdata/builtins/int/uadd.carbon @@ -128,7 +128,7 @@ let b: i32 = Add(0x7FFFFFFF, 1); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Add.call: init %i32 = call %Add.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Add.call to %return +// CHECK:STDOUT: return %Add.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/udiv.carbon b/toolchain/check/testdata/builtins/int/udiv.carbon index a68b2a59f955..95978b147880 100644 --- a/toolchain/check/testdata/builtins/int/udiv.carbon +++ b/toolchain/check/testdata/builtins/int/udiv.carbon @@ -78,7 +78,7 @@ let b: i32 = Div(0, 0); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Div.call: init %i32 = call %Div.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Div.call to %return +// CHECK:STDOUT: return %Div.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/umod.carbon b/toolchain/check/testdata/builtins/int/umod.carbon index 15540d8623b5..84667b260ee3 100644 --- a/toolchain/check/testdata/builtins/int/umod.carbon +++ b/toolchain/check/testdata/builtins/int/umod.carbon @@ -80,7 +80,7 @@ let b: i32 = Mod(0, 0); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Mod.call: init %i32 = call %Mod.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Mod.call to %return +// CHECK:STDOUT: return %Mod.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/umul.carbon b/toolchain/check/testdata/builtins/int/umul.carbon index 2085bda64686..87fb722dce84 100644 --- a/toolchain/check/testdata/builtins/int/umul.carbon +++ b/toolchain/check/testdata/builtins/int/umul.carbon @@ -52,7 +52,7 @@ let b: i32 = Mul(0x8000, 0x10000); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Mul.call: init %i32 = call %Mul.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Mul.call to %return +// CHECK:STDOUT: return %Mul.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/unegate.carbon b/toolchain/check/testdata/builtins/int/unegate.carbon index a97ce9c31043..ecc44d9e652b 100644 --- a/toolchain/check/testdata/builtins/int/unegate.carbon +++ b/toolchain/check/testdata/builtins/int/unegate.carbon @@ -137,7 +137,7 @@ fn F() { // CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [concrete = constants.%Negate] // CHECK:STDOUT: %a.ref: %u32 = name_ref a, %a // CHECK:STDOUT: %Negate.call: init %u32 = call %Negate.ref(%a.ref) -// CHECK:STDOUT: return %Negate.call to %return +// CHECK:STDOUT: return %Negate.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/usub.carbon b/toolchain/check/testdata/builtins/int/usub.carbon index 77e6860eb9df..b630cf2a232d 100644 --- a/toolchain/check/testdata/builtins/int/usub.carbon +++ b/toolchain/check/testdata/builtins/int/usub.carbon @@ -53,7 +53,7 @@ let c: i32 = Sub(Sub(0, 0x7FFFFFFF), 2); // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Sub.call: init %i32 = call %Sub.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Sub.call to %return +// CHECK:STDOUT: return %Sub.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/int/xor.carbon b/toolchain/check/testdata/builtins/int/xor.carbon index 0ffce563c609..00cc78264e8d 100644 --- a/toolchain/check/testdata/builtins/int/xor.carbon +++ b/toolchain/check/testdata/builtins/int/xor.carbon @@ -41,7 +41,7 @@ fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Xor.call: init %i32 = call %Xor.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Xor.call to %return +// CHECK:STDOUT: return %Xor.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/builtins/pointer/is_null.carbon b/toolchain/check/testdata/builtins/pointer/is_null.carbon index 1d95d3cbf331..b2081e3af595 100644 --- a/toolchain/check/testdata/builtins/pointer/is_null.carbon +++ b/toolchain/check/testdata/builtins/pointer/is_null.carbon @@ -171,7 +171,7 @@ fn NotPointer(p: MakeUnformed({})) -> bool = "pointer.is_null"; // CHECK:STDOUT: %IsNullEmptyStruct.ref: %IsNullEmptyStruct.type = name_ref IsNullEmptyStruct, file.%IsNullEmptyStruct.decl [concrete = constants.%IsNullEmptyStruct] // CHECK:STDOUT: %s.ref: %.b2d = name_ref s, %s // CHECK:STDOUT: %IsNullEmptyStruct.call: init bool = call %IsNullEmptyStruct.ref(%s.ref) -// CHECK:STDOUT: return %IsNullEmptyStruct.call to %return +// CHECK:STDOUT: return %IsNullEmptyStruct.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestC(%c.param: %.edf) -> bool { @@ -179,7 +179,7 @@ fn NotPointer(p: MakeUnformed({})) -> bool = "pointer.is_null"; // CHECK:STDOUT: %IsNullC.ref: %IsNullC.type = name_ref IsNullC, file.%IsNullC.decl [concrete = constants.%IsNullC] // CHECK:STDOUT: %c.ref: %.edf = name_ref c, %c // CHECK:STDOUT: %IsNullC.call: init bool = call %IsNullC.ref(%c.ref) -// CHECK:STDOUT: return %IsNullC.call to %return +// CHECK:STDOUT: return %IsNullC.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- call_generic.carbon @@ -269,7 +269,7 @@ fn NotPointer(p: MakeUnformed({})) -> bool = "pointer.is_null"; // CHECK:STDOUT: %s.ref: %.b2d = name_ref s, %s // CHECK:STDOUT: %IsNull.specific_fn: = specific_function %IsNull.ref, @IsNull(constants.%empty_struct_type) [concrete = constants.%IsNull.specific_fn.34e] // CHECK:STDOUT: %IsNull.call: init bool = call %IsNull.specific_fn(%s.ref) -// CHECK:STDOUT: return %IsNull.call to %return +// CHECK:STDOUT: return %IsNull.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestC(%c.param: %.edf) -> bool { @@ -278,6 +278,6 @@ fn NotPointer(p: MakeUnformed({})) -> bool = "pointer.is_null"; // CHECK:STDOUT: %c.ref: %.edf = name_ref c, %c // CHECK:STDOUT: %IsNull.specific_fn: = specific_function %IsNull.ref, @IsNull(constants.%C) [concrete = constants.%IsNull.specific_fn.b1f] // CHECK:STDOUT: %IsNull.call: init bool = call %IsNull.specific_fn(%c.ref) -// CHECK:STDOUT: return %IsNull.call to %return +// CHECK:STDOUT: return %IsNull.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/access_modifers.carbon b/toolchain/check/testdata/class/access_modifers.carbon index 46656cb85594..7ea755fa45c1 100644 --- a/toolchain/check/testdata/class/access_modifers.carbon +++ b/toolchain/check/testdata/class/access_modifers.carbon @@ -286,7 +286,7 @@ class A { // CHECK:STDOUT: %bound_method.loc9_13.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.d2e] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc9_13.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc9: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc9 to %return +// CHECK:STDOUT: return %.loc9 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Circle.Make() -> %return.param: %Circle { @@ -299,11 +299,11 @@ class A { // CHECK:STDOUT: %bound_method.loc13_24.2: = bound_method %int_5, %specific_fn [concrete = constants.%bound_method.e9d] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc13_24.2(%int_5) [concrete = constants.%int_5.0f6] // CHECK:STDOUT: %.loc13_24.2: init %i32 = converted %int_5, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_5.0f6] -// CHECK:STDOUT: %.loc13_24.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc13_24.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc13_24.4: init %i32 = initialize_from %.loc13_24.2 to %.loc13_24.3 [concrete = constants.%int_5.0f6] -// CHECK:STDOUT: %.loc13_24.5: init %Circle = class_init (%.loc13_24.4), %return [concrete = constants.%Circle.val] +// CHECK:STDOUT: %.loc13_24.5: init %Circle = class_init (%.loc13_24.4), %return.param [concrete = constants.%Circle.val] // CHECK:STDOUT: %.loc13_25: init %Circle = converted %.loc13_24.1, %.loc13_24.5 [concrete = constants.%Circle.val] -// CHECK:STDOUT: return %.loc13_25 to %return +// CHECK:STDOUT: return %.loc13_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Run() { @@ -550,7 +550,7 @@ class A { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_16.2: = bound_method %.loc8_16.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc8_16.2(%.loc8_16.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Circle.SomeInternalFunction() -> %i32 { @@ -562,7 +562,7 @@ class A { // CHECK:STDOUT: %bound_method.loc12_13.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc12_13.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc12: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc12 to %return +// CHECK:STDOUT: return %.loc12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Circle.Compute(%self.param: %Circle) -> %i32 { @@ -570,7 +570,7 @@ class A { // CHECK:STDOUT: %self.ref: %Circle = name_ref self, %self // CHECK:STDOUT: %SomeInternalFunction.ref: %Circle.SomeInternalFunction.type = name_ref SomeInternalFunction, @Circle.%Circle.SomeInternalFunction.decl [concrete = constants.%Circle.SomeInternalFunction] // CHECK:STDOUT: %Circle.SomeInternalFunction.call: init %i32 = call %SomeInternalFunction.ref() -// CHECK:STDOUT: return %Circle.SomeInternalFunction.call to %return +// CHECK:STDOUT: return %Circle.SomeInternalFunction.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- public_global_access.carbon diff --git a/toolchain/check/testdata/class/adapter/adapt_copy.carbon b/toolchain/check/testdata/class/adapter/adapt_copy.carbon index bd4953e85ed2..c2bc052c7f58 100644 --- a/toolchain/check/testdata/class/adapter/adapt_copy.carbon +++ b/toolchain/check/testdata/class/adapter/adapt_copy.carbon @@ -300,7 +300,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %.loc24: %AdaptCopyable = acquire_value %d.ref // CHECK:STDOUT: %DestroyOp.bound: = bound_method %d.var, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%d.var) -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc16(%self.param: %AdaptCopyable) = "no_op"; @@ -338,7 +338,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %d.ref: ref %tuple.type.d78 = name_ref d, %d // CHECK:STDOUT: %tuple.elem0.loc43_10.1: ref %AdaptCopyable = tuple_access %d.ref, element0 // CHECK:STDOUT: %.loc43_10.1: %AdaptCopyable = acquire_value %tuple.elem0.loc43_10.1 -// CHECK:STDOUT: %tuple.elem0.loc43_10.2: ref %AdaptCopyable = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0.loc43_10.2: ref %AdaptCopyable = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc43_10.2: init %AdaptCopyable = initialize_from to %tuple.elem0.loc43_10.2 [concrete = ] // CHECK:STDOUT: %tuple.elem1.loc43_10.1: ref %u32 = tuple_access %d.ref, element1 // CHECK:STDOUT: %.loc43_10.3: %u32 = acquire_value %tuple.elem1.loc43_10.1 @@ -347,13 +347,13 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc43: = specific_function %impl.elem0.loc43, @UInt.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%UInt.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc43_10.2: = bound_method %.loc43_10.3, %specific_fn.loc43 // CHECK:STDOUT: %UInt.as.Copy.impl.Op.call.loc43: init %u32 = call %bound_method.loc43_10.2(%.loc43_10.3) -// CHECK:STDOUT: %tuple.elem1.loc43_10.2: ref %u32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1.loc43_10.2: ref %u32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc43_10.4: init %u32 = initialize_from %UInt.as.Copy.impl.Op.call.loc43 to %tuple.elem1.loc43_10.2 -// CHECK:STDOUT: %.loc43_10.5: init %tuple.type.d78 = tuple_init (%.loc43_10.2, %.loc43_10.4) to %return +// CHECK:STDOUT: %.loc43_10.5: init %tuple.type.d78 = tuple_init (%.loc43_10.2, %.loc43_10.4) to %return.param // CHECK:STDOUT: %.loc43_11: init %tuple.type.d78 = converted %d.ref, %.loc43_10.5 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %d.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%d.var) -// CHECK:STDOUT: return %.loc43_11 to %return +// CHECK:STDOUT: return %.loc43_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc35(%self.param: %tuple.type.d78) = "no_op"; @@ -534,7 +534,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc10_11.1: = specific_function %impl.elem0.loc10_11.1, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc10_11.2: = bound_method %.loc10_11.2, %specific_fn.loc10_11.1 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc10_11.1: init %i32 = call %bound_method.loc10_11.2(%.loc10_11.2) -// CHECK:STDOUT: %.loc10_11.3: ref %tuple.type.d07 = as_compatible %return +// CHECK:STDOUT: %.loc10_11.3: ref %tuple.type.d07 = as_compatible %return.param // CHECK:STDOUT: %tuple.elem0.loc10_11.2: ref %i32 = tuple_access %.loc10_11.3, element0 // CHECK:STDOUT: %.loc10_11.4: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc10_11.1 to %tuple.elem0.loc10_11.2 // CHECK:STDOUT: %tuple.elem1.loc10_11.1: ref %i32 = tuple_access %.loc10_11.1, element1 @@ -551,7 +551,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %.loc10_11.9: init %AdaptTuple = converted %d.ref, %.loc10_11.8 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %d.var, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%d.var) -// CHECK:STDOUT: return %.loc10_11.9 to %return +// CHECK:STDOUT: return %.loc10_11.9 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc9(%self.param: %AdaptTuple) = "no_op"; @@ -616,7 +616,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc15_10.1: = specific_function %impl.elem0.loc15_10.1, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_10.2: = bound_method %.loc15_10.2, %specific_fn.loc15_10.1 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc15_10.1: init %i32 = call %bound_method.loc15_10.2(%.loc15_10.2) -// CHECK:STDOUT: %tuple.elem0.loc15_10.3: ref %AdaptTuple = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0.loc15_10.3: ref %AdaptTuple = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc15_10.3: ref %tuple.type.d07 = as_compatible %tuple.elem0.loc15_10.3 // CHECK:STDOUT: %tuple.elem0.loc15_10.4: ref %i32 = tuple_access %.loc15_10.3, element0 // CHECK:STDOUT: %.loc15_10.4: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc15_10.1 to %tuple.elem0.loc15_10.4 @@ -639,13 +639,13 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc15_10.3: = specific_function %impl.elem0.loc15_10.3, @UInt.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%UInt.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_10.6: = bound_method %.loc15_10.10, %specific_fn.loc15_10.3 // CHECK:STDOUT: %UInt.as.Copy.impl.Op.call.loc15: init %u32 = call %bound_method.loc15_10.6(%.loc15_10.10) -// CHECK:STDOUT: %tuple.elem1.loc15_10.4: ref %u32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1.loc15_10.4: ref %u32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc15_10.11: init %u32 = initialize_from %UInt.as.Copy.impl.Op.call.loc15 to %tuple.elem1.loc15_10.4 -// CHECK:STDOUT: %.loc15_10.12: init %tuple.type.3c7 = tuple_init (%.loc15_10.9, %.loc15_10.11) to %return +// CHECK:STDOUT: %.loc15_10.12: init %tuple.type.3c7 = tuple_init (%.loc15_10.9, %.loc15_10.11) to %return.param // CHECK:STDOUT: %.loc15_11: init %tuple.type.3c7 = converted %d.ref, %.loc15_10.12 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %d.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%d.var) -// CHECK:STDOUT: return %.loc15_11 to %return +// CHECK:STDOUT: return %.loc15_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc14(%self.param: %tuple.type.3c7) = "no_op"; @@ -739,7 +739,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %.loc28: %AdaptNoncopyable = acquire_value %b.ref // CHECK:STDOUT: %DestroyOp.bound: = bound_method %b.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%b.var) -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %AdaptNoncopyable) = "no_op"; @@ -877,14 +877,14 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc34: = specific_function %impl.elem0.loc34, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc34_11.2: = bound_method %.loc34_11.2, %specific_fn.loc34 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc34: init %i32 = call %bound_method.loc34_11.2(%.loc34_11.2) -// CHECK:STDOUT: %.loc34_11.3: ref %tuple.type.7f9 = as_compatible %return +// CHECK:STDOUT: %.loc34_11.3: ref %tuple.type.7f9 = as_compatible %return.param // CHECK:STDOUT: %tuple.elem0.loc34_11.2: ref %i32 = tuple_access %.loc34_11.3, element0 // CHECK:STDOUT: %.loc34_11.4: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc34 to %tuple.elem0.loc34_11.2 // CHECK:STDOUT: %tuple.elem1.loc34: ref %Noncopyable = tuple_access %.loc34_11.1, element1 // CHECK:STDOUT: %.loc34_11.5: %Noncopyable = acquire_value %tuple.elem1.loc34 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %b.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%b.var) -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %AdaptNoncopyableIndirect) = "no_op"; @@ -1063,7 +1063,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc10_11.1: = specific_function %impl.elem0.loc10_11.1, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc10_11.2: = bound_method %.loc10_11.3, %specific_fn.loc10_11.1 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc10_11.1: init %i32 = call %bound_method.loc10_11.2(%.loc10_11.3) -// CHECK:STDOUT: %.loc10_11.4: ref %struct_type.e.f = as_compatible %return +// CHECK:STDOUT: %.loc10_11.4: ref %struct_type.e.f = as_compatible %return.param // CHECK:STDOUT: %.loc10_11.5: ref %i32 = struct_access %.loc10_11.4, element0 // CHECK:STDOUT: %.loc10_11.6: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc10_11.1 to %.loc10_11.5 // CHECK:STDOUT: %.loc10_11.7: ref %i32 = struct_access %.loc10_11.1, element1 @@ -1080,7 +1080,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %.loc10_11.13: init %AdaptStruct = converted %h.ref, %.loc10_11.12 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %h.var, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%h.var) -// CHECK:STDOUT: return %.loc10_11.13 to %return +// CHECK:STDOUT: return %.loc10_11.13 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc9(%self.param: %AdaptStruct) = "no_op"; @@ -1145,7 +1145,7 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc15_10.1: = specific_function %impl.elem0.loc15_10.1, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_10.2: = bound_method %.loc15_10.3, %specific_fn.loc15_10.1 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc15_10.1: init %i32 = call %bound_method.loc15_10.2(%.loc15_10.3) -// CHECK:STDOUT: %tuple.elem0.loc15_10.2: ref %AdaptStruct = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0.loc15_10.2: ref %AdaptStruct = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc15_10.4: ref %struct_type.e.f = as_compatible %tuple.elem0.loc15_10.2 // CHECK:STDOUT: %.loc15_10.5: ref %i32 = struct_access %.loc15_10.4, element0 // CHECK:STDOUT: %.loc15_10.6: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc15_10.1 to %.loc15_10.5 @@ -1168,13 +1168,13 @@ fn InTuple(c: (AdaptStruct, u32)) -> (AdaptStruct, u32) { // CHECK:STDOUT: %specific_fn.loc15_10.3: = specific_function %impl.elem0.loc15_10.3, @UInt.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%UInt.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_10.6: = bound_method %.loc15_10.14, %specific_fn.loc15_10.3 // CHECK:STDOUT: %UInt.as.Copy.impl.Op.call.loc15: init %u32 = call %bound_method.loc15_10.6(%.loc15_10.14) -// CHECK:STDOUT: %tuple.elem1.loc15_10.2: ref %u32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1.loc15_10.2: ref %u32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc15_10.15: init %u32 = initialize_from %UInt.as.Copy.impl.Op.call.loc15 to %tuple.elem1.loc15_10.2 -// CHECK:STDOUT: %.loc15_10.16: init %tuple.type.691 = tuple_init (%.loc15_10.13, %.loc15_10.15) to %return +// CHECK:STDOUT: %.loc15_10.16: init %tuple.type.691 = tuple_init (%.loc15_10.13, %.loc15_10.15) to %return.param // CHECK:STDOUT: %.loc15_11: init %tuple.type.691 = converted %d.ref, %.loc15_10.16 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %d.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%d.var) -// CHECK:STDOUT: return %.loc15_11 to %return +// CHECK:STDOUT: return %.loc15_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc14(%self.param: %tuple.type.691) = "no_op"; diff --git a/toolchain/check/testdata/class/adapter/extend_adapt.carbon b/toolchain/check/testdata/class/adapter/extend_adapt.carbon index 42c4aab6f109..b98465bd060c 100644 --- a/toolchain/check/testdata/class/adapter/extend_adapt.carbon +++ b/toolchain/check/testdata/class/adapter/extend_adapt.carbon @@ -451,7 +451,7 @@ fn F(a: IntAdapter) -> i32 { // CHECK:STDOUT: %b.ref: %SomeClass.elem = name_ref b, @SomeClass.%.loc6 [concrete = @SomeClass.%.loc6] // CHECK:STDOUT: %.loc21_11.1: %SomeClass = converted %a.ref, [concrete = ] // CHECK:STDOUT: %.loc21_11.2: %i32 = class_element_access , element1 [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_adapt_struct.carbon @@ -525,7 +525,7 @@ fn F(a: IntAdapter) -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %StructAdapter = name_ref a, %a // CHECK:STDOUT: %b.ref: = name_ref b, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_adapt_tuple.carbon @@ -602,7 +602,7 @@ fn F(a: IntAdapter) -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %TupleAdapter = name_ref a, %a // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_adapt_builtin.carbon @@ -708,6 +708,6 @@ fn F(a: IntAdapter) -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %IntAdapter = name_ref a, %a // CHECK:STDOUT: %foo.ref: = name_ref foo, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/base.carbon b/toolchain/check/testdata/class/base.carbon index 9e36a3f7a6c7..f3e575f09852 100644 --- a/toolchain/check/testdata/class/base.carbon +++ b/toolchain/check/testdata/class/base.carbon @@ -215,7 +215,7 @@ class Derived { // CHECK:STDOUT: %bound_method.loc14_26.2: = bound_method %int_4, %specific_fn.loc14_26 [concrete = constants.%bound_method.6d7] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc14_26: init %i32 = call %bound_method.loc14_26.2(%int_4) [concrete = constants.%int_4.940] // CHECK:STDOUT: %.loc14_26.2: init %i32 = converted %int_4, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc14_26 [concrete = constants.%int_4.940] -// CHECK:STDOUT: %.loc14_35.2: ref %Base = class_element_access %return, element0 +// CHECK:STDOUT: %.loc14_35.2: ref %Base = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc14_26.3: ref %i32 = class_element_access %.loc14_35.2, element0 // CHECK:STDOUT: %.loc14_26.4: init %i32 = initialize_from %.loc14_26.2 to %.loc14_26.3 [concrete = constants.%int_4.940] // CHECK:STDOUT: %.loc14_26.5: init %Base = class_init (%.loc14_26.4), %.loc14_35.2 [concrete = constants.%Base.val] @@ -226,11 +226,11 @@ class Derived { // CHECK:STDOUT: %bound_method.loc14_35.2: = bound_method %int_7, %specific_fn.loc14_35 [concrete = constants.%bound_method.bf2] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc14_35: init %i32 = call %bound_method.loc14_35.2(%int_7) [concrete = constants.%int_7.0b1] // CHECK:STDOUT: %.loc14_35.4: init %i32 = converted %int_7, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc14_35 [concrete = constants.%int_7.0b1] -// CHECK:STDOUT: %.loc14_35.5: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc14_35.5: ref %i32 = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc14_35.6: init %i32 = initialize_from %.loc14_35.4 to %.loc14_35.5 [concrete = constants.%int_7.0b1] -// CHECK:STDOUT: %.loc14_35.7: init %Derived = class_init (%.loc14_35.3, %.loc14_35.6), %return [concrete = constants.%Derived.val] +// CHECK:STDOUT: %.loc14_35.7: init %Derived = class_init (%.loc14_35.3, %.loc14_35.6), %return.param [concrete = constants.%Derived.val] // CHECK:STDOUT: %.loc14_36: init %Derived = converted %.loc14_35.1, %.loc14_35.7 [concrete = constants.%Derived.val] -// CHECK:STDOUT: return %.loc14_36 to %return +// CHECK:STDOUT: return %.loc14_36 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Access(%d.param: %Derived) -> %return.param: %tuple.type.d07 { @@ -252,18 +252,18 @@ class Derived { // CHECK:STDOUT: %specific_fn.loc18_12: = specific_function %impl.elem0.loc18_12, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc18_12.2: = bound_method %.loc18_12.2, %specific_fn.loc18_12 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc18_12: init %i32 = call %bound_method.loc18_12.2(%.loc18_12.2) -// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc18_24.2: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc18_12 to %tuple.elem0 // CHECK:STDOUT: %impl.elem0.loc18_22: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] // CHECK:STDOUT: %bound_method.loc18_22.1: = bound_method %.loc18_22.2, %impl.elem0.loc18_22 // CHECK:STDOUT: %specific_fn.loc18_22: = specific_function %impl.elem0.loc18_22, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc18_22.2: = bound_method %.loc18_22.2, %specific_fn.loc18_22 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc18_22: init %i32 = call %bound_method.loc18_22.2(%.loc18_22.2) -// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc18_24.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc18_22 to %tuple.elem1 -// CHECK:STDOUT: %.loc18_24.4: init %tuple.type.d07 = tuple_init (%.loc18_24.2, %.loc18_24.3) to %return +// CHECK:STDOUT: %.loc18_24.4: init %tuple.type.d07 = tuple_init (%.loc18_24.2, %.loc18_24.3) to %return.param // CHECK:STDOUT: %.loc18_25: init %tuple.type.d07 = converted %.loc18_24.1, %.loc18_24.4 -// CHECK:STDOUT: return %.loc18_25 to %return +// CHECK:STDOUT: return %.loc18_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_base_after_field.carbon diff --git a/toolchain/check/testdata/class/base_field.carbon b/toolchain/check/testdata/class/base_field.carbon index a61827990bef..c219c5a4f9fa 100644 --- a/toolchain/check/testdata/class/base_field.carbon +++ b/toolchain/check/testdata/class/base_field.carbon @@ -165,6 +165,6 @@ fn Access(p: Derived*) -> i32* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%i32) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc29_10.2: = bound_method %addr, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.235 = call %bound_method.loc29_10.2(%addr) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/base_method_qualified.carbon b/toolchain/check/testdata/class/base_method_qualified.carbon index c6e5ca8d255d..d30f3ca047c2 100644 --- a/toolchain/check/testdata/class/base_method_qualified.carbon +++ b/toolchain/check/testdata/class/base_method_qualified.carbon @@ -261,7 +261,7 @@ fn PassDerivedToBaseIndirect(p: Derived*) -> i32 { // CHECK:STDOUT: %.loc30_10.2: ref %Base = converted %a.ref, %.loc30_10.1 // CHECK:STDOUT: %.loc30_10.3: %Base = acquire_value %.loc30_10.2 // CHECK:STDOUT: %Base.F.call: init %i32 = call %Base.F.bound(%.loc30_10.3) -// CHECK:STDOUT: return %Base.F.call to %return +// CHECK:STDOUT: return %Base.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallIndirect(%p.param: %ptr.f74) -> %i32 { @@ -275,7 +275,7 @@ fn PassDerivedToBaseIndirect(p: Derived*) -> i32 { // CHECK:STDOUT: %.loc34_11.3: ref %Base = converted %.loc34_11.1, %.loc34_11.2 // CHECK:STDOUT: %.loc34_11.4: %Base = acquire_value %.loc34_11.3 // CHECK:STDOUT: %Base.F.call: init %i32 = call %Base.F.bound(%.loc34_11.4) -// CHECK:STDOUT: return %Base.F.call to %return +// CHECK:STDOUT: return %Base.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @PassDerivedToBase(%a.param: %Derived) -> %i32 { @@ -285,7 +285,7 @@ fn PassDerivedToBaseIndirect(p: Derived*) -> i32 { // CHECK:STDOUT: %G.ref: %Base.G.type = name_ref G, @Base.%Base.G.decl [concrete = constants.%Base.G] // CHECK:STDOUT: %Base.G.bound: = bound_method %a.ref, %G.ref // CHECK:STDOUT: %Base.G.call: init %i32 = call %Base.G.bound(%a.ref) -// CHECK:STDOUT: return %Base.G.call to %return +// CHECK:STDOUT: return %Base.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @PassDerivedToBaseIndirect(%p.param: %ptr.f74) -> %i32 { @@ -297,6 +297,6 @@ fn PassDerivedToBaseIndirect(p: Derived*) -> i32 { // CHECK:STDOUT: %Base.G.bound: = bound_method %.loc42_11.1, %G.ref // CHECK:STDOUT: %.loc42_11.2: %Derived = acquire_value %.loc42_11.1 // CHECK:STDOUT: %Base.G.call: init %i32 = call %Base.G.bound(%.loc42_11.2) -// CHECK:STDOUT: return %Base.G.call to %return +// CHECK:STDOUT: return %Base.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/basic.carbon b/toolchain/check/testdata/class/basic.carbon index 9a214ffce8e6..1fc994127298 100644 --- a/toolchain/check/testdata/class/basic.carbon +++ b/toolchain/check/testdata/class/basic.carbon @@ -195,7 +195,7 @@ fn Run() -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc17_12.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_12.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.G(%n.param.loc25: %i32) -> %i32 { @@ -206,7 +206,7 @@ fn Run() -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc26_10.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc26_10.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.loc25 +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param.loc25 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Run() -> %i32 { @@ -222,6 +222,6 @@ fn Run() -> i32 { // CHECK:STDOUT: %.loc30_18.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_4.940] // CHECK:STDOUT: %.loc30_18.2: %i32 = converted %int_4, %.loc30_18.1 [concrete = constants.%int_4.940] // CHECK:STDOUT: %Class.F.call: init %i32 = call %F.ref(%.loc30_18.2) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/complete_in_member_fn.carbon b/toolchain/check/testdata/class/complete_in_member_fn.carbon index 6c1a7718375b..a17ed9d97c74 100644 --- a/toolchain/check/testdata/class/complete_in_member_fn.carbon +++ b/toolchain/check/testdata/class/complete_in_member_fn.carbon @@ -109,6 +109,6 @@ class C { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc16_31.2: = bound_method %.loc16_31.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc16_31.2(%.loc16_31.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/compound_field.carbon b/toolchain/check/testdata/class/compound_field.carbon index dc42023f182d..c1814b286d44 100644 --- a/toolchain/check/testdata/class/compound_field.carbon +++ b/toolchain/check/testdata/class/compound_field.carbon @@ -246,7 +246,7 @@ fn AccessBaseIndirect(p: Derived*) -> i32* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc29_11.2: = bound_method %.loc29_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc29_11.2(%.loc29_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @AccessBase(%d.param: %Derived) -> %i32 { @@ -263,7 +263,7 @@ fn AccessBaseIndirect(p: Derived*) -> i32* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc33_11.2: = bound_method %.loc33_11.4, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc33_11.2(%.loc33_11.4) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @AccessDerivedIndirect(%p.param: %ptr.f74) -> %ptr.235 { @@ -279,7 +279,7 @@ fn AccessBaseIndirect(p: Derived*) -> i32* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%i32) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc37_10.2: = bound_method %addr, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.235 = call %bound_method.loc37_10.2(%addr) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @AccessBaseIndirect(%p.param: %ptr.f74) -> %ptr.235 { @@ -297,6 +297,6 @@ fn AccessBaseIndirect(p: Derived*) -> i32* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%i32) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc41_10.2: = bound_method %addr, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.235 = call %bound_method.loc41_10.2(%addr) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/derived_to_base.carbon b/toolchain/check/testdata/class/derived_to_base.carbon index 26f29e64f175..960a578db2df 100644 --- a/toolchain/check/testdata/class/derived_to_base.carbon +++ b/toolchain/check/testdata/class/derived_to_base.carbon @@ -303,7 +303,7 @@ fn PassConstB(p: const B) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%B) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.695] // CHECK:STDOUT: %bound_method.loc19_39.2: = bound_method %.loc19_39.3, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.27c = call %bound_method.loc19_39.2(%.loc19_39.3) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ConvertBToA(%p.param: %ptr.27c) -> %ptr.643 { @@ -318,7 +318,7 @@ fn PassConstB(p: const B) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%A) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.05b] // CHECK:STDOUT: %bound_method.loc20_39.2: = bound_method %.loc20_39.3, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.643 = call %bound_method.loc20_39.2(%.loc20_39.3) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ConvertCToA(%p.param: %ptr.31e) -> %ptr.643 { @@ -334,7 +334,7 @@ fn PassConstB(p: const B) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%A) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.05b] // CHECK:STDOUT: %bound_method.loc21_39.2: = bound_method %.loc21_39.4, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.643 = call %bound_method.loc21_39.2(%.loc21_39.4) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ConvertValue(%c.param: %C) { @@ -366,7 +366,7 @@ fn PassConstB(p: const B) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%A) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.05b] // CHECK:STDOUT: %bound_method.loc28_10.2: = bound_method %addr, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.643 = call %bound_method.loc28_10.2(%addr) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ConvertInit() { diff --git a/toolchain/check/testdata/class/fail_abstract.carbon b/toolchain/check/testdata/class/fail_abstract.carbon index 76680c89b172..957be81ba94f 100644 --- a/toolchain/check/testdata/class/fail_abstract.carbon +++ b/toolchain/check/testdata/class/fail_abstract.carbon @@ -601,7 +601,7 @@ fn CallReturnAbstract() { // CHECK:STDOUT: %.loc22_20: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc22_29: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc22_30: %struct_type.base.d.e0f = struct_literal (%.loc22_20, %.loc22_29) [concrete = constants.%struct] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_return_abstract.carbon @@ -776,7 +776,7 @@ fn CallReturnAbstract() { // CHECK:STDOUT: %base.ref: %Derived.elem.032 = name_ref base, @Derived.%.loc9 [concrete = @Derived.%.loc9] // CHECK:STDOUT: %.loc15: ref %Abstract = class_element_access %d.ref, element0 // CHECK:STDOUT: %a.ref: = name_ref a, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- abstract_let_temporary.carbon diff --git a/toolchain/check/testdata/class/forward_declared.carbon b/toolchain/check/testdata/class/forward_declared.carbon index e06a6efd8cb0..750157e5d311 100644 --- a/toolchain/check/testdata/class/forward_declared.carbon +++ b/toolchain/check/testdata/class/forward_declared.carbon @@ -87,6 +87,6 @@ fn F(p: Class*) -> Class* { return p; } // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%Class) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc17_36.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.8e5 = call %bound_method.loc17_36.2(%p.ref) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/adapt.carbon b/toolchain/check/testdata/class/generic/adapt.carbon index 8d9a17d1d635..4aa3e455035d 100644 --- a/toolchain/check/testdata/class/generic/adapt.carbon +++ b/toolchain/check/testdata/class/generic/adapt.carbon @@ -267,7 +267,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc13_23.2: = bound_method %.loc13_23.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc13_23.2(%.loc13_23.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%T.67d) { @@ -418,7 +418,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_23.2: = bound_method %.loc7_23.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_23.2(%.loc7_23.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%T.67d) { @@ -558,7 +558,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %x.ref: %C.elem.8f4 = name_ref x, @C.%.loc5 [concrete = @C.%.loc5] // CHECK:STDOUT: %.loc21_11.1: %C.b13 = converted %a.ref, [concrete = ] // CHECK:STDOUT: %.loc21_11.2: %i32 = class_element_access , element0 [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%T) { @@ -791,7 +791,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %x.ref: %C.elem.fd3 = name_ref x, imports.%Main.import_ref.b94 [concrete = imports.%.68d] // CHECK:STDOUT: %.loc15_11.1: %C.829 = converted %a.ref, [concrete = ] // CHECK:STDOUT: %.loc15_11.2: %i32 = class_element_access , element0 [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%T) { @@ -926,7 +926,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc9_12.2: = bound_method %.loc9_12.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc9_12.2(%.loc9_12.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Adapter(constants.%T.67d) { @@ -1094,7 +1094,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_12.2: = bound_method %.loc7_12.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_12.2(%.loc7_12.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ImportedConvertLocal(%a.param: %Adapter.8a3) -> %i32 { @@ -1111,7 +1111,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_18.2: = bound_method %.loc15_18.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc15_18.2(%.loc15_18.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Adapter(constants.%T.67d) { diff --git a/toolchain/check/testdata/class/generic/base_is_generic.carbon b/toolchain/check/testdata/class/generic/base_is_generic.carbon index ee680690f043..5b1886850df5 100644 --- a/toolchain/check/testdata/class/generic/base_is_generic.carbon +++ b/toolchain/check/testdata/class/generic/base_is_generic.carbon @@ -251,7 +251,7 @@ fn H() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc17_13.2: = bound_method %.loc17_13.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_13.2(%.loc17_13.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Base(constants.%T.67d) { @@ -421,7 +421,7 @@ fn H() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_13.2: = bound_method %.loc7_13.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_13.2(%.loc7_13.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Base(constants.%T.67d) { @@ -635,7 +635,7 @@ fn H() { // CHECK:STDOUT: %return.param_patt: @X.G.%pattern_type (%pattern_type.51d) = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %U.ref: type = name_ref U, @X.%U.loc4_14.2 [symbolic = %U (constants.%U)] -// CHECK:STDOUT: %.loc5_13.2: form = init_form %U.ref, call_param0 [symbolic = %.loc5_13.1 (constants.%.c6c)] +// CHECK:STDOUT: %.loc5_13.3: form = init_form %U.ref, call_param0 [symbolic = %.loc5_13.2 (constants.%.c6c)] // CHECK:STDOUT: %return.param: ref @X.G.%U (%U) = out_param call_param0 // CHECK:STDOUT: %return: ref @X.G.%U (%U) = return_slot %return.param // CHECK:STDOUT: } @@ -680,7 +680,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: generic fn @X.G(@X.%U.loc4_14.2: type) { // CHECK:STDOUT: %U: type = symbolic_binding U, 0 [symbolic = %U (constants.%U)] -// CHECK:STDOUT: %.loc5_13.1: form = init_form %U, call_param0 [symbolic = %.loc5_13.1 (constants.%.c6c)] +// CHECK:STDOUT: %.loc5_13.2: form = init_form %U, call_param0 [symbolic = %.loc5_13.2 (constants.%.c6c)] // CHECK:STDOUT: %pattern_type: type = pattern_type %U [symbolic = %pattern_type (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -694,9 +694,9 @@ fn H() { // CHECK:STDOUT: %.loc5_24: @X.G.%X.G.type (%X.G.type.20eb90.1) = specific_constant @X.%X.G.decl, @X(constants.%U) [symbolic = %X.G (constants.%X.G.f9f685.1)] // CHECK:STDOUT: %G.ref: @X.G.%X.G.type (%X.G.type.20eb90.1) = name_ref G, %.loc5_24 [symbolic = %X.G (constants.%X.G.f9f685.1)] // CHECK:STDOUT: %X.G.specific_fn.loc5_24.1: = specific_function %G.ref, @X.G(constants.%U) [symbolic = %X.G.specific_fn.loc5_24.2 (constants.%X.G.specific_fn.974)] -// CHECK:STDOUT: %.loc5_10: ref @X.G.%U (%U) = splice_block %return {} -// CHECK:STDOUT: %X.G.call: init @X.G.%U (%U) = call %X.G.specific_fn.loc5_24.1() to %.loc5_10 -// CHECK:STDOUT: return %X.G.call to %return +// CHECK:STDOUT: %.loc5_13.1: ref @X.G.%U (%U) = splice_block %return.param {} +// CHECK:STDOUT: %X.G.call: init @X.G.%U (%U) = call %X.G.specific_fn.loc5_24.1() to %.loc5_13.1 +// CHECK:STDOUT: return %X.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -733,7 +733,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: specific @X.G(constants.%U) { // CHECK:STDOUT: %U => constants.%U -// CHECK:STDOUT: %.loc5_13.1 => constants.%.c6c +// CHECK:STDOUT: %.loc5_13.2 => constants.%.c6c // CHECK:STDOUT: %pattern_type => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -777,7 +777,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: specific @X.G(constants.%i32) { // CHECK:STDOUT: %U => constants.%i32 -// CHECK:STDOUT: %.loc5_13.1 => constants.%.941 +// CHECK:STDOUT: %.loc5_13.2 => constants.%.941 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.7ce // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/class/generic/basic.carbon b/toolchain/check/testdata/class/generic/basic.carbon index 0823afdf92bb..1aeae41f7376 100644 --- a/toolchain/check/testdata/class/generic/basic.carbon +++ b/toolchain/check/testdata/class/generic/basic.carbon @@ -145,8 +145,8 @@ class Declaration(T:! type); // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref: %Copy.type = name_ref T, @Class.%T.loc5_13.2 [symbolic = %T (constants.%T.035)] // CHECK:STDOUT: %T.as_type: type = facet_access_type %T.ref [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc10_32.2: type = converted %T.ref, %T.as_type [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc10_32.3: form = init_form %.loc10_32.2, call_param1 [symbolic = %.loc10_32.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc10_32.3: type = converted %T.ref, %T.as_type [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc10_32.4: form = init_form %.loc10_32.3, call_param1 [symbolic = %.loc10_32.2 (constants.%.075d25.1)] // CHECK:STDOUT: %self.param: @Class.GetValue.%Class (%Class) = value_param call_param0 // CHECK:STDOUT: %.loc10_21.1: type = splice_block %Self.ref [symbolic = %Class (constants.%Class)] { // CHECK:STDOUT: %.loc10_21.2: type = specific_constant constants.%Class, @Class(constants.%T.035) [symbolic = %Class (constants.%Class)] @@ -209,7 +209,7 @@ class Declaration(T:! type); // CHECK:STDOUT: %specific_impl_fn.loc7_12.1: = specific_impl_function %impl.elem0.loc7_12.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc7_12.2 (constants.%specific_impl_fn.0df)] // CHECK:STDOUT: %bound_method.loc7_12.2: = bound_method %addr, %specific_impl_fn.loc7_12.1 // CHECK:STDOUT: %Copy.Op.call: init @Class.GetAddr.%ptr.loc6_36.1 (%ptr.e7d) = call %bound_method.loc7_12.2(%addr) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -218,7 +218,7 @@ class Declaration(T:! type); // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %pattern_type.loc10_15: type = pattern_type %Class [symbolic = %pattern_type.loc10_15 (constants.%pattern_type.893)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc10_32.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc10_32.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc10_32.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc10_32.2 (constants.%.075d25.1)] // CHECK:STDOUT: %pattern_type.loc10_29: type = pattern_type %T.binding.as_type [symbolic = %pattern_type.loc10_29 (constants.%pattern_type.9b9f0c.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -240,9 +240,9 @@ class Declaration(T:! type); // CHECK:STDOUT: %bound_method.loc11_16.1: = bound_method %.loc11_16.2, %impl.elem0.loc11_16.1 // CHECK:STDOUT: %specific_impl_fn.loc11_16.1: = specific_impl_function %impl.elem0.loc11_16.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc11_16.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc11_16.2: = bound_method %.loc11_16.2, %specific_impl_fn.loc11_16.1 -// CHECK:STDOUT: %.loc10_29: ref @Class.GetValue.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @Class.GetValue.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc11_16.2(%.loc11_16.2) to %.loc10_29 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc10_32.1: ref @Class.GetValue.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @Class.GetValue.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc11_16.2(%.loc11_16.2) to %.loc10_32.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -277,7 +277,7 @@ class Declaration(T:! type); // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: %pattern_type.loc10_15 => constants.%pattern_type.893 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type -// CHECK:STDOUT: %.loc10_32.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc10_32.2 => constants.%.075d25.1 // CHECK:STDOUT: %pattern_type.loc10_29 => constants.%pattern_type.9b9f0c.1 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/call.carbon b/toolchain/check/testdata/class/generic/call.carbon index ef9c0d4dd858..c5231d974ce5 100644 --- a/toolchain/check/testdata/class/generic/call.carbon +++ b/toolchain/check/testdata/class/generic/call.carbon @@ -703,9 +703,9 @@ class Outer(T:! type) { // CHECK:STDOUT: fn() -> %return.param: @Inner.A.%Outer.loc4_22.1 (%Outer.387) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc5_15.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc5_15.2: init @Inner.A.%Outer.loc4_22.1 (%Outer.387) = class_init (), %return [symbolic = %Outer.val (constants.%Outer.val.ca1)] +// CHECK:STDOUT: %.loc5_15.2: init @Inner.A.%Outer.loc4_22.1 (%Outer.387) = class_init (), %return.param [symbolic = %Outer.val (constants.%Outer.val.ca1)] // CHECK:STDOUT: %.loc5_16: init @Inner.A.%Outer.loc4_22.1 (%Outer.387) = converted %.loc5_15.1, %.loc5_15.2 [symbolic = %Outer.val (constants.%Outer.val.ca1)] -// CHECK:STDOUT: return %.loc5_16 to %return +// CHECK:STDOUT: return %.loc5_16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -722,9 +722,9 @@ class Outer(T:! type) { // CHECK:STDOUT: fn() -> %return.param: @Inner.B.%Outer.loc7_22.1 (%Outer.d2f) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc8_15.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc8_15.2: init @Inner.B.%Outer.loc7_22.1 (%Outer.d2f) = class_init (), %return [symbolic = %Outer.val (constants.%Outer.val.756)] +// CHECK:STDOUT: %.loc8_15.2: init @Inner.B.%Outer.loc7_22.1 (%Outer.d2f) = class_init (), %return.param [symbolic = %Outer.val (constants.%Outer.val.756)] // CHECK:STDOUT: %.loc8_16: init @Inner.B.%Outer.loc7_22.1 (%Outer.d2f) = converted %.loc8_15.1, %.loc8_15.2 [symbolic = %Outer.val (constants.%Outer.val.756)] -// CHECK:STDOUT: return %.loc8_16 to %return +// CHECK:STDOUT: return %.loc8_16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -743,9 +743,9 @@ class Outer(T:! type) { // CHECK:STDOUT: fn() -> %return.param: @Inner.C.%Inner.loc10_22.1 (%Inner.ddc) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc11_15.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc11_15.2: init @Inner.C.%Inner.loc10_22.1 (%Inner.ddc) = class_init (), %return [symbolic = %Inner.val (constants.%Inner.val.240)] +// CHECK:STDOUT: %.loc11_15.2: init @Inner.C.%Inner.loc10_22.1 (%Inner.ddc) = class_init (), %return.param [symbolic = %Inner.val (constants.%Inner.val.240)] // CHECK:STDOUT: %.loc11_16: init @Inner.C.%Inner.loc10_22.1 (%Inner.ddc) = converted %.loc11_15.1, %.loc11_15.2 [symbolic = %Inner.val (constants.%Inner.val.240)] -// CHECK:STDOUT: return %.loc11_16 to %return +// CHECK:STDOUT: return %.loc11_16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -765,9 +765,9 @@ class Outer(T:! type) { // CHECK:STDOUT: fn() -> %return.param: @Inner.D.%Inner.loc13_22.1 (%Inner.e21) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc14_15.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc14_15.2: init @Inner.D.%Inner.loc13_22.1 (%Inner.e21) = class_init (), %return [symbolic = %Inner.val (constants.%Inner.val.43a)] +// CHECK:STDOUT: %.loc14_15.2: init @Inner.D.%Inner.loc13_22.1 (%Inner.e21) = class_init (), %return.param [symbolic = %Inner.val (constants.%Inner.val.43a)] // CHECK:STDOUT: %.loc14_16: init @Inner.D.%Inner.loc13_22.1 (%Inner.e21) = converted %.loc14_15.1, %.loc14_15.2 [symbolic = %Inner.val (constants.%Inner.val.43a)] -// CHECK:STDOUT: return %.loc14_16 to %return +// CHECK:STDOUT: return %.loc14_16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/field.carbon b/toolchain/check/testdata/class/generic/field.carbon index f85a86076eea..93a939f04b44 100644 --- a/toolchain/check/testdata/class/generic/field.carbon +++ b/toolchain/check/testdata/class/generic/field.carbon @@ -156,8 +156,8 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc13_37: %Copy.type = name_ref T, %T.loc13_6.2 [symbolic = %T.loc13_6.1 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc13_37: type = facet_access_type %T.ref.loc13_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc13_37.2: type = converted %T.ref.loc13_37, %T.as_type.loc13_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc13_37.3: form = init_form %.loc13_37.2, call_param1 [symbolic = %.loc13_37.1 (constants.%.075d25.2)] +// CHECK:STDOUT: %.loc13_37.3: type = converted %T.ref.loc13_37, %T.as_type.loc13_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc13_37.4: form = init_form %.loc13_37.3, call_param1 [symbolic = %.loc13_37.2 (constants.%.075d25.2)] // CHECK:STDOUT: %.loc13_14: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -185,8 +185,8 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: } { // CHECK:STDOUT: %U.ref.loc17_37: %Copy.type = name_ref U, %U.loc17_6.2 [symbolic = %U.loc17_6.1 (constants.%U.035)] // CHECK:STDOUT: %U.as_type.loc17_37: type = facet_access_type %U.ref.loc17_37 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] -// CHECK:STDOUT: %.loc17_37.2: type = converted %U.ref.loc17_37, %U.as_type.loc17_37 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] -// CHECK:STDOUT: %.loc17_37.3: form = init_form %.loc17_37.2, call_param1 [symbolic = %.loc17_37.1 (constants.%.075d25.3)] +// CHECK:STDOUT: %.loc17_37.3: type = converted %U.ref.loc17_37, %U.as_type.loc17_37 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] +// CHECK:STDOUT: %.loc17_37.4: form = init_form %.loc17_37.3, call_param1 [symbolic = %.loc17_37.2 (constants.%.075d25.3)] // CHECK:STDOUT: %.loc17_14: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -241,7 +241,7 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc10_11.2: = bound_method %.loc10_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc10_11.2(%.loc10_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @G(%T.loc13_6.2: %Copy.type) { @@ -249,7 +249,7 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T.loc13_6.1 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %Class.loc13_31.1: type = class_type @Class, @Class(%T.binding.as_type) [symbolic = %Class.loc13_31.1 (constants.%Class.3168aa.1)] // CHECK:STDOUT: %pattern_type.loc13_21: type = pattern_type %Class.loc13_31.1 [symbolic = %pattern_type.loc13_21 (constants.%pattern_type.c542f5.1)] -// CHECK:STDOUT: %.loc13_37.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc13_37.1 (constants.%.075d25.2)] +// CHECK:STDOUT: %.loc13_37.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc13_37.2 (constants.%.075d25.2)] // CHECK:STDOUT: %pattern_type.loc13_34: type = pattern_type %T.binding.as_type [symbolic = %pattern_type.loc13_34 (constants.%pattern_type.9b9f0c.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -271,9 +271,9 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %bound_method.loc14_11.1: = bound_method %.loc14_11.2, %impl.elem0.loc14_11.1 // CHECK:STDOUT: %specific_impl_fn.loc14_11.1: = specific_impl_function %impl.elem0.loc14_11.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc14_11.2 (constants.%specific_impl_fn.2c9874.1)] // CHECK:STDOUT: %bound_method.loc14_11.2: = bound_method %.loc14_11.2, %specific_impl_fn.loc14_11.1 -// CHECK:STDOUT: %.loc13_34: ref @G.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @G.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc14_11.2(%.loc14_11.2) to %.loc13_34 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc13_37.1: ref @G.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @G.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc14_11.2(%.loc14_11.2) to %.loc13_37.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -282,7 +282,7 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %U.binding.as_type: type = symbolic_binding_type U, 0, %U.loc17_6.1 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] // CHECK:STDOUT: %Class.loc17_31.1: type = class_type @Class, @Class(%U.binding.as_type) [symbolic = %Class.loc17_31.1 (constants.%Class.3168aa.2)] // CHECK:STDOUT: %pattern_type.loc17_21: type = pattern_type %Class.loc17_31.1 [symbolic = %pattern_type.loc17_21 (constants.%pattern_type.c542f5.2)] -// CHECK:STDOUT: %.loc17_37.1: form = init_form %U.binding.as_type, call_param1 [symbolic = %.loc17_37.1 (constants.%.075d25.3)] +// CHECK:STDOUT: %.loc17_37.2: form = init_form %U.binding.as_type, call_param1 [symbolic = %.loc17_37.2 (constants.%.075d25.3)] // CHECK:STDOUT: %pattern_type.loc17_34: type = pattern_type %U.binding.as_type [symbolic = %pattern_type.loc17_34 (constants.%pattern_type.9b9f0c.3)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -304,9 +304,9 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %bound_method.loc18_11.1: = bound_method %.loc18_11.2, %impl.elem0.loc18_11.1 // CHECK:STDOUT: %specific_impl_fn.loc18_11.1: = specific_impl_function %impl.elem0.loc18_11.1, @Copy.Op(constants.%U.035) [symbolic = %specific_impl_fn.loc18_11.2 (constants.%specific_impl_fn.2c9874.2)] // CHECK:STDOUT: %bound_method.loc18_11.2: = bound_method %.loc18_11.2, %specific_impl_fn.loc18_11.1 -// CHECK:STDOUT: %.loc17_34: ref @H.%U.binding.as_type (%U.binding.as_type.14b) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @H.%U.binding.as_type (%U.binding.as_type.14b) = call %bound_method.loc18_11.2(%.loc18_11.2) to %.loc17_34 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc17_37.1: ref @H.%U.binding.as_type (%U.binding.as_type.14b) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @H.%U.binding.as_type (%U.binding.as_type.14b) = call %bound_method.loc18_11.2(%.loc18_11.2) to %.loc17_37.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -341,7 +341,7 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %Class.loc13_31.1 => constants.%Class.3168aa.1 // CHECK:STDOUT: %pattern_type.loc13_21 => constants.%pattern_type.c542f5.1 -// CHECK:STDOUT: %.loc13_37.1 => constants.%.075d25.2 +// CHECK:STDOUT: %.loc13_37.2 => constants.%.075d25.2 // CHECK:STDOUT: %pattern_type.loc13_34 => constants.%pattern_type.9b9f0c.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -361,7 +361,7 @@ fn H(U:! Core.Copy, c: Class(U)) -> U { // CHECK:STDOUT: %U.binding.as_type => constants.%U.binding.as_type.14b // CHECK:STDOUT: %Class.loc17_31.1 => constants.%Class.3168aa.2 // CHECK:STDOUT: %pattern_type.loc17_21 => constants.%pattern_type.c542f5.2 -// CHECK:STDOUT: %.loc17_37.1 => constants.%.075d25.3 +// CHECK:STDOUT: %.loc17_37.2 => constants.%.075d25.3 // CHECK:STDOUT: %pattern_type.loc17_34 => constants.%pattern_type.9b9f0c.3 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/import.carbon b/toolchain/check/testdata/class/generic/import.carbon index c71e688ccb4e..f09d63c0d3aa 100644 --- a/toolchain/check/testdata/class/generic/import.carbon +++ b/toolchain/check/testdata/class/generic/import.carbon @@ -234,7 +234,7 @@ class Class(U:! type) { // CHECK:STDOUT: %bound_method.loc8_27.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc8_27.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc8_27: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc8_27 to %return +// CHECK:STDOUT: return %.loc8_27 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -425,11 +425,11 @@ class Class(U:! type) { // CHECK:STDOUT: %bound_method.loc9_17.2: = bound_method %int_1, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc9_17.2(%int_1) [concrete = constants.%int_1.47b] // CHECK:STDOUT: %.loc9_17.2: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.47b] -// CHECK:STDOUT: %.loc9_17.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc9_17.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc9_17.4: init %i32 = initialize_from %.loc9_17.2 to %.loc9_17.3 [concrete = constants.%int_1.47b] -// CHECK:STDOUT: %.loc9_17.5: init %CompleteClass.667 = class_init (%.loc9_17.4), %return [concrete = constants.%CompleteClass.val] +// CHECK:STDOUT: %.loc9_17.5: init %CompleteClass.667 = class_init (%.loc9_17.4), %return.param [concrete = constants.%CompleteClass.val] // CHECK:STDOUT: %.loc9_18: init %CompleteClass.667 = converted %.loc9_17.1, %.loc9_17.5 [concrete = constants.%CompleteClass.val] -// CHECK:STDOUT: return %.loc9_18 to %return +// CHECK:STDOUT: return %.loc9_18 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Class(constants.%T) { @@ -607,7 +607,7 @@ class Class(U:! type) { // CHECK:STDOUT: %CompleteClass.F.call: init %i32 = call %CompleteClass.F.specific_fn() // CHECK:STDOUT: %DestroyOp.bound: = bound_method %v.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%v.var) -// CHECK:STDOUT: return %CompleteClass.F.call to %return +// CHECK:STDOUT: return %CompleteClass.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @CompleteClass.F(imports.%Main.import_ref.b3bc94.1: type) [from "foo.carbon"] { @@ -649,7 +649,7 @@ class Class(U:! type) { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc12_11.2(%.loc12_11.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %v.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%v.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @CompleteClass(constants.%T.67d) { diff --git a/toolchain/check/testdata/class/generic/init.carbon b/toolchain/check/testdata/class/generic/init.carbon index b81e86fc8570..99fc22b4cb57 100644 --- a/toolchain/check/testdata/class/generic/init.carbon +++ b/toolchain/check/testdata/class/generic/init.carbon @@ -130,8 +130,8 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc9_50: %Copy.type = name_ref T, %T.loc9_26.2 [symbolic = %T.loc9_26.1 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc9_50: type = facet_access_type %T.ref.loc9_50 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc9_50.2: type = converted %T.ref.loc9_50, %T.as_type.loc9_50 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc9_50.3: form = init_form %.loc9_50.2, call_param1 [symbolic = %.loc9_50.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc9_50.3: type = converted %T.ref.loc9_50, %T.as_type.loc9_50 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc9_50.4: form = init_form %.loc9_50.3, call_param1 [symbolic = %.loc9_50.2 (constants.%.075d25.1)] // CHECK:STDOUT: %.loc9_34: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -172,7 +172,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.loc9_26.1: %Copy.type = symbolic_binding T, 0 [symbolic = %T.loc9_26.1 (constants.%T.035)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T.loc9_26.1 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %pattern_type.loc9: type = pattern_type %T.binding.as_type [symbolic = %pattern_type.loc9 (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc9_50.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc9_50.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc9_50.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc9_50.2 (constants.%.075d25.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete.loc9: = require_complete_type %T.binding.as_type [symbolic = %require_complete.loc9 (constants.%require_complete.67c)] @@ -223,11 +223,11 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %bound_method.loc11_11.1: = bound_method %.loc11_11.2, %impl.elem0.loc11 // CHECK:STDOUT: %specific_impl_fn.loc11: = specific_impl_function %impl.elem0.loc11, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc10_27.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc11_11.2: = bound_method %.loc11_11.2, %specific_impl_fn.loc11 -// CHECK:STDOUT: %.loc9_47: ref @InitFromStructGeneric.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call.loc11: init @InitFromStructGeneric.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc11_11.2(%.loc11_11.2) to %.loc9_47 +// CHECK:STDOUT: %.loc9_50.1: ref @InitFromStructGeneric.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call.loc11: init @InitFromStructGeneric.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc11_11.2(%.loc11_11.2) to %.loc9_50.1 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %v.var, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%v.var) -// CHECK:STDOUT: return %Copy.Op.call.loc11 to %return +// CHECK:STDOUT: return %Copy.Op.call.loc11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -270,7 +270,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc16: init %i32 = call %bound_method.loc16_11.2(%.loc16_11.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %v.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%v.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call.loc16 to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call.loc16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc15(%self.param: %Class.805) = "no_op"; @@ -279,7 +279,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.loc9_26.1 => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type.loc9 => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc9_50.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc9_50.2 => constants.%.075d25.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- adapt.carbon @@ -346,8 +346,8 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc9_51: %Copy.type = name_ref T, %T.loc9_27.2 [symbolic = %T.loc9_27.1 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc9_51: type = facet_access_type %T.ref.loc9_51 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc9_51.2: type = converted %T.ref.loc9_51, %T.as_type.loc9_51 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc9_51.3: form = init_form %.loc9_51.2, call_param1 [symbolic = %.loc9_51.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc9_51.3: type = converted %T.ref.loc9_51, %T.as_type.loc9_51 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc9_51.4: form = init_form %.loc9_51.3, call_param1 [symbolic = %.loc9_51.2 (constants.%.075d25.1)] // CHECK:STDOUT: %.loc9_35: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -388,7 +388,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.loc9_27.1: %Copy.type = symbolic_binding T, 0 [symbolic = %T.loc9_27.1 (constants.%T.035)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T.loc9_27.1 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc9_51.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc9_51.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc9_51.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc9_51.2 (constants.%.075d25.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete.loc9: = require_complete_type %T.binding.as_type [symbolic = %require_complete.loc9 (constants.%require_complete.67c)] @@ -418,9 +418,9 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %bound_method.loc10_26.1: = bound_method %.loc10_26.2, %impl.elem0.loc10_26.1 // CHECK:STDOUT: %specific_impl_fn.loc10_26.1: = specific_impl_function %impl.elem0.loc10_26.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc10_26.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc10_26.2: = bound_method %.loc10_26.2, %specific_impl_fn.loc10_26.1 -// CHECK:STDOUT: %.loc9_48: ref @InitFromAdaptedGeneric.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @InitFromAdaptedGeneric.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc10_26.2(%.loc10_26.2) to %.loc9_48 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc9_51.1: ref @InitFromAdaptedGeneric.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @InitFromAdaptedGeneric.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc10_26.2(%.loc10_26.2) to %.loc9_51.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -442,13 +442,13 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_28.2: = bound_method %.loc14_28.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc14_28.2(%.loc14_28.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @InitFromAdaptedGeneric(constants.%T.035) { // CHECK:STDOUT: %T.loc9_27.1 => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc9_51.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc9_51.2 => constants.%.075d25.1 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_access.carbon b/toolchain/check/testdata/class/generic/member_access.carbon index fe191a069ca7..61edf1201cc4 100644 --- a/toolchain/check/testdata/class/generic/member_access.carbon +++ b/toolchain/check/testdata/class/generic/member_access.carbon @@ -185,8 +185,8 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %specific_impl_fn.loc9_16.1: = specific_impl_function %impl.elem0.loc9_16.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc9_16.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc9_16.2: = bound_method %.loc9_16.2, %specific_impl_fn.loc9_16.1 // CHECK:STDOUT: -// CHECK:STDOUT: %Copy.Op.call: init @Class.Get.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc9_16.2(%.loc9_16.2) to %.loc7_24 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %Copy.Op.call: init @Class.Get.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc9_16.2(%.loc9_16.2) to %.loc7_27.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -214,7 +214,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %specific_impl_fn.loc15_12.1: = specific_impl_function %impl.elem0.loc15_12.1, @Copy.Op(constants.%Copy.facet.8e7) [symbolic = %specific_impl_fn.loc15_12.2 (constants.%specific_impl_fn.0df)] // CHECK:STDOUT: %bound_method.loc15_12.2: = bound_method %addr, %specific_impl_fn.loc15_12.1 // CHECK:STDOUT: %Copy.Op.call: init @Class.GetAddr.%ptr.loc13_36.1 (%ptr.e7d) = call %bound_method.loc15_12.2(%addr) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -229,7 +229,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc22_11.2: = bound_method %.loc22_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc22_11.2(%.loc22_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @MethodCall(%x.param: %Class.06a) -> %i32 { @@ -241,7 +241,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class.Get.specific_fn: = specific_function %Get.ref, @Class.Get(constants.%Copy.facet.de4) [concrete = constants.%Class.Get.specific_fn] // CHECK:STDOUT: %bound_method: = bound_method %x.ref, %Class.Get.specific_fn // CHECK:STDOUT: %Class.Get.call: init %i32 = call %bound_method(%x.ref) -// CHECK:STDOUT: return %Class.Get.call to %return +// CHECK:STDOUT: return %Class.Get.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @AddrMethodCall(%p.param: %ptr.7d6) -> %i32 { @@ -263,7 +263,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc34_10.2: = bound_method %.loc34_10.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc34_10.2(%.loc34_10.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Class(constants.%T.035) { @@ -287,7 +287,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class => constants.%Class.847 // CHECK:STDOUT: %pattern_type.loc7_10 => constants.%pattern_type.893 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type -// CHECK:STDOUT: %.loc7_27.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc7_27.2 => constants.%.075d25.1 // CHECK:STDOUT: %pattern_type.loc7_24 => constants.%pattern_type.9b9f0c.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -322,7 +322,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class => constants.%Class.06a // CHECK:STDOUT: %pattern_type.loc7_10 => constants.%pattern_type.cea // CHECK:STDOUT: %T.binding.as_type => constants.%i32 -// CHECK:STDOUT: %.loc7_27.1 => constants.%.4d5 +// CHECK:STDOUT: %.loc7_27.2 => constants.%.4d5 // CHECK:STDOUT: %pattern_type.loc7_24 => constants.%pattern_type.7ce // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -391,15 +391,15 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Make.ref: @StaticMemberFunctionCall.%Class.Make.type (%Class.Make.type) = name_ref Make, %.loc10 [symbolic = %Class.Make (constants.%Class.Make)] // CHECK:STDOUT: %Class.Make.specific_fn.loc10_18.1: = specific_function %Make.ref, @Class.Make(constants.%T) [symbolic = %Class.Make.specific_fn.loc10_18.2 (constants.%Class.Make.specific_fn)] // CHECK:STDOUT: -// CHECK:STDOUT: %Class.Make.call: init @StaticMemberFunctionCall.%Class.loc8_49.1 (%Class) = call %Class.Make.specific_fn.loc10_18.1() to %.loc8_39 -// CHECK:STDOUT: return %Class.Make.call to %return +// CHECK:STDOUT: %Class.Make.call: init @StaticMemberFunctionCall.%Class.loc8_49.1 (%Class) = call %Class.Make.specific_fn.loc10_18.1() to %.loc8_49.1 +// CHECK:STDOUT: return %Class.Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @StaticMemberFunctionCall(constants.%T) { // CHECK:STDOUT: %T.loc8_29.1 => constants.%T // CHECK:STDOUT: %Class.loc8_49.1 => constants.%Class -// CHECK:STDOUT: %.loc8_49.1 => constants.%.859 +// CHECK:STDOUT: %.loc8_49.2 => constants.%.859 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.466 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_inline.carbon b/toolchain/check/testdata/class/generic/member_inline.carbon index 7c3646d13294..35d5d22df82a 100644 --- a/toolchain/check/testdata/class/generic/member_inline.carbon +++ b/toolchain/check/testdata/class/generic/member_inline.carbon @@ -120,8 +120,8 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_17: %Copy.type = name_ref T, @Class.%T.loc5_13.2 [symbolic = %T (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc6_17: type = facet_access_type %T.ref.loc6_17 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc6_17.2: type = converted %T.ref.loc6_17, %T.as_type.loc6_17 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc6_17.3: form = init_form %.loc6_17.2, call_param1 [symbolic = %.loc6_17.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc6_17.3: type = converted %T.ref.loc6_17, %T.as_type.loc6_17 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc6_17.4: form = init_form %.loc6_17.3, call_param1 [symbolic = %.loc6_17.2 (constants.%.075d25.1)] // CHECK:STDOUT: %n.param: @Class.F.%T.binding.as_type (%T.binding.as_type) = value_param call_param0 // CHECK:STDOUT: %.loc6_11.1: type = splice_block %.loc6_11.2 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] { // CHECK:STDOUT: %T.ref.loc6_11: %Copy.type = name_ref T, @Class.%T.loc5_13.2 [symbolic = %T (constants.%T.035)] @@ -140,8 +140,8 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref: %Copy.type = name_ref T, @Class.%T.loc5_13.2 [symbolic = %T (constants.%T.035)] // CHECK:STDOUT: %T.as_type: type = facet_access_type %T.ref [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc10_25.2: type = converted %T.ref, %T.as_type [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc10_25.3: form = init_form %.loc10_25.2, call_param1 [symbolic = %.loc10_25.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc10_25.3: type = converted %T.ref, %T.as_type [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc10_25.4: form = init_form %.loc10_25.3, call_param1 [symbolic = %.loc10_25.2 (constants.%.075d25.1)] // CHECK:STDOUT: %self.param: @Class.G.%Class (%Class) = value_param call_param0 // CHECK:STDOUT: %.loc10_14.1: type = splice_block %Self.ref [symbolic = %Class (constants.%Class)] { // CHECK:STDOUT: %.loc10_14.2: type = specific_constant constants.%Class, @Class(constants.%T.035) [symbolic = %Class (constants.%Class)] @@ -171,7 +171,7 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: %T: %Copy.type = symbolic_binding T, 0 [symbolic = %T (constants.%T.035)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc6_17.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc6_17.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc6_17.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc6_17.2 (constants.%.075d25.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete: = require_complete_type %T.binding.as_type [symbolic = %require_complete (constants.%require_complete.67c)] @@ -187,9 +187,9 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: %bound_method.loc7_12.1: = bound_method %n.ref, %impl.elem0.loc7_12.1 // CHECK:STDOUT: %specific_impl_fn.loc7_12.1: = specific_impl_function %impl.elem0.loc7_12.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc7_12.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc7_12.2: = bound_method %n.ref, %specific_impl_fn.loc7_12.1 -// CHECK:STDOUT: %.loc6_14: ref @Class.F.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @Class.F.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc7_12.2(%n.ref) to %.loc6_14 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc6_17.1: ref @Class.F.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @Class.F.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc7_12.2(%n.ref) to %.loc6_17.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -198,7 +198,7 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %pattern_type.loc10_8: type = pattern_type %Class [symbolic = %pattern_type.loc10_8 (constants.%pattern_type.893)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc10_25.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc10_25.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc10_25.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc10_25.2 (constants.%.075d25.1)] // CHECK:STDOUT: %pattern_type.loc10_22: type = pattern_type %T.binding.as_type [symbolic = %pattern_type.loc10_22 (constants.%pattern_type.9b9f0c.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -220,9 +220,9 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: %bound_method.loc11_16.1: = bound_method %.loc11_16.2, %impl.elem0.loc11_16.1 // CHECK:STDOUT: %specific_impl_fn.loc11_16.1: = specific_impl_function %impl.elem0.loc11_16.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc11_16.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc11_16.2: = bound_method %.loc11_16.2, %specific_impl_fn.loc11_16.1 -// CHECK:STDOUT: %.loc10_22: ref @Class.G.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @Class.G.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc11_16.2(%.loc11_16.2) to %.loc10_22 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc10_25.1: ref @Class.G.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @Class.G.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc11_16.2(%.loc11_16.2) to %.loc10_25.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -246,7 +246,7 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: %T => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc6_17.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc6_17.2 => constants.%.075d25.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Class.G(constants.%T.035) { @@ -254,7 +254,7 @@ class C(T:! Core.Copy) { // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: %pattern_type.loc10_8 => constants.%pattern_type.893 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type -// CHECK:STDOUT: %.loc10_25.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc10_25.2 => constants.%.075d25.1 // CHECK:STDOUT: %pattern_type.loc10_22 => constants.%pattern_type.9b9f0c.1 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_lookup.carbon b/toolchain/check/testdata/class/generic/member_lookup.carbon index 8c4b061b1752..f295f43f64f9 100644 --- a/toolchain/check/testdata/class/generic/member_lookup.carbon +++ b/toolchain/check/testdata/class/generic/member_lookup.carbon @@ -122,8 +122,8 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %specific_impl_fn.loc15_11.1: = specific_impl_function %impl.elem0.loc15_11.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc15_11.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc15_11.2: = bound_method %.loc15_11.2, %specific_impl_fn.loc15_11.1 // CHECK:STDOUT: -// CHECK:STDOUT: %Copy.Op.call: init @AccessDerived.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc15_11.2(%.loc15_11.2) to %.loc13_48 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %Copy.Op.call: init @AccessDerived.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc15_11.2(%.loc15_11.2) to %.loc13_51.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -153,8 +153,8 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %specific_impl_fn.loc21_11.1: = specific_impl_function %impl.elem0.loc21_11.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc21_11.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc21_11.2: = bound_method %.loc21_11.4, %specific_impl_fn.loc21_11.1 // CHECK:STDOUT: -// CHECK:STDOUT: %Copy.Op.call: init @AccessBase.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc21_11.2(%.loc21_11.4) to %.loc19_45 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %Copy.Op.call: init @AccessBase.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc21_11.2(%.loc21_11.4) to %.loc19_48.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -163,7 +163,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %Derived.loc13_45.1 => constants.%Derived.ad7 // CHECK:STDOUT: %pattern_type.loc13_33 => constants.%pattern_type.d85 -// CHECK:STDOUT: %.loc13_51.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc13_51.2 => constants.%.075d25.1 // CHECK:STDOUT: %pattern_type.loc13_48 => constants.%pattern_type.9b9f0c.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -172,7 +172,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %Derived.loc19_42.1 => constants.%Derived.ad7 // CHECK:STDOUT: %pattern_type.loc19_30 => constants.%pattern_type.d85 -// CHECK:STDOUT: %.loc19_48.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc19_48.2 => constants.%.075d25.1 // CHECK:STDOUT: %pattern_type.loc19_45 => constants.%pattern_type.9b9f0c.1 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_out_of_line.carbon b/toolchain/check/testdata/class/generic/member_out_of_line.carbon index 4ebf01bf230a..b557c27bf558 100644 --- a/toolchain/check/testdata/class/generic/member_out_of_line.carbon +++ b/toolchain/check/testdata/class/generic/member_out_of_line.carbon @@ -175,8 +175,8 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %T.loc11: %Copy.type = symbolic_binding T, 0 [symbolic = @Class.%T.loc5_13.1 (constants.%T.035)] // CHECK:STDOUT: %T.ref.loc11_36: %Copy.type = name_ref T, %T.loc11 [symbolic = %T.loc6 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc11_36: type = facet_access_type %T.ref.loc11_36 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc11_36.1: type = converted %T.ref.loc11_36, %T.as_type.loc11_36 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc11_36.2: form = init_form %.loc11_36.1, call_param1 [symbolic = %.loc6_17.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc11_36.2: type = converted %T.ref.loc11_36, %T.as_type.loc11_36 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc11_36.3: form = init_form %.loc11_36.2, call_param1 [symbolic = %.loc6_17.1 (constants.%.075d25.1)] // CHECK:STDOUT: %n.param.loc11: @Class.F.%T.binding.as_type (%T.binding.as_type) = value_param call_param0 // CHECK:STDOUT: %.loc11_30.1: type = splice_block %.loc11_30.2 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] { // CHECK:STDOUT: %T.ref.loc11_30: %Copy.type = name_ref T, %T.loc11 [symbolic = %T.loc6 (constants.%T.035)] @@ -201,8 +201,8 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %T.loc15: %Copy.type = symbolic_binding T, 0 [symbolic = @Class.%T.loc5_13.1 (constants.%T.035)] // CHECK:STDOUT: %T.ref.loc15: %Copy.type = name_ref T, %T.loc15 [symbolic = %T.loc7 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc15: type = facet_access_type %T.ref.loc15 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc15_44.1: type = converted %T.ref.loc15, %T.as_type.loc15 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc15_44.2: form = init_form %.loc15_44.1, call_param1 [symbolic = %.loc7_25.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc15_44.2: type = converted %T.ref.loc15, %T.as_type.loc15 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc15_44.3: form = init_form %.loc15_44.2, call_param1 [symbolic = %.loc7_25.1 (constants.%.075d25.1)] // CHECK:STDOUT: %self.param.loc15: @Class.G.%Class (%Class) = value_param call_param0 // CHECK:STDOUT: %.loc15_33.1: type = splice_block %Self.ref.loc15 [symbolic = %Class (constants.%Class)] { // CHECK:STDOUT: %.loc15_33.2: type = specific_constant constants.%Class, @Class(constants.%T.035) [symbolic = %Class (constants.%Class)] @@ -305,9 +305,9 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %bound_method.loc12_10.1: = bound_method %n.ref, %impl.elem0.loc12_10.1 // CHECK:STDOUT: %specific_impl_fn.loc12_10.1: = specific_impl_function %impl.elem0.loc12_10.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc12_10.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc12_10.2: = bound_method %n.ref, %specific_impl_fn.loc12_10.1 -// CHECK:STDOUT: %.loc11_33: ref @Class.F.%T.binding.as_type (%T.binding.as_type) = splice_block %return.loc11 {} -// CHECK:STDOUT: %Copy.Op.call: init @Class.F.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc12_10.2(%n.ref) to %.loc11_33 -// CHECK:STDOUT: return %Copy.Op.call to %return.loc11 +// CHECK:STDOUT: %.loc11_36.1: ref @Class.F.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param.loc11 {} +// CHECK:STDOUT: %Copy.Op.call: init @Class.F.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc12_10.2(%n.ref) to %.loc11_36.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param.loc11 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -338,9 +338,9 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %bound_method.loc16_14.1: = bound_method %.loc16_14.2, %impl.elem0.loc16_14.1 // CHECK:STDOUT: %specific_impl_fn.loc16_14.1: = specific_impl_function %impl.elem0.loc16_14.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc16_14.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc16_14.2: = bound_method %.loc16_14.2, %specific_impl_fn.loc16_14.1 -// CHECK:STDOUT: %.loc15_41: ref @Class.G.%T.binding.as_type (%T.binding.as_type) = splice_block %return.loc15 {} -// CHECK:STDOUT: %Copy.Op.call: init @Class.G.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc16_14.2(%.loc16_14.2) to %.loc15_41 -// CHECK:STDOUT: return %Copy.Op.call to %return.loc15 +// CHECK:STDOUT: %.loc15_44.1: ref @Class.G.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param.loc15 {} +// CHECK:STDOUT: %Copy.Op.call: init @Class.G.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc16_14.2(%.loc16_14.2) to %.loc15_44.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param.loc15 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_type.carbon b/toolchain/check/testdata/class/generic/member_type.carbon index 025c2dd1a096..0f7d4d52ba85 100644 --- a/toolchain/check/testdata/class/generic/member_type.carbon +++ b/toolchain/check/testdata/class/generic/member_type.carbon @@ -280,12 +280,12 @@ fn Test() -> i32 { // CHECK:STDOUT: %bound_method.loc9_38.1: = bound_method %n.ref, %impl.elem0.loc9_38.1 // CHECK:STDOUT: %specific_impl_fn.loc9_38.1: = specific_impl_function %impl.elem0.loc9_38.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc9_38.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc9_38.2: = bound_method %n.ref, %specific_impl_fn.loc9_38.1 -// CHECK:STDOUT: %.loc9_39.2: ref @Outer.F.%T.binding.as_type (%T.binding.as_type) = class_element_access %return, element0 +// CHECK:STDOUT: %.loc9_39.2: ref @Outer.F.%T.binding.as_type (%T.binding.as_type) = class_element_access %return.param, element0 // CHECK:STDOUT: %Copy.Op.call: init @Outer.F.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc9_38.2(%n.ref) to %.loc9_39.2 // CHECK:STDOUT: %.loc9_39.3: init @Outer.F.%T.binding.as_type (%T.binding.as_type) = initialize_from %Copy.Op.call to %.loc9_39.2 -// CHECK:STDOUT: %.loc9_39.4: init @Outer.F.%Inner (%Inner.bcf) = class_init (%.loc9_39.3), %return +// CHECK:STDOUT: %.loc9_39.4: init @Outer.F.%Inner (%Inner.bcf) = class_init (%.loc9_39.3), %return.param // CHECK:STDOUT: %.loc9_40: init @Outer.F.%Inner (%Inner.bcf) = converted %.loc9_39.1, %.loc9_39.4 -// CHECK:STDOUT: return %.loc9_40 to %return +// CHECK:STDOUT: return %.loc9_40 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -342,7 +342,7 @@ fn Test() -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc14_11.2(%.loc14_11.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %c.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%c.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %Inner.74c) = "no_op"; @@ -593,7 +593,7 @@ fn Test() -> i32 { // CHECK:STDOUT: %return.param_patt: @C.as.Inner.impl.F.%pattern_type.loc11_23 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref: type = name_ref T, @Outer.%T.loc4_13.2 [symbolic = %T (constants.%T)] -// CHECK:STDOUT: %.loc11_26.2: form = init_form %T.ref, call_param1 [symbolic = %.loc11_26.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc11_26.3: form = init_form %T.ref, call_param1 [symbolic = %.loc11_26.2 (constants.%.e5f)] // CHECK:STDOUT: %self.param: @C.as.Inner.impl.F.%C (%C.131) = value_param call_param0 // CHECK:STDOUT: %.loc11_18.1: type = splice_block %C.ref [symbolic = %C (constants.%C.131)] { // CHECK:STDOUT: %.loc11_18.2: type = specific_constant @Outer.%C.decl, @Outer(constants.%T) [symbolic = %C (constants.%C.131)] @@ -716,7 +716,7 @@ fn Test() -> i32 { // CHECK:STDOUT: %T: type = symbolic_binding T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T) [symbolic = %C (constants.%C.131)] // CHECK:STDOUT: %pattern_type.loc11_12: type = pattern_type %C [symbolic = %pattern_type.loc11_12 (constants.%pattern_type.fe7)] -// CHECK:STDOUT: %.loc11_26.1: form = init_form %T, call_param1 [symbolic = %.loc11_26.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc11_26.2: form = init_form %T, call_param1 [symbolic = %.loc11_26.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc11_23: type = pattern_type %T [symbolic = %pattern_type.loc11_23 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -745,9 +745,9 @@ fn Test() -> i32 { // CHECK:STDOUT: %bound_method.loc11_41: = bound_method %self.ref, %impl.elem0.loc11_41.1 // CHECK:STDOUT: %specific_impl_fn.loc11_41.1: = specific_impl_function %impl.elem0.loc11_41.1, @Inner.F(constants.%T, constants.%Inner.facet.f78) [symbolic = %specific_impl_fn.loc11_41.2 (constants.%specific_impl_fn)] // CHECK:STDOUT: %bound_method.loc11_52: = bound_method %self.ref, %specific_impl_fn.loc11_41.1 -// CHECK:STDOUT: %.loc11_23: ref @C.as.Inner.impl.F.%T (%T) = splice_block %return {} -// CHECK:STDOUT: %Inner.F.call: init @C.as.Inner.impl.F.%T (%T) = call %bound_method.loc11_52(%self.ref) to %.loc11_23 -// CHECK:STDOUT: return %Inner.F.call to %return +// CHECK:STDOUT: %.loc11_26.1: ref @C.as.Inner.impl.F.%T (%T) = splice_block %return.param {} +// CHECK:STDOUT: %Inner.F.call: init @C.as.Inner.impl.F.%T (%T) = call %bound_method.loc11_52(%self.ref) to %.loc11_26.1 +// CHECK:STDOUT: return %Inner.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -790,7 +790,7 @@ fn Test() -> i32 { // CHECK:STDOUT: %C.as.Inner.impl.F.call: init %i32 = call %bound_method.loc24_33(%.loc24_10) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %c.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%c.var) -// CHECK:STDOUT: return %C.as.Inner.impl.F.call to %return +// CHECK:STDOUT: return %C.as.Inner.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %C.d3f) = "no_op"; @@ -844,7 +844,7 @@ fn Test() -> i32 { // CHECK:STDOUT: %T => constants.%T // CHECK:STDOUT: %C => constants.%C.131 // CHECK:STDOUT: %pattern_type.loc11_12 => constants.%pattern_type.fe7 -// CHECK:STDOUT: %.loc11_26.1 => constants.%.e5f +// CHECK:STDOUT: %.loc11_26.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc11_23 => constants.%pattern_type.51d // CHECK:STDOUT: } // CHECK:STDOUT: @@ -917,7 +917,7 @@ fn Test() -> i32 { // CHECK:STDOUT: %T => constants.%i32 // CHECK:STDOUT: %C => constants.%C.d3f // CHECK:STDOUT: %pattern_type.loc11_12 => constants.%pattern_type.129 -// CHECK:STDOUT: %.loc11_26.1 => constants.%.4d5 +// CHECK:STDOUT: %.loc11_26.2 => constants.%.4d5 // CHECK:STDOUT: %pattern_type.loc11_23 => constants.%pattern_type.7ce // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/class/generic/method_deduce.carbon b/toolchain/check/testdata/class/generic/method_deduce.carbon index 85dcc6f2eed6..47847b40fa3c 100644 --- a/toolchain/check/testdata/class/generic/method_deduce.carbon +++ b/toolchain/check/testdata/class/generic/method_deduce.carbon @@ -120,9 +120,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: } { // CHECK:STDOUT: %A.ref.loc23_39: type = name_ref A, file.%A.decl [concrete = constants.%A] // CHECK:STDOUT: %B.ref.loc23: type = name_ref B, file.%B.decl [concrete = constants.%B] -// CHECK:STDOUT: %.loc23_43.1: %tuple.type.24b = tuple_literal (%A.ref.loc23_39, %B.ref.loc23) [concrete = constants.%tuple.5bc] -// CHECK:STDOUT: %.loc23_43.2: type = converted %.loc23_43.1, constants.%tuple.type.e87 [concrete = constants.%tuple.type.e87] -// CHECK:STDOUT: %.loc23_43.3: form = init_form %.loc23_43.2, call_param1 [concrete = constants.%.c61] +// CHECK:STDOUT: %.loc23_43.2: %tuple.type.24b = tuple_literal (%A.ref.loc23_39, %B.ref.loc23) [concrete = constants.%tuple.5bc] +// CHECK:STDOUT: %.loc23_43.3: type = converted %.loc23_43.2, constants.%tuple.type.e87 [concrete = constants.%tuple.type.e87] +// CHECK:STDOUT: %.loc23_43.4: form = init_form %.loc23_43.3, call_param1 [concrete = constants.%.c61] // CHECK:STDOUT: %c.param: %Class.802 = value_param call_param0 // CHECK:STDOUT: %.loc23_32: type = splice_block %Class [concrete = constants.%Class.802] { // CHECK:STDOUT: %Class.ref: %Class.type = name_ref Class, file.%Class.decl [concrete = constants.%Class.generic] @@ -141,9 +141,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: } { // CHECK:STDOUT: %A.ref.loc27_58: type = name_ref A, file.%A.decl [concrete = constants.%A] // CHECK:STDOUT: %B.ref.loc27: type = name_ref B, file.%B.decl [concrete = constants.%B] -// CHECK:STDOUT: %.loc27_62.1: %tuple.type.24b = tuple_literal (%A.ref.loc27_58, %B.ref.loc27) [concrete = constants.%tuple.5bc] -// CHECK:STDOUT: %.loc27_62.2: type = converted %.loc27_62.1, constants.%tuple.type.e87 [concrete = constants.%tuple.type.e87] -// CHECK:STDOUT: %.loc27_62.3: form = init_form %.loc27_62.2, call_param1 [concrete = constants.%.c61] +// CHECK:STDOUT: %.loc27_62.2: %tuple.type.24b = tuple_literal (%A.ref.loc27_58, %B.ref.loc27) [concrete = constants.%tuple.5bc] +// CHECK:STDOUT: %.loc27_62.3: type = converted %.loc27_62.2, constants.%tuple.type.e87 [concrete = constants.%tuple.type.e87] +// CHECK:STDOUT: %.loc27_62.4: form = init_form %.loc27_62.3, call_param1 [concrete = constants.%.c61] // CHECK:STDOUT: %c.param: %Class.802 = value_param call_param0 // CHECK:STDOUT: %.loc27_51: type = splice_block %Class [concrete = constants.%Class.802] { // CHECK:STDOUT: %Class.ref: %Class.type = name_ref Class, file.%Class.decl [concrete = constants.%Class.generic] @@ -189,9 +189,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref: type = name_ref T, @Class.%T.loc18_13.2 [symbolic = %T (constants.%T)] // CHECK:STDOUT: %U.ref.loc19_27: type = name_ref U, %U.loc19_10.2 [symbolic = %U.loc19_10.1 (constants.%U)] -// CHECK:STDOUT: %.loc19_28.2: %tuple.type.24b = tuple_literal (%T.ref, %U.ref.loc19_27) [symbolic = %tuple (constants.%tuple.4b9)] -// CHECK:STDOUT: %.loc19_28.3: type = converted %.loc19_28.2, constants.%tuple.type.a5e [symbolic = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc19_28.4: form = init_form %.loc19_28.3, call_param0 [symbolic = %.loc19_28.1 (constants.%.5b7)] +// CHECK:STDOUT: %.loc19_28.3: %tuple.type.24b = tuple_literal (%T.ref, %U.ref.loc19_27) [symbolic = %tuple (constants.%tuple.4b9)] +// CHECK:STDOUT: %.loc19_28.4: type = converted %.loc19_28.3, constants.%tuple.type.a5e [symbolic = %tuple.type (constants.%tuple.type.a5e)] +// CHECK:STDOUT: %.loc19_28.5: form = init_form %.loc19_28.4, call_param0 [symbolic = %.loc19_28.2 (constants.%.5b7)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %U.loc19_10.2: type = symbolic_binding U, 1 [symbolic = %U.loc19_10.1 (constants.%U)] // CHECK:STDOUT: %return.param: ref @Class.Get.%tuple.type (%tuple.type.a5e) = out_param call_param0 @@ -206,9 +206,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc20_38: type = name_ref T, @Class.%T.loc18_13.2 [symbolic = %T (constants.%T)] // CHECK:STDOUT: %U.ref.loc20_41: type = name_ref U, %U.loc20_24.2 [symbolic = %U.loc20_24.1 (constants.%U)] -// CHECK:STDOUT: %.loc20_42.2: %tuple.type.24b = tuple_literal (%T.ref.loc20_38, %U.ref.loc20_41) [symbolic = %tuple (constants.%tuple.4b9)] -// CHECK:STDOUT: %.loc20_42.3: type = converted %.loc20_42.2, constants.%tuple.type.a5e [symbolic = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc20_42.4: form = init_form %.loc20_42.3, call_param1 [symbolic = %.loc20_42.1 (constants.%.541)] +// CHECK:STDOUT: %.loc20_42.3: %tuple.type.24b = tuple_literal (%T.ref.loc20_38, %U.ref.loc20_41) [symbolic = %tuple (constants.%tuple.4b9)] +// CHECK:STDOUT: %.loc20_42.4: type = converted %.loc20_42.3, constants.%tuple.type.a5e [symbolic = %tuple.type (constants.%tuple.type.a5e)] +// CHECK:STDOUT: %.loc20_42.5: form = init_form %.loc20_42.4, call_param1 [symbolic = %.loc20_42.2 (constants.%.541)] // CHECK:STDOUT: %x.param: @Class.GetNoDeduce.%T (%T) = value_param call_param0 // CHECK:STDOUT: %T.ref.loc20_21: type = name_ref T, @Class.%T.loc18_13.2 [symbolic = %T (constants.%T)] // CHECK:STDOUT: %x: @Class.GetNoDeduce.%T (%T) = value_binding x, %x.param @@ -233,7 +233,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %T: type = symbolic_binding T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: %tuple: %tuple.type.24b = tuple_value (%T, %U.loc19_10.1) [symbolic = %tuple (constants.%tuple.4b9)] // CHECK:STDOUT: %tuple.type: type = tuple_type (%T, %U.loc19_10.1) [symbolic = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc19_28.1: form = init_form %tuple.type, call_param0 [symbolic = %.loc19_28.1 (constants.%.5b7)] +// CHECK:STDOUT: %.loc19_28.2: form = init_form %tuple.type, call_param0 [symbolic = %.loc19_28.2 (constants.%.5b7)] // CHECK:STDOUT: %pattern_type: type = pattern_type %tuple.type [symbolic = %pattern_type (constants.%pattern_type.eee)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -248,9 +248,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %Get.ref: @Class.Get.%Class.Get.type (%Class.Get.type.ab7) = name_ref Get, %.loc19_39 [symbolic = %Class.Get (constants.%Class.Get.ecd)] // CHECK:STDOUT: %U.ref.loc19_43: type = name_ref U, %U.loc19_10.2 [symbolic = %U.loc19_10.1 (constants.%U)] // CHECK:STDOUT: %Class.Get.specific_fn.loc19_39.1: = specific_function %Get.ref, @Class.Get(constants.%T, constants.%U) [symbolic = %Class.Get.specific_fn.loc19_39.2 (constants.%Class.Get.specific_fn.f51)] -// CHECK:STDOUT: %.loc19_20: ref @Class.Get.%tuple.type (%tuple.type.a5e) = splice_block %return {} -// CHECK:STDOUT: %Class.Get.call: init @Class.Get.%tuple.type (%tuple.type.a5e) = call %Class.Get.specific_fn.loc19_39.1() to %.loc19_20 -// CHECK:STDOUT: return %Class.Get.call to %return +// CHECK:STDOUT: %.loc19_28.1: ref @Class.Get.%tuple.type (%tuple.type.a5e) = splice_block %return.param {} +// CHECK:STDOUT: %Class.Get.call: init @Class.Get.%tuple.type (%tuple.type.a5e) = call %Class.Get.specific_fn.loc19_39.1() to %.loc19_28.1 +// CHECK:STDOUT: return %Class.Get.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -260,7 +260,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %U.loc20_24.1: type = symbolic_binding U, 1 [symbolic = %U.loc20_24.1 (constants.%U)] // CHECK:STDOUT: %tuple: %tuple.type.24b = tuple_value (%T, %U.loc20_24.1) [symbolic = %tuple (constants.%tuple.4b9)] // CHECK:STDOUT: %tuple.type: type = tuple_type (%T, %U.loc20_24.1) [symbolic = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc20_42.1: form = init_form %tuple.type, call_param1 [symbolic = %.loc20_42.1 (constants.%.541)] +// CHECK:STDOUT: %.loc20_42.2: form = init_form %tuple.type, call_param1 [symbolic = %.loc20_42.2 (constants.%.541)] // CHECK:STDOUT: %pattern_type.loc20_34: type = pattern_type %tuple.type [symbolic = %pattern_type.loc20_34 (constants.%pattern_type.eee)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -277,9 +277,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %x.ref: @Class.GetNoDeduce.%T (%T) = name_ref x, %x // CHECK:STDOUT: %U.ref.loc20_68: type = name_ref U, %U.loc20_24.2 [symbolic = %U.loc20_24.1 (constants.%U)] // CHECK:STDOUT: %Class.GetNoDeduce.specific_fn.loc20_53.1: = specific_function %GetNoDeduce.ref, @Class.GetNoDeduce(constants.%T, constants.%U) [symbolic = %Class.GetNoDeduce.specific_fn.loc20_53.2 (constants.%Class.GetNoDeduce.specific_fn.710)] -// CHECK:STDOUT: %.loc20_34: ref @Class.GetNoDeduce.%tuple.type (%tuple.type.a5e) = splice_block %return {} -// CHECK:STDOUT: %Class.GetNoDeduce.call: init @Class.GetNoDeduce.%tuple.type (%tuple.type.a5e) = call %Class.GetNoDeduce.specific_fn.loc20_53.1(%x.ref) to %.loc20_34 -// CHECK:STDOUT: return %Class.GetNoDeduce.call to %return +// CHECK:STDOUT: %.loc20_42.1: ref @Class.GetNoDeduce.%tuple.type (%tuple.type.a5e) = splice_block %return.param {} +// CHECK:STDOUT: %Class.GetNoDeduce.call: init @Class.GetNoDeduce.%tuple.type (%tuple.type.a5e) = call %Class.GetNoDeduce.specific_fn.loc20_53.1(%x.ref) to %.loc20_42.1 +// CHECK:STDOUT: return %Class.GetNoDeduce.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -290,9 +290,9 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %Get.ref: %Class.Get.type.a01 = name_ref Get, %.loc24 [concrete = constants.%Class.Get.5f3] // CHECK:STDOUT: %B.ref.loc24: type = name_ref B, file.%B.decl [concrete = constants.%B] // CHECK:STDOUT: %Class.Get.specific_fn: = specific_function %Get.ref, @Class.Get(constants.%A, constants.%B) [concrete = constants.%Class.Get.specific_fn.54d] -// CHECK:STDOUT: %.loc23_35: ref %tuple.type.e87 = splice_block %return {} -// CHECK:STDOUT: %Class.Get.call: init %tuple.type.e87 = call %Class.Get.specific_fn() to %.loc23_35 -// CHECK:STDOUT: return %Class.Get.call to %return +// CHECK:STDOUT: %.loc23_43.1: ref %tuple.type.e87 = splice_block %return.param {} +// CHECK:STDOUT: %Class.Get.call: init %tuple.type.e87 = call %Class.Get.specific_fn() to %.loc23_43.1 +// CHECK:STDOUT: return %Class.Get.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallGenericMethodWithNonDeducedParam(%c.param: %Class.802) -> %return.param: %tuple.type.e87 { @@ -303,16 +303,16 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %.loc28_25.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] // CHECK:STDOUT: %B.ref.loc28: type = name_ref B, file.%B.decl [concrete = constants.%B] // CHECK:STDOUT: %Class.GetNoDeduce.specific_fn: = specific_function %GetNoDeduce.ref, @Class.GetNoDeduce(constants.%A, constants.%B) [concrete = constants.%Class.GetNoDeduce.specific_fn.83b] -// CHECK:STDOUT: %.loc27_54: ref %tuple.type.e87 = splice_block %return {} +// CHECK:STDOUT: %.loc27_62.1: ref %tuple.type.e87 = splice_block %return.param {} // CHECK:STDOUT: %.loc28_25.2: ref %A = temporary_storage // CHECK:STDOUT: %.loc28_25.3: init %A = class_init (), %.loc28_25.2 [concrete = constants.%A.val] // CHECK:STDOUT: %.loc28_25.4: ref %A = temporary %.loc28_25.2, %.loc28_25.3 // CHECK:STDOUT: %.loc28_25.5: ref %A = converted %.loc28_25.1, %.loc28_25.4 // CHECK:STDOUT: %.loc28_25.6: %A = acquire_value %.loc28_25.5 -// CHECK:STDOUT: %Class.GetNoDeduce.call: init %tuple.type.e87 = call %Class.GetNoDeduce.specific_fn(%.loc28_25.6) to %.loc27_54 +// CHECK:STDOUT: %Class.GetNoDeduce.call: init %tuple.type.e87 = call %Class.GetNoDeduce.specific_fn(%.loc28_25.6) to %.loc27_62.1 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc28_25.4, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc28_25.4) -// CHECK:STDOUT: return %Class.GetNoDeduce.call to %return +// CHECK:STDOUT: return %Class.GetNoDeduce.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %A) = "no_op"; @@ -332,7 +332,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %T => constants.%T // CHECK:STDOUT: %tuple => constants.%tuple.4b9 // CHECK:STDOUT: %tuple.type => constants.%tuple.type.a5e -// CHECK:STDOUT: %.loc19_28.1 => constants.%.5b7 +// CHECK:STDOUT: %.loc19_28.2 => constants.%.5b7 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.eee // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -348,7 +348,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %U.loc20_24.1 => constants.%U // CHECK:STDOUT: %tuple => constants.%tuple.4b9 // CHECK:STDOUT: %tuple.type => constants.%tuple.type.a5e -// CHECK:STDOUT: %.loc20_42.1 => constants.%.541 +// CHECK:STDOUT: %.loc20_42.2 => constants.%.541 // CHECK:STDOUT: %pattern_type.loc20_34 => constants.%pattern_type.eee // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -374,7 +374,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %T => constants.%A // CHECK:STDOUT: %tuple => constants.%tuple.5bc // CHECK:STDOUT: %tuple.type => constants.%tuple.type.e87 -// CHECK:STDOUT: %.loc19_28.1 => constants.%.a4d +// CHECK:STDOUT: %.loc19_28.2 => constants.%.a4d // CHECK:STDOUT: %pattern_type => constants.%pattern_type.b74 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -390,7 +390,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %U.loc20_24.1 => constants.%B // CHECK:STDOUT: %tuple => constants.%tuple.5bc // CHECK:STDOUT: %tuple.type => constants.%tuple.type.e87 -// CHECK:STDOUT: %.loc20_42.1 => constants.%.c61 +// CHECK:STDOUT: %.loc20_42.2 => constants.%.c61 // CHECK:STDOUT: %pattern_type.loc20_34 => constants.%pattern_type.b74 // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/class/generic/self.carbon b/toolchain/check/testdata/class/generic/self.carbon index b35a08c67316..49565b5e2b62 100644 --- a/toolchain/check/testdata/class/generic/self.carbon +++ b/toolchain/check/testdata/class/generic/self.carbon @@ -141,9 +141,9 @@ class Class(T:! type) { // CHECK:STDOUT: fn() -> %return.param: @Class.MakeSelf.%Class (%Class) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc18_35.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc18_35.2: init @Class.MakeSelf.%Class (%Class) = class_init (), %return [symbolic = %Class.val (constants.%Class.val)] +// CHECK:STDOUT: %.loc18_35.2: init @Class.MakeSelf.%Class (%Class) = class_init (), %return.param [symbolic = %Class.val (constants.%Class.val)] // CHECK:STDOUT: %.loc18_36: init @Class.MakeSelf.%Class (%Class) = converted %.loc18_35.1, %.loc18_35.2 [symbolic = %Class.val (constants.%Class.val)] -// CHECK:STDOUT: return %.loc18_36 to %return +// CHECK:STDOUT: return %.loc18_36 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -160,9 +160,9 @@ class Class(T:! type) { // CHECK:STDOUT: fn() -> %return.param: @Class.MakeClass.%Class.loc19_28.1 (%Class) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc19_40.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc19_40.2: init @Class.MakeClass.%Class.loc19_28.1 (%Class) = class_init (), %return [symbolic = %Class.val (constants.%Class.val)] +// CHECK:STDOUT: %.loc19_40.2: init @Class.MakeClass.%Class.loc19_28.1 (%Class) = class_init (), %return.param [symbolic = %Class.val (constants.%Class.val)] // CHECK:STDOUT: %.loc19_41: init @Class.MakeClass.%Class.loc19_28.1 (%Class) = converted %.loc19_40.1, %.loc19_40.2 [symbolic = %Class.val (constants.%Class.val)] -// CHECK:STDOUT: return %.loc19_41 to %return +// CHECK:STDOUT: return %.loc19_41 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/inheritance_access.carbon b/toolchain/check/testdata/class/inheritance_access.carbon index 4ba7fc7fa55b..5b19b05ba48f 100644 --- a/toolchain/check/testdata/class/inheritance_access.carbon +++ b/toolchain/check/testdata/class/inheritance_access.carbon @@ -413,7 +413,7 @@ class B { // CHECK:STDOUT: %specific_fn.loc13_17: = specific_function %impl.elem0.loc13_17, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc13_17.2: = bound_method %.loc13_17.4, %specific_fn.loc13_17 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc13_17: init %i32 = call %bound_method.loc13_17.2(%.loc13_17.4) -// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc13_27.2: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc13_17 to %tuple.elem0 // CHECK:STDOUT: %.loc13_25.4: %i32 = acquire_value %.loc13_25.3 // CHECK:STDOUT: %impl.elem0.loc13_25: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] @@ -421,11 +421,11 @@ class B { // CHECK:STDOUT: %specific_fn.loc13_25: = specific_function %impl.elem0.loc13_25, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc13_25.2: = bound_method %.loc13_25.4, %specific_fn.loc13_25 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc13_25: init %i32 = call %bound_method.loc13_25.2(%.loc13_25.4) -// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc13_27.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc13_25 to %tuple.elem1 -// CHECK:STDOUT: %.loc13_27.4: init %tuple.type.d07 = tuple_init (%.loc13_27.2, %.loc13_27.3) to %return +// CHECK:STDOUT: %.loc13_27.4: init %tuple.type.d07 = tuple_init (%.loc13_27.2, %.loc13_27.3) to %return.param // CHECK:STDOUT: %.loc13_28: init %tuple.type.d07 = converted %.loc13_27.1, %.loc13_27.4 -// CHECK:STDOUT: return %.loc13_28 to %return +// CHECK:STDOUT: return %.loc13_28 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- shadowing_access.carbon @@ -556,7 +556,7 @@ class B { // CHECK:STDOUT: %self.ref: %C = name_ref self, %self // CHECK:STDOUT: %F.ref: %A.F.type = name_ref F, @A.%A.F.decl [concrete = constants.%A.F] // CHECK:STDOUT: %A.F.call: init %empty_tuple.type = call %F.ref() -// CHECK:STDOUT: return %A.F.call to %return +// CHECK:STDOUT: return %A.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- inherited_member_access.carbon @@ -720,7 +720,7 @@ class B { // CHECK:STDOUT: %bound_method.loc7_13.2: = bound_method %int_5, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc7_13.2(%int_5) [concrete = constants.%int_5.0f6] // CHECK:STDOUT: %.loc7: init %i32 = converted %int_5, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_5.0f6] -// CHECK:STDOUT: return %.loc7 to %return +// CHECK:STDOUT: return %.loc7 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B.G() -> %i32 { @@ -732,7 +732,7 @@ class B { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_13.2: = bound_method %SOME_CONSTANT.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc15_13.2(%SOME_CONSTANT.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B.H() -> %i32 { @@ -740,7 +740,7 @@ class B { // CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [concrete = constants.%A] // CHECK:STDOUT: %SomeProtectedFunction.ref: %A.SomeProtectedFunction.type = name_ref SomeProtectedFunction, @A.%A.SomeProtectedFunction.decl [concrete = constants.%A.SomeProtectedFunction] // CHECK:STDOUT: %A.SomeProtectedFunction.call: init %i32 = call %SomeProtectedFunction.ref() -// CHECK:STDOUT: return %A.SomeProtectedFunction.call to %return +// CHECK:STDOUT: return %A.SomeProtectedFunction.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_inherited_private_field_access.carbon @@ -831,7 +831,7 @@ class B { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %self.ref: %Square = name_ref self, %self // CHECK:STDOUT: %y.ref: = name_ref y, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- noninstance_private_on_self.carbon @@ -1182,7 +1182,7 @@ class B { // CHECK:STDOUT: fn @C.G1() -> %i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %SOME_PRIVATE_CONSTANT.ref: = name_ref SOME_PRIVATE_CONSTANT, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.G2() { @@ -1452,7 +1452,7 @@ class B { // CHECK:STDOUT: %SOME_PRIVATE_CONSTANT.ref: = name_ref SOME_PRIVATE_CONSTANT, [concrete = ] // CHECK:STDOUT: %A.ref.loc33: type = name_ref A, file.%A.decl [concrete = constants.%A] // CHECK:STDOUT: %SOME_PROTECTED_CONSTANT.ref: = name_ref SOME_PROTECTED_CONSTANT, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B.SomeFunc(%self.param: %B) -> %i32 { @@ -1462,7 +1462,7 @@ class B { // CHECK:STDOUT: %.loc44_16.1: ref %Internal = class_element_access %self.ref, element0 // CHECK:STDOUT: %.loc44_16.2: %Internal = acquire_value %.loc44_16.1 // CHECK:STDOUT: %INTERNAL_CONSTANT.ref: = name_ref INTERNAL_CONSTANT, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_compound_member_access.carbon diff --git a/toolchain/check/testdata/class/init.carbon b/toolchain/check/testdata/class/init.carbon index 163ab7cc5af0..59c26455a0bf 100644 --- a/toolchain/check/testdata/class/init.carbon +++ b/toolchain/check/testdata/class/init.carbon @@ -172,18 +172,18 @@ fn MakeReorder(n: i32, next: Class*) -> Class { // CHECK:STDOUT: %specific_fn.loc21_16: = specific_function %impl.elem0.loc21_16, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc21_16.2: = bound_method %n.ref, %specific_fn.loc21_16 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc21_16.2(%n.ref) -// CHECK:STDOUT: %.loc21_31.2: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc21_31.2: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc21_31.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call to %.loc21_31.2 // CHECK:STDOUT: %impl.elem0.loc21_27: %.105 = impl_witness_access constants.%Copy.impl_witness.9d3, element0 [concrete = constants.%ptr.as.Copy.impl.Op.120] // CHECK:STDOUT: %bound_method.loc21_27.1: = bound_method %next.ref, %impl.elem0.loc21_27 // CHECK:STDOUT: %specific_fn.loc21_27: = specific_function %impl.elem0.loc21_27, @ptr.as.Copy.impl.Op(constants.%Class) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc21_27.2: = bound_method %next.ref, %specific_fn.loc21_27 // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.8e5 = call %bound_method.loc21_27.2(%next.ref) -// CHECK:STDOUT: %.loc21_31.4: ref %ptr.8e5 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc21_31.4: ref %ptr.8e5 = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc21_31.5: init %ptr.8e5 = initialize_from %ptr.as.Copy.impl.Op.call to %.loc21_31.4 -// CHECK:STDOUT: %.loc21_31.6: init %Class = class_init (%.loc21_31.3, %.loc21_31.5), %return +// CHECK:STDOUT: %.loc21_31.6: init %Class = class_init (%.loc21_31.3, %.loc21_31.5), %return.param // CHECK:STDOUT: %.loc21_32: init %Class = converted %.loc21_31.1, %.loc21_31.6 -// CHECK:STDOUT: return %.loc21_32 to %return +// CHECK:STDOUT: return %.loc21_32 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @MakeReorder(%n.param: %i32, %next.param: %ptr.8e5) -> %return.param: %Class { @@ -196,17 +196,17 @@ fn MakeReorder(n: i32, next: Class*) -> Class { // CHECK:STDOUT: %specific_fn.loc25_30: = specific_function %impl.elem0.loc25_30, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc25_30.2: = bound_method %n.ref, %specific_fn.loc25_30 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc25_30.2(%n.ref) -// CHECK:STDOUT: %.loc25_31.2: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc25_31.2: ref %i32 = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc25_31.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call to %.loc25_31.2 // CHECK:STDOUT: %impl.elem0.loc25_19: %.105 = impl_witness_access constants.%Copy.impl_witness.9d3, element0 [concrete = constants.%ptr.as.Copy.impl.Op.120] // CHECK:STDOUT: %bound_method.loc25_19.1: = bound_method %next.ref, %impl.elem0.loc25_19 // CHECK:STDOUT: %specific_fn.loc25_19: = specific_function %impl.elem0.loc25_19, @ptr.as.Copy.impl.Op(constants.%Class) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc25_19.2: = bound_method %next.ref, %specific_fn.loc25_19 // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.8e5 = call %bound_method.loc25_19.2(%next.ref) -// CHECK:STDOUT: %.loc25_31.4: ref %ptr.8e5 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc25_31.4: ref %ptr.8e5 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc25_31.5: init %ptr.8e5 = initialize_from %ptr.as.Copy.impl.Op.call to %.loc25_31.4 -// CHECK:STDOUT: %.loc25_31.6: init %Class = class_init (%.loc25_31.3, %.loc25_31.5), %return +// CHECK:STDOUT: %.loc25_31.6: init %Class = class_init (%.loc25_31.3, %.loc25_31.5), %return.param // CHECK:STDOUT: %.loc25_32: init %Class = converted %.loc25_31.1, %.loc25_31.6 -// CHECK:STDOUT: return %.loc25_32 to %return +// CHECK:STDOUT: return %.loc25_32 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/init_as.carbon b/toolchain/check/testdata/class/init_as.carbon index f24b68e8da1e..f6928c640444 100644 --- a/toolchain/check/testdata/class/init_as.carbon +++ b/toolchain/check/testdata/class/init_as.carbon @@ -168,7 +168,7 @@ fn F() -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc21_37.2(%.loc21_37.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc21_26.10, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc21_26.10) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %Class) = "no_op"; diff --git a/toolchain/check/testdata/class/init_nested.carbon b/toolchain/check/testdata/class/init_nested.carbon index 406ee5ba1781..729d6f10633b 100644 --- a/toolchain/check/testdata/class/init_nested.carbon +++ b/toolchain/check/testdata/class/init_nested.carbon @@ -129,14 +129,14 @@ fn MakeOuter() -> Outer { // CHECK:STDOUT: fn @MakeOuter() -> %return.param: %Outer { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %MakeInner.ref.loc28_16: %MakeInner.type = name_ref MakeInner, file.%MakeInner.decl [concrete = constants.%MakeInner] -// CHECK:STDOUT: %.loc28_45.1: ref %Inner = class_element_access %return, element0 +// CHECK:STDOUT: %.loc28_45.1: ref %Inner = class_element_access %return.param, element0 // CHECK:STDOUT: %MakeInner.call.loc28_26: init %Inner = call %MakeInner.ref.loc28_16() to %.loc28_45.1 // CHECK:STDOUT: %MakeInner.ref.loc28_34: %MakeInner.type = name_ref MakeInner, file.%MakeInner.decl [concrete = constants.%MakeInner] -// CHECK:STDOUT: %.loc28_45.2: ref %Inner = class_element_access %return, element1 +// CHECK:STDOUT: %.loc28_45.2: ref %Inner = class_element_access %return.param, element1 // CHECK:STDOUT: %MakeInner.call.loc28_44: init %Inner = call %MakeInner.ref.loc28_34() to %.loc28_45.2 // CHECK:STDOUT: %.loc28_45.3: %struct_type.c.d.8f4 = struct_literal (%MakeInner.call.loc28_26, %MakeInner.call.loc28_44) -// CHECK:STDOUT: %.loc28_45.4: init %Outer = class_init (%MakeInner.call.loc28_26, %MakeInner.call.loc28_44), %return +// CHECK:STDOUT: %.loc28_45.4: init %Outer = class_init (%MakeInner.call.loc28_26, %MakeInner.call.loc28_44), %return.param // CHECK:STDOUT: %.loc28_46: init %Outer = converted %.loc28_45.3, %.loc28_45.4 -// CHECK:STDOUT: return %.loc28_46 to %return +// CHECK:STDOUT: return %.loc28_46 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/local.carbon b/toolchain/check/testdata/class/local.carbon index cca2c2dccb55..1ceb415b629a 100644 --- a/toolchain/check/testdata/class/local.carbon +++ b/toolchain/check/testdata/class/local.carbon @@ -173,7 +173,7 @@ class A { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc26_20.2(%.loc26_20.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc26_19.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc26_19.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B.Make() -> %return.param: %B { @@ -190,14 +190,14 @@ class A { // CHECK:STDOUT: %bound_method.loc19_39.2: = bound_method %int_1, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc19_39.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc19_39.2: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc19_39.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc19_39.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc19_39.4: init %i32 = initialize_from %.loc19_39.2 to %.loc19_39.3 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc19_39.5: init %B = class_init (%.loc19_39.4), %return [concrete = constants.%B.val] +// CHECK:STDOUT: %.loc19_39.5: init %B = class_init (%.loc19_39.4), %return.param [concrete = constants.%B.val] // CHECK:STDOUT: %.loc19_18: init %B = converted %.loc19_39.1, %.loc19_39.5 [concrete = constants.%B.val] -// CHECK:STDOUT: assign %return, %.loc19_18 +// CHECK:STDOUT: assign %return.param, %.loc19_18 // CHECK:STDOUT: %Self.ref.loc19: type = name_ref Self, constants.%B [concrete = constants.%B] -// CHECK:STDOUT: %b: ref %B = ref_binding b, %return -// CHECK:STDOUT: return %b to %return +// CHECK:STDOUT: %b: ref %B = ref_binding b, %return.param +// CHECK:STDOUT: return %b to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %B) = "no_op"; diff --git a/toolchain/check/testdata/class/method.carbon b/toolchain/check/testdata/class/method.carbon index dc5e2a2f256e..cbf1ebd0766a 100644 --- a/toolchain/check/testdata/class/method.carbon +++ b/toolchain/check/testdata/class/method.carbon @@ -364,7 +364,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc25_14.2: = bound_method %.loc25_14.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc25_14.2(%.loc25_14.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.loc24 +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param.loc24 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.G(%self.param: %Class) -> %i32; @@ -375,7 +375,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %F.ref: %Class.F.type = name_ref F, @Class.%Class.F.decl [concrete = constants.%Class.F] // CHECK:STDOUT: %Class.F.bound: = bound_method %c.ref, %F.ref // CHECK:STDOUT: %Class.F.call: init %i32 = call %Class.F.bound(%c.ref) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallAlias(%c.param: %Class) -> %i32 { @@ -384,7 +384,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %A.ref: %Class.F.type = name_ref A, @Class.%A [concrete = constants.%Class.F] // CHECK:STDOUT: %Class.F.bound: = bound_method %c.ref, %A.ref // CHECK:STDOUT: %Class.F.call: init %i32 = call %Class.F.bound(%c.ref) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallOnConstBoundMethod() -> %i32 { @@ -410,7 +410,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %Class.F.call: init %i32 = call %Class.F.bound(%.loc39_20.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc39_18.7, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc39_18.7) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %Class) = "no_op"; @@ -430,7 +430,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %Class.G.call: init %i32 = call %Class.G.bound(%c.ref) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %c.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%c.var) -// CHECK:STDOUT: return %Class.G.call to %return +// CHECK:STDOUT: return %Class.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallFThroughPointer(%p.param: %ptr.8e5) -> %i32 { @@ -441,7 +441,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %Class.F.bound: = bound_method %.loc48_11.1, %F.ref // CHECK:STDOUT: %.loc48_11.2: %Class = acquire_value %.loc48_11.1 // CHECK:STDOUT: %Class.F.call: init %i32 = call %Class.F.bound(%.loc48_11.2) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallGThroughPointer(%p.param: %ptr.8e5) -> %i32 { @@ -451,7 +451,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %G.ref: %Class.G.type = name_ref G, @Class.%Class.G.decl [concrete = constants.%Class.G] // CHECK:STDOUT: %Class.G.bound: = bound_method %.loc52, %G.ref // CHECK:STDOUT: %Class.G.call: init %i32 = call %Class.G.bound(%.loc52) -// CHECK:STDOUT: return %Class.G.call to %return +// CHECK:STDOUT: return %Class.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Make() -> %return.param: %Class; @@ -468,7 +468,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %Class.F.call: init %i32 = call %Class.F.bound(%.loc58_15.3) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc58_15.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc58_15.2) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallGOnInitializingExpr() -> %i32 { @@ -482,6 +482,6 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %Class.G.call: init %i32 = call %Class.G.bound(%.loc62_15.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc62_15.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc62_15.2) -// CHECK:STDOUT: return %Class.G.call to %return +// CHECK:STDOUT: return %Class.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/nested_name.carbon b/toolchain/check/testdata/class/nested_name.carbon index 0b52b9fb9299..c24dec664ff6 100644 --- a/toolchain/check/testdata/class/nested_name.carbon +++ b/toolchain/check/testdata/class/nested_name.carbon @@ -150,7 +150,7 @@ fn G(o: Outer) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc22_12.2: = bound_method %.loc22_12.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc22_12.2(%.loc22_12.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G(%o.param: %Outer) { diff --git a/toolchain/check/testdata/class/raw_self.carbon b/toolchain/check/testdata/class/raw_self.carbon index f73123acf01a..4e7ccef1d80d 100644 --- a/toolchain/check/testdata/class/raw_self.carbon +++ b/toolchain/check/testdata/class/raw_self.carbon @@ -211,17 +211,17 @@ fn Class.G[self: Self](r#self: i32) -> (i32, i32) { // CHECK:STDOUT: %specific_fn.loc26_15: = specific_function %impl.elem0.loc26_15, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc26_15.2: = bound_method %.loc26_15.2, %specific_fn.loc26_15 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc26_15: init %i32 = call %bound_method.loc26_15.2(%.loc26_15.2) -// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return.loc25, element0 +// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return.param.loc25, element0 // CHECK:STDOUT: %.loc26_25.2: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc26_15 to %tuple.elem0 // CHECK:STDOUT: %impl.elem0.loc26_19: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] // CHECK:STDOUT: %bound_method.loc26_19.1: = bound_method %self.ref.loc26_19, %impl.elem0.loc26_19 // CHECK:STDOUT: %specific_fn.loc26_19: = specific_function %impl.elem0.loc26_19, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc26_19.2: = bound_method %self.ref.loc26_19, %specific_fn.loc26_19 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc26_19: init %i32 = call %bound_method.loc26_19.2(%self.ref.loc26_19) -// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return.loc25, element1 +// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return.param.loc25, element1 // CHECK:STDOUT: %.loc26_25.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc26_19 to %tuple.elem1 -// CHECK:STDOUT: %.loc26_25.4: init %tuple.type.d07 = tuple_init (%.loc26_25.2, %.loc26_25.3) to %return.loc25 +// CHECK:STDOUT: %.loc26_25.4: init %tuple.type.d07 = tuple_init (%.loc26_25.2, %.loc26_25.3) to %return.param.loc25 // CHECK:STDOUT: %.loc26_26: init %tuple.type.d07 = converted %.loc26_25.1, %.loc26_25.4 -// CHECK:STDOUT: return %.loc26_26 to %return.loc25 +// CHECK:STDOUT: return %.loc26_26 to %return.param.loc25 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/reenter_scope.carbon b/toolchain/check/testdata/class/reenter_scope.carbon index 2a8deca4f40f..ab8a5c449c01 100644 --- a/toolchain/check/testdata/class/reenter_scope.carbon +++ b/toolchain/check/testdata/class/reenter_scope.carbon @@ -105,7 +105,7 @@ fn Class.F() -> i32 { // CHECK:STDOUT: %Class.G.call.loc21: init %i32 = call %G.ref.loc21() // CHECK:STDOUT: %G.ref.loc22: %Class.G.type = name_ref G, @Class.%Class.G.decl [concrete = constants.%Class.G] // CHECK:STDOUT: %Class.G.call.loc22: init %i32 = call %G.ref.loc22() -// CHECK:STDOUT: return %Class.G.call.loc22 to %return.loc20 +// CHECK:STDOUT: return %Class.G.call.loc22 to %return.param.loc20 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.G() -> %i32; diff --git a/toolchain/check/testdata/class/reorder.carbon b/toolchain/check/testdata/class/reorder.carbon index 63120f470046..89ddbc5073cb 100644 --- a/toolchain/check/testdata/class/reorder.carbon +++ b/toolchain/check/testdata/class/reorder.carbon @@ -115,7 +115,7 @@ class Class { // CHECK:STDOUT: %Class.ref: type = name_ref Class, file.%Class.decl [concrete = constants.%Class] // CHECK:STDOUT: %F.ref: %Class.F.type = name_ref F, @Class.%Class.F.decl [concrete = constants.%Class.F] // CHECK:STDOUT: %Class.F.call: init %i32 = call %F.ref() -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.F() -> %i32 { @@ -127,6 +127,6 @@ class Class { // CHECK:STDOUT: %bound_method.loc21_13.2: = bound_method %int_1, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc21_13.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc21: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: return %.loc21 to %return +// CHECK:STDOUT: return %.loc21 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/scope.carbon b/toolchain/check/testdata/class/scope.carbon index d0e699a42c53..4132fe5a69a0 100644 --- a/toolchain/check/testdata/class/scope.carbon +++ b/toolchain/check/testdata/class/scope.carbon @@ -154,14 +154,14 @@ fn Run() { // CHECK:STDOUT: %bound_method.loc17_13.2: = bound_method %int_1, %specific_fn [concrete = constants.%bound_method.38b] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc17_13.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc17: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: return %.loc17 to %return +// CHECK:STDOUT: return %.loc17 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.G() -> %i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %Class.F.type = name_ref F, @Class.%Class.F.decl [concrete = constants.%Class.F] // CHECK:STDOUT: %Class.F.call: init %i32 = call %F.ref() -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() -> %i32 { @@ -173,7 +173,7 @@ fn Run() { // CHECK:STDOUT: %bound_method.loc26_11.2: = bound_method %int_2, %specific_fn [concrete = constants.%bound_method.646] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc26_11.2(%int_2) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc26: init %i32 = converted %int_2, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: return %.loc26 to %return +// CHECK:STDOUT: return %.loc26 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Run() { diff --git a/toolchain/check/testdata/class/self.carbon b/toolchain/check/testdata/class/self.carbon index 71aadd486365..1fe657c30cf0 100644 --- a/toolchain/check/testdata/class/self.carbon +++ b/toolchain/check/testdata/class/self.carbon @@ -184,7 +184,7 @@ class Class { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc12_14.2: = bound_method %.loc12_14.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc12_14.2(%.loc12_14.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.loc11 +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param.loc11 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.G(%self.param.loc15: %Class) -> %i32 { @@ -198,7 +198,7 @@ class Class { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc16_14.2: = bound_method %.loc16_14.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc16_14.2(%.loc16_14.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.loc15 +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param.loc15 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_return_self_value.carbon diff --git a/toolchain/check/testdata/class/self_conversion.carbon b/toolchain/check/testdata/class/self_conversion.carbon index 284310d37eb6..5785f28ea8eb 100644 --- a/toolchain/check/testdata/class/self_conversion.carbon +++ b/toolchain/check/testdata/class/self_conversion.carbon @@ -225,7 +225,7 @@ fn Call(p: Derived*) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc27_14.2: = bound_method %.loc27_14.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc27_14.2(%.loc27_14.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.loc26 +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param.loc26 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Derived.RefSelfBase(%self.param.loc30: %Base) { @@ -261,6 +261,6 @@ fn Call(p: Derived*) -> i32 { // CHECK:STDOUT: %.loc36_11.3: ref %Base = converted %.loc36_11.1, %.loc36_11.2 // CHECK:STDOUT: %.loc36_11.4: %Base = acquire_value %.loc36_11.3 // CHECK:STDOUT: %Derived.SelfBase.call: init %i32 = call %Derived.SelfBase.bound(%.loc36_11.4) -// CHECK:STDOUT: return %Derived.SelfBase.call to %return +// CHECK:STDOUT: return %Derived.SelfBase.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/self_type.carbon b/toolchain/check/testdata/class/self_type.carbon index 122176b8f004..2733f010695a 100644 --- a/toolchain/check/testdata/class/self_type.carbon +++ b/toolchain/check/testdata/class/self_type.carbon @@ -145,7 +145,7 @@ fn Class.F[self: Self]() -> i32 { // CHECK:STDOUT: %Class.F.bound: = bound_method %.loc26_11.1, %F.ref // CHECK:STDOUT: %.loc26_11.2: %Class = acquire_value %.loc26_11.1 // CHECK:STDOUT: %Class.F.call: init %i32 = call %Class.F.bound(%.loc26_11.2) -// CHECK:STDOUT: return %Class.F.call to %return.loc25 +// CHECK:STDOUT: return %Class.F.call to %return.param.loc25 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Class.Make() -> %return.param: %Class { @@ -155,7 +155,7 @@ fn Class.F[self: Self]() -> i32 { // CHECK:STDOUT: %s.var_patt: %pattern_type.904 = var_pattern %s.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %Self.ref.loc18: type = name_ref Self, constants.%Class [concrete = constants.%Class] -// CHECK:STDOUT: %s: ref %Class = ref_binding s, %return +// CHECK:STDOUT: %s: ref %Class = ref_binding s, %return.param // CHECK:STDOUT: %s.ref.loc19_5: ref %Class = name_ref s, %s // CHECK:STDOUT: %s.ref.loc19_16: ref %Class = name_ref s, %s // CHECK:STDOUT: %addr: %ptr.8e5 = addr_of %s.ref.loc19_16 @@ -170,6 +170,6 @@ fn Class.F[self: Self]() -> i32 { // CHECK:STDOUT: %.loc19_17.4: init %Class = class_init (%.loc19_17.3), %s.ref.loc19_5 // CHECK:STDOUT: %.loc19_7: init %Class = converted %.loc19_17.1, %.loc19_17.4 // CHECK:STDOUT: assign %s.ref.loc19_5, %.loc19_7 -// CHECK:STDOUT: return %s to %return +// CHECK:STDOUT: return %s to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/static_method.carbon b/toolchain/check/testdata/class/static_method.carbon index 9fd04aea356e..c935bb5468a9 100644 --- a/toolchain/check/testdata/class/static_method.carbon +++ b/toolchain/check/testdata/class/static_method.carbon @@ -112,7 +112,7 @@ fn Run() -> i32 { // CHECK:STDOUT: %Class.F.call: init %i32 = call %F.ref() // CHECK:STDOUT: %DestroyOp.bound: = bound_method %c.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%c.var) -// CHECK:STDOUT: return %Class.F.call to %return +// CHECK:STDOUT: return %Class.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %Class) = "no_op"; diff --git a/toolchain/check/testdata/class/virtual_modifiers.carbon b/toolchain/check/testdata/class/virtual_modifiers.carbon index 986ded13f951..171ea6a0d2c3 100644 --- a/toolchain/check/testdata/class/virtual_modifiers.carbon +++ b/toolchain/check/testdata/class/virtual_modifiers.carbon @@ -2150,9 +2150,9 @@ class T2(G2:! type) { // CHECK:STDOUT: fn @T2.as.ImplicitAs.impl.Convert(%self.param: %T2) -> %return.param: %T1 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc12_13.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc12_13.2: init %T1 = class_init (), %return [concrete = constants.%T1.val] +// CHECK:STDOUT: %.loc12_13.2: init %T1 = class_init (), %return.param [concrete = constants.%T1.val] // CHECK:STDOUT: %.loc12_14: init %T1 = converted %.loc12_13.1, %.loc12_13.2 [concrete = constants.%T1.val] -// CHECK:STDOUT: return %.loc12_14 to %return +// CHECK:STDOUT: return %.loc12_14 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: virtual fn @Base.F(%self.param: %Base) -> %return.param: %T1; diff --git a/toolchain/check/testdata/const/basics.carbon b/toolchain/check/testdata/const/basics.carbon index 2cb87a151ff1..558511fb548d 100644 --- a/toolchain/check/testdata/const/basics.carbon +++ b/toolchain/check/testdata/const/basics.carbon @@ -257,7 +257,7 @@ fn PassConstReferenceToReference(p: const X*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%ptr.c45) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.6a7] // CHECK:STDOUT: %bound_method.loc7_10.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.728 = call %bound_method.loc7_10.2(%p.ref) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B(%p.param: %const.8ce) -> %const.8ce { @@ -268,7 +268,7 @@ fn PassConstReferenceToReference(p: const X*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @const.as.Copy.impl.Op(constants.%Copy.facet.a7f) [concrete = constants.%const.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc11_10.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %const.as.Copy.impl.Op.call: init %const.8ce = call %bound_method.loc11_10.2(%p.ref) -// CHECK:STDOUT: return %const.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %const.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- collapse.carbon @@ -334,6 +334,6 @@ fn PassConstReferenceToReference(p: const X*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%ptr.c45) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc12_10.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.728 = call %bound_method.loc12_10.2(%p.ref) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/deduce/array.carbon b/toolchain/check/testdata/deduce/array.carbon index bbad50f9b76d..eb9e055ee473 100644 --- a/toolchain/check/testdata/deduce/array.carbon +++ b/toolchain/check/testdata/deduce/array.carbon @@ -214,7 +214,7 @@ fn G() { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc6_32 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_35: type = name_ref T, %T.loc6_6.2 [symbolic = %T.loc6_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc6_35.2: form = init_form %T.ref.loc6_35, call_param1 [symbolic = %.loc6_35.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_35.3: form = init_form %T.ref.loc6_35, call_param1 [symbolic = %.loc6_35.2 (constants.%.e5f)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc6_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %a.param: @F.%array_type.loc6_29.1 (%array_type.3ec) = value_param call_param0 @@ -232,7 +232,7 @@ fn G() { // CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc8: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc8_11: form = init_form %C.ref.loc8, call_param0 [concrete = constants.%.64f] +// CHECK:STDOUT: %.loc8_11.2: form = init_form %C.ref.loc8, call_param0 [concrete = constants.%.64f] // CHECK:STDOUT: %return.param: ref %C = out_param call_param0 // CHECK:STDOUT: %return: ref %C = return_slot %return.param // CHECK:STDOUT: } @@ -250,7 +250,7 @@ fn G() { // CHECK:STDOUT: %T.loc6_6.1: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %array_type.loc6_29.1: type = array_type constants.%int_3, %T.loc6_6.1 [symbolic = %array_type.loc6_29.1 (constants.%array_type.3ec)] // CHECK:STDOUT: %pattern_type.loc6_16: type = pattern_type %array_type.loc6_29.1 [symbolic = %pattern_type.loc6_16 (constants.%pattern_type.b3f)] -// CHECK:STDOUT: %.loc6_35.1: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_35.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_35.2: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_35.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc6_32: type = pattern_type %T.loc6_6.1 [symbolic = %pattern_type.loc6_32 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -263,9 +263,9 @@ fn G() { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %a.ref: @F.%array_type.loc6_29.1 (%array_type.3ec) = name_ref a, %a // CHECK:STDOUT: %F.specific_fn.loc6_46.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc6_46.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc6_32: ref @F.%T.loc6_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_46.1(%a.ref) to %.loc6_32 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc6_35.1: ref @F.%T.loc6_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_46.1(%a.ref) to %.loc6_35.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -304,12 +304,12 @@ fn G() { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %a.ref: ref %array_type.931 = name_ref a, %a // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C) [concrete = constants.%F.specific_fn.540] -// CHECK:STDOUT: %.loc8_8: ref %C = splice_block %return {} +// CHECK:STDOUT: %.loc8_11.1: ref %C = splice_block %return.param {} // CHECK:STDOUT: %.loc10: %array_type.931 = acquire_value %a.ref -// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%.loc10) to %.loc8_8 +// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%.loc10) to %.loc8_11.1 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %a.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type.931) = "no_op"; @@ -318,7 +318,7 @@ fn G() { // CHECK:STDOUT: %T.loc6_6.1 => constants.%T // CHECK:STDOUT: %array_type.loc6_29.1 => constants.%array_type.3ec // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.b3f -// CHECK:STDOUT: %.loc6_35.1 => constants.%.e5f +// CHECK:STDOUT: %.loc6_35.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc6_32 => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -331,7 +331,7 @@ fn G() { // CHECK:STDOUT: %T.loc6_6.1 => constants.%C // CHECK:STDOUT: %array_type.loc6_29.1 => constants.%array_type.931 // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.f21 -// CHECK:STDOUT: %.loc6_35.1 => constants.%.887 +// CHECK:STDOUT: %.loc6_35.2 => constants.%.887 // CHECK:STDOUT: %pattern_type.loc6_32 => constants.%pattern_type.7c7 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -499,7 +499,7 @@ fn G() { // CHECK:STDOUT: %bound_method.loc6_62.2: = bound_method %N.ref.loc6_61, %specific_fn [symbolic = %bound_method.loc6_62.3 (constants.%bound_method.7fa)] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_62.1: init %i32 = call %bound_method.loc6_62.2(%N.ref.loc6_61) [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_62.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] // CHECK:STDOUT: %.loc6_62: init %i32 = converted %N.ref.loc6_61, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_62.1 [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_62.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] -// CHECK:STDOUT: return %.loc6_62 to %return +// CHECK:STDOUT: return %.loc6_62 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -542,7 +542,7 @@ fn G() { // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%.loc10) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %a.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type.931) = "no_op"; @@ -812,7 +812,7 @@ fn G() { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc6_32 (%pattern_type.51d1c4.1) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_35: type = name_ref T, %T.loc6_6.2 [symbolic = %T.loc6_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc6_35.2: form = init_form %T.ref.loc6_35, call_param1 [symbolic = %.loc6_35.1 (constants.%.e5ffed.1)] +// CHECK:STDOUT: %.loc6_35.3: form = init_form %T.ref.loc6_35, call_param1 [symbolic = %.loc6_35.2 (constants.%.e5ffed.1)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc6_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %a.param: @F.%array_type.loc6_29.1 (%array_type.a0b) = value_param call_param0 @@ -830,7 +830,7 @@ fn G() { // CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc8: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc8_11: form = init_form %C.ref.loc8, call_param0 [concrete = constants.%.64f] +// CHECK:STDOUT: %.loc8_11.2: form = init_form %C.ref.loc8, call_param0 [concrete = constants.%.64f] // CHECK:STDOUT: %return.param: ref %C = out_param call_param0 // CHECK:STDOUT: %return: ref %C = return_slot %return.param // CHECK:STDOUT: } @@ -848,7 +848,7 @@ fn G() { // CHECK:STDOUT: %T.loc6_6.1: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %array_type.loc6_29.1: type = array_type constants.%int_2, %T.loc6_6.1 [symbolic = %array_type.loc6_29.1 (constants.%array_type.a0b)] // CHECK:STDOUT: %pattern_type.loc6_16: type = pattern_type %array_type.loc6_29.1 [symbolic = %pattern_type.loc6_16 (constants.%pattern_type.b42)] -// CHECK:STDOUT: %.loc6_35.1: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_35.1 (constants.%.e5ffed.1)] +// CHECK:STDOUT: %.loc6_35.2: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_35.2 (constants.%.e5ffed.1)] // CHECK:STDOUT: %pattern_type.loc6_32: type = pattern_type %T.loc6_6.1 [symbolic = %pattern_type.loc6_32 (constants.%pattern_type.51d1c4.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -861,9 +861,9 @@ fn G() { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %a.ref: @F.%array_type.loc6_29.1 (%array_type.a0b) = name_ref a, %a // CHECK:STDOUT: %F.specific_fn.loc6_46.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc6_46.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc6_32: ref @F.%T.loc6_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_46.1(%a.ref) to %.loc6_32 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc6_35.1: ref @F.%T.loc6_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_46.1(%a.ref) to %.loc6_35.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -902,12 +902,12 @@ fn G() { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %a.ref: ref %array_type.931 = name_ref a, %a // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C) [concrete = constants.%F.specific_fn.540] -// CHECK:STDOUT: %.loc8_8: ref %C = splice_block %return {} +// CHECK:STDOUT: %.loc8_11.1: ref %C = splice_block %return.param {} // CHECK:STDOUT: %.loc21: %array_type.158 = converted %a.ref, [concrete = ] -// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn() to %.loc8_8 +// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn() to %.loc8_11.1 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %a.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type.931) = "no_op"; @@ -916,7 +916,7 @@ fn G() { // CHECK:STDOUT: %T.loc6_6.1 => constants.%T // CHECK:STDOUT: %array_type.loc6_29.1 => constants.%array_type.a0b // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.b42 -// CHECK:STDOUT: %.loc6_35.1 => constants.%.e5ffed.1 +// CHECK:STDOUT: %.loc6_35.2 => constants.%.e5ffed.1 // CHECK:STDOUT: %pattern_type.loc6_32 => constants.%pattern_type.51d1c4.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -929,7 +929,7 @@ fn G() { // CHECK:STDOUT: %T.loc6_6.1 => constants.%C // CHECK:STDOUT: %array_type.loc6_29.1 => constants.%array_type.158 // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.6d3 -// CHECK:STDOUT: %.loc6_35.1 => constants.%.887 +// CHECK:STDOUT: %.loc6_35.2 => constants.%.887 // CHECK:STDOUT: %pattern_type.loc6_32 => constants.%pattern_type.7c7 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -1110,7 +1110,7 @@ fn G() { // CHECK:STDOUT: %bound_method.loc7_62.2: = bound_method %N.ref.loc7_61, %specific_fn [symbolic = %bound_method.loc7_62.3 (constants.%bound_method.7fa)] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc7_62.1: init %i32 = call %bound_method.loc7_62.2(%N.ref.loc7_61) [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc7_62.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] // CHECK:STDOUT: %.loc7_62: init %i32 = converted %N.ref.loc7_61, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc7_62.1 [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc7_62.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] -// CHECK:STDOUT: return %.loc7_62 to %return +// CHECK:STDOUT: return %.loc7_62 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1153,7 +1153,7 @@ fn G() { // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn() // CHECK:STDOUT: %DestroyOp.bound: = bound_method %a.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type.b6d) = "no_op"; @@ -1347,7 +1347,7 @@ fn G() { // CHECK:STDOUT: %specific_fn.loc6_47: = specific_function %impl.elem0.loc6_47, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_47.2: = bound_method %N.ref.loc6_47, %specific_fn.loc6_47 [symbolic = %bound_method.loc6_47.3 (constants.%bound_method.207)] // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_47.2(%N.ref.loc6_47) [symbolic = %N.loc6_6.1 (constants.%N.5de)] -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1387,7 +1387,7 @@ fn G() { // CHECK:STDOUT: %a.ref: ref %array_type.931 = name_ref a, %a // CHECK:STDOUT: %DestroyOp.bound: = bound_method %a.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var) -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type.931) = "no_op"; diff --git a/toolchain/check/testdata/deduce/generic_type.carbon b/toolchain/check/testdata/deduce/generic_type.carbon index afe3b556d94e..d3e6ac5832cc 100644 --- a/toolchain/check/testdata/deduce/generic_type.carbon +++ b/toolchain/check/testdata/deduce/generic_type.carbon @@ -130,7 +130,7 @@ fn G() -> i32 { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc7_25 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc7_28: type = name_ref T, %T.loc7_6.2 [symbolic = %T.loc7_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc7_28.2: form = init_form %T.ref.loc7_28, call_param1 [symbolic = %.loc7_28.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc7_28.3: form = init_form %T.ref.loc7_28, call_param1 [symbolic = %.loc7_28.2 (constants.%.e5f)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc7_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc7_6.1 (constants.%T)] // CHECK:STDOUT: %p.param: @F.%C.loc7_22.1 (%C.5a3) = value_param call_param0 @@ -150,7 +150,7 @@ fn G() -> i32 { // CHECK:STDOUT: %return.param_patt: %pattern_type.9c8 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref.loc9_18: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc9_18: form = init_form %D.ref.loc9_18, call_param1 [concrete = constants.%.bb8] +// CHECK:STDOUT: %.loc9_18.2: form = init_form %D.ref.loc9_18, call_param1 [concrete = constants.%.bb8] // CHECK:STDOUT: %p.param: %C.302 = value_param call_param0 // CHECK:STDOUT: %.loc9_12: type = splice_block %C [concrete = constants.%C.302] { // CHECK:STDOUT: %C.ref: %C.type = name_ref C, file.%C.decl [concrete = constants.%C.generic] @@ -189,7 +189,7 @@ fn G() -> i32 { // CHECK:STDOUT: %T.loc7_6.1: type = symbolic_binding T, 0 [symbolic = %T.loc7_6.1 (constants.%T)] // CHECK:STDOUT: %C.loc7_22.1: type = class_type @C, @C(%T.loc7_6.1) [symbolic = %C.loc7_22.1 (constants.%C.5a3)] // CHECK:STDOUT: %pattern_type.loc7_16: type = pattern_type %C.loc7_22.1 [symbolic = %pattern_type.loc7_16 (constants.%pattern_type.3d5)] -// CHECK:STDOUT: %.loc7_28.1: form = init_form %T.loc7_6.1, call_param1 [symbolic = %.loc7_28.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc7_28.2: form = init_form %T.loc7_6.1, call_param1 [symbolic = %.loc7_28.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc7_25: type = pattern_type %T.loc7_6.1 [symbolic = %pattern_type.loc7_25 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -202,9 +202,9 @@ fn G() -> i32 { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%C.loc7_22.1 (%C.5a3) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc7_39.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc7_39.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc7_25: ref @F.%T.loc7_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc7_6.1 (%T) = call %F.specific_fn.loc7_39.1(%p.ref) to %.loc7_25 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc7_28.1: ref @F.%T.loc7_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc7_6.1 (%T) = call %F.specific_fn.loc7_39.1(%p.ref) to %.loc7_28.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -213,9 +213,9 @@ fn G() -> i32 { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %C.302 = name_ref p, %p // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%D) [concrete = constants.%F.specific_fn.e8a] -// CHECK:STDOUT: %.loc9_15: ref %D = splice_block %return {} -// CHECK:STDOUT: %F.call: init %D = call %F.specific_fn(%p.ref) to %.loc9_15 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc9_18.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %D = call %F.specific_fn(%p.ref) to %.loc9_18.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%T) { @@ -228,7 +228,7 @@ fn G() -> i32 { // CHECK:STDOUT: %T.loc7_6.1 => constants.%T // CHECK:STDOUT: %C.loc7_22.1 => constants.%C.5a3 // CHECK:STDOUT: %pattern_type.loc7_16 => constants.%pattern_type.3d5 -// CHECK:STDOUT: %.loc7_28.1 => constants.%.e5f +// CHECK:STDOUT: %.loc7_28.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc7_25 => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -247,7 +247,7 @@ fn G() -> i32 { // CHECK:STDOUT: %T.loc7_6.1 => constants.%D // CHECK:STDOUT: %C.loc7_22.1 => constants.%C.302 // CHECK:STDOUT: %pattern_type.loc7_16 => constants.%pattern_type.a7e -// CHECK:STDOUT: %.loc7_28.1 => constants.%.bb8 +// CHECK:STDOUT: %.loc7_28.2 => constants.%.bb8 // CHECK:STDOUT: %pattern_type.loc7_25 => constants.%pattern_type.9c8 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -314,7 +314,7 @@ fn G() -> i32 { // CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc7_28: form = init_form %C.ref, call_param1 [concrete = constants.%.887] +// CHECK:STDOUT: %.loc7_28.2: form = init_form %C.ref, call_param1 [concrete = constants.%.887] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc7_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc7_6.1 (constants.%T)] // CHECK:STDOUT: %p.param: @F.%I.loc7_22.1 (%I.3cf) = value_param call_param0 @@ -334,7 +334,7 @@ fn G() -> i32 { // CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc9_18: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc9_18: form = init_form %C.ref.loc9_18, call_param1 [concrete = constants.%.887] +// CHECK:STDOUT: %.loc9_18.2: form = init_form %C.ref.loc9_18, call_param1 [concrete = constants.%.887] // CHECK:STDOUT: %p.param: %I.bce = value_param call_param0 // CHECK:STDOUT: %.loc9_12: type = splice_block %I [concrete = constants.%I.bce] { // CHECK:STDOUT: %I.ref: %I.type = name_ref I, file.%I.decl [concrete = constants.%I.generic] @@ -383,9 +383,9 @@ fn G() -> i32 { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%I.loc7_22.1 (%I.3cf) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc7_39.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc7_39.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc7_25: ref %C = splice_block %return {} -// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn.loc7_39.1(%p.ref) to %.loc7_25 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc7_28.1: ref %C = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn.loc7_39.1(%p.ref) to %.loc7_28.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -394,9 +394,9 @@ fn G() -> i32 { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %I.bce = name_ref p, %p // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C) [concrete = constants.%F.specific_fn.540] -// CHECK:STDOUT: %.loc9_15: ref %C = splice_block %return {} -// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%p.ref) to %.loc9_15 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc9_18.1: ref %C = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%p.ref) to %.loc9_18.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @I(constants.%T) { @@ -511,9 +511,9 @@ fn G() -> i32 { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc13_52: type = name_ref T, %T.loc13_6.2 [symbolic = %T.loc13_6.1 (constants.%T)] // CHECK:STDOUT: %U.ref.loc13_55: type = name_ref U, %U.loc13_16.2 [symbolic = %U.loc13_16.1 (constants.%U)] -// CHECK:STDOUT: %.loc13_56.2: %tuple.type.24b = tuple_literal (%T.ref.loc13_52, %U.ref.loc13_55) [symbolic = %tuple (constants.%tuple.4b9)] -// CHECK:STDOUT: %.loc13_56.3: type = converted %.loc13_56.2, constants.%tuple.type.a5e [symbolic = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc13_56.4: form = init_form %.loc13_56.3, call_param1 [symbolic = %.loc13_56.1 (constants.%.541)] +// CHECK:STDOUT: %.loc13_56.3: %tuple.type.24b = tuple_literal (%T.ref.loc13_52, %U.ref.loc13_55) [symbolic = %tuple (constants.%tuple.4b9)] +// CHECK:STDOUT: %.loc13_56.4: type = converted %.loc13_56.3, constants.%tuple.type.a5e [symbolic = %tuple.type (constants.%tuple.type.a5e)] +// CHECK:STDOUT: %.loc13_56.5: form = init_form %.loc13_56.4, call_param1 [symbolic = %.loc13_56.2 (constants.%.541)] // CHECK:STDOUT: %.Self.1: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc13_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc13_6.1 (constants.%T)] // CHECK:STDOUT: %.Self.2: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] @@ -540,9 +540,9 @@ fn G() -> i32 { // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc15_32: type = name_ref C, file.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %D.ref.loc15_35: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc15_36.1: %tuple.type.24b = tuple_literal (%C.ref.loc15_32, %D.ref.loc15_35) [concrete = constants.%tuple.a0a] -// CHECK:STDOUT: %.loc15_36.2: type = converted %.loc15_36.1, constants.%tuple.type.281 [concrete = constants.%tuple.type.281] -// CHECK:STDOUT: %.loc15_36.3: form = init_form %.loc15_36.2, call_param1 [concrete = constants.%.21e] +// CHECK:STDOUT: %.loc15_36.2: %tuple.type.24b = tuple_literal (%C.ref.loc15_32, %D.ref.loc15_35) [concrete = constants.%tuple.a0a] +// CHECK:STDOUT: %.loc15_36.3: type = converted %.loc15_36.2, constants.%tuple.type.281 [concrete = constants.%tuple.type.281] +// CHECK:STDOUT: %.loc15_36.4: form = init_form %.loc15_36.3, call_param1 [concrete = constants.%.21e] // CHECK:STDOUT: %p.param: %Inner.240 = value_param call_param0 // CHECK:STDOUT: %.loc15_25: type = splice_block %Inner [concrete = constants.%Inner.240] { // CHECK:STDOUT: %Outer.ref: %Outer.type = name_ref Outer, file.%Outer.decl [concrete = constants.%Outer.generic] @@ -623,7 +623,7 @@ fn G() -> i32 { // CHECK:STDOUT: %pattern_type.loc13_26: type = pattern_type %Inner.loc13_45.1 [symbolic = %pattern_type.loc13_26 (constants.%pattern_type.0d1)] // CHECK:STDOUT: %tuple: %tuple.type.24b = tuple_value (%T.loc13_6.1, %U.loc13_16.1) [symbolic = %tuple (constants.%tuple.4b9)] // CHECK:STDOUT: %tuple.type: type = tuple_type (%T.loc13_6.1, %U.loc13_16.1) [symbolic = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc13_56.1: form = init_form %tuple.type, call_param1 [symbolic = %.loc13_56.1 (constants.%.541)] +// CHECK:STDOUT: %.loc13_56.2: form = init_form %tuple.type, call_param1 [symbolic = %.loc13_56.2 (constants.%.541)] // CHECK:STDOUT: %pattern_type.loc13_48: type = pattern_type %tuple.type [symbolic = %pattern_type.loc13_48 (constants.%pattern_type.eee)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -636,9 +636,9 @@ fn G() -> i32 { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%Inner.loc13_45.1 (%Inner.e21) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc13_67.1: = specific_function %F.ref, @F(constants.%T, constants.%U) [symbolic = %F.specific_fn.loc13_67.2 (constants.%F.specific_fn.a54)] -// CHECK:STDOUT: %.loc13_48: ref @F.%tuple.type (%tuple.type.a5e) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%tuple.type (%tuple.type.a5e) = call %F.specific_fn.loc13_67.1(%p.ref) to %.loc13_48 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc13_56.1: ref @F.%tuple.type (%tuple.type.a5e) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%tuple.type (%tuple.type.a5e) = call %F.specific_fn.loc13_67.1(%p.ref) to %.loc13_56.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -647,9 +647,9 @@ fn G() -> i32 { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %Inner.240 = name_ref p, %p // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C, constants.%D) [concrete = constants.%F.specific_fn.107] -// CHECK:STDOUT: %.loc15_28: ref %tuple.type.281 = splice_block %return {} -// CHECK:STDOUT: %F.call: init %tuple.type.281 = call %F.specific_fn(%p.ref) to %.loc15_28 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc15_36.1: ref %tuple.type.281 = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %tuple.type.281 = call %F.specific_fn(%p.ref) to %.loc15_36.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Outer(constants.%T) { @@ -677,7 +677,7 @@ fn G() -> i32 { // CHECK:STDOUT: %pattern_type.loc13_26 => constants.%pattern_type.0d1 // CHECK:STDOUT: %tuple => constants.%tuple.4b9 // CHECK:STDOUT: %tuple.type => constants.%tuple.type.a5e -// CHECK:STDOUT: %.loc13_56.1 => constants.%.541 +// CHECK:STDOUT: %.loc13_56.2 => constants.%.541 // CHECK:STDOUT: %pattern_type.loc13_48 => constants.%pattern_type.eee // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -711,7 +711,7 @@ fn G() -> i32 { // CHECK:STDOUT: %pattern_type.loc13_26 => constants.%pattern_type.204 // CHECK:STDOUT: %tuple => constants.%tuple.a0a // CHECK:STDOUT: %tuple.type => constants.%tuple.type.281 -// CHECK:STDOUT: %.loc13_56.1 => constants.%.21e +// CHECK:STDOUT: %.loc13_56.2 => constants.%.21e // CHECK:STDOUT: %pattern_type.loc13_48 => constants.%pattern_type.881 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -894,7 +894,7 @@ fn G() -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_50.2: = bound_method %N.ref.loc6_50, %specific_fn [symbolic = %bound_method.loc6_50.3 (constants.%bound_method.207)] // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_50.2(%N.ref.loc6_50) [symbolic = %N.loc6_6.1 (constants.%N.5de)] -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -921,7 +921,7 @@ fn G() -> i32 { // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%.loc9_15.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc9_13.4, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc9_13.4) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %WithNontype.6bb) = "no_op"; diff --git a/toolchain/check/testdata/deduce/int_float.carbon b/toolchain/check/testdata/deduce/int_float.carbon index c68f7b1557b4..c2ed9d0cced0 100644 --- a/toolchain/check/testdata/deduce/int_float.carbon +++ b/toolchain/check/testdata/deduce/int_float.carbon @@ -165,7 +165,7 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %impl.elem0: %.6b5 = impl_witness_access constants.%Copy.impl_witness.98e, element0 [concrete = constants.%Core.IntLiteral.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %N.ref.loc5, %impl.elem0 [symbolic = %Core.IntLiteral.as.Copy.impl.Op.bound (constants.%Core.IntLiteral.as.Copy.impl.Op.bound.555)] // CHECK:STDOUT: %Core.IntLiteral.as.Copy.impl.Op.call: init Core.IntLiteral = call %bound_method(%N.ref.loc5) [symbolic = %N.loc4_6.1 (constants.%N)] -// CHECK:STDOUT: return %Core.IntLiteral.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Core.IntLiteral.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -175,7 +175,7 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %a.ref: %i64 = name_ref a, %a // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%int_64) [concrete = constants.%F.specific_fn] // CHECK:STDOUT: %F.call: init Core.IntLiteral = call %F.specific_fn(%a.ref) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%N) { @@ -323,7 +323,7 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %impl.elem0: %.6b5 = impl_witness_access constants.%Copy.impl_witness.98e, element0 [concrete = constants.%Core.IntLiteral.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %N.ref.loc5, %impl.elem0 [symbolic = %Core.IntLiteral.as.Copy.impl.Op.bound (constants.%Core.IntLiteral.as.Copy.impl.Op.bound.555)] // CHECK:STDOUT: %Core.IntLiteral.as.Copy.impl.Op.call: init Core.IntLiteral = call %bound_method(%N.ref.loc5) [symbolic = %N.loc4_6.1 (constants.%N)] -// CHECK:STDOUT: return %Core.IntLiteral.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Core.IntLiteral.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -333,7 +333,7 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %a.ref: %f64.d77 = name_ref a, %a // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%int_64) [concrete = constants.%F.specific_fn] // CHECK:STDOUT: %F.call: init Core.IntLiteral = call %F.specific_fn(%a.ref) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%N) { diff --git a/toolchain/check/testdata/deduce/tuple.carbon b/toolchain/check/testdata/deduce/tuple.carbon index 45ee58f161c5..2a2e581dac88 100644 --- a/toolchain/check/testdata/deduce/tuple.carbon +++ b/toolchain/check/testdata/deduce/tuple.carbon @@ -118,7 +118,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc7_40 (%pattern_type.946) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %U.ref.loc7_43: type = name_ref U, %U.loc7_16.2 [symbolic = %U.loc7_16.1 (constants.%U)] -// CHECK:STDOUT: %.loc7_43.2: form = init_form %U.ref.loc7_43, call_param1 [symbolic = %.loc7_43.1 (constants.%.ead)] +// CHECK:STDOUT: %.loc7_43.3: form = init_form %U.ref.loc7_43, call_param1 [symbolic = %.loc7_43.2 (constants.%.ead)] // CHECK:STDOUT: %.Self.1: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc7_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc7_6.1 (constants.%T)] // CHECK:STDOUT: %.Self.2: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] @@ -141,7 +141,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %return.param_patt: %pattern_type.9c8 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref.loc9_23: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc9_23: form = init_form %D.ref.loc9_23, call_param1 [concrete = constants.%.bb8] +// CHECK:STDOUT: %.loc9_23.2: form = init_form %D.ref.loc9_23, call_param1 [concrete = constants.%.bb8] // CHECK:STDOUT: %pair.param: %tuple.type.281 = value_param call_param0 // CHECK:STDOUT: %.loc9_17.1: type = splice_block %.loc9_17.3 [concrete = constants.%tuple.type.281] { // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [concrete = constants.%C] @@ -177,7 +177,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple: %tuple.type.24b = tuple_value (%T.loc7_6.1, %U.loc7_16.1) [symbolic = %tuple (constants.%tuple.4b9)] // CHECK:STDOUT: %tuple.type: type = tuple_type (%T.loc7_6.1, %U.loc7_16.1) [symbolic = %tuple.type (constants.%tuple.type.a5e)] // CHECK:STDOUT: %pattern_type.loc7_26: type = pattern_type %tuple.type [symbolic = %pattern_type.loc7_26 (constants.%pattern_type.eee)] -// CHECK:STDOUT: %.loc7_43.1: form = init_form %U.loc7_16.1, call_param1 [symbolic = %.loc7_43.1 (constants.%.ead)] +// CHECK:STDOUT: %.loc7_43.2: form = init_form %U.loc7_16.1, call_param1 [symbolic = %.loc7_43.2 (constants.%.ead)] // CHECK:STDOUT: %pattern_type.loc7_40: type = pattern_type %U.loc7_16.1 [symbolic = %pattern_type.loc7_40 (constants.%pattern_type.946)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -190,9 +190,9 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %pair.ref: @F.%tuple.type (%tuple.type.a5e) = name_ref pair, %pair // CHECK:STDOUT: %F.specific_fn.loc7_54.1: = specific_function %F.ref, @F(constants.%T, constants.%U) [symbolic = %F.specific_fn.loc7_54.2 (constants.%F.specific_fn.a54)] -// CHECK:STDOUT: %.loc7_40: ref @F.%U.loc7_16.1 (%U) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%U.loc7_16.1 (%U) = call %F.specific_fn.loc7_54.1(%pair.ref) to %.loc7_40 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc7_43.1: ref @F.%U.loc7_16.1 (%U) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%U.loc7_16.1 (%U) = call %F.specific_fn.loc7_54.1(%pair.ref) to %.loc7_43.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -201,9 +201,9 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %pair.ref: %tuple.type.281 = name_ref pair, %pair // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C, constants.%D) [concrete = constants.%F.specific_fn.107] -// CHECK:STDOUT: %.loc9_20: ref %D = splice_block %return {} -// CHECK:STDOUT: %F.call: init %D = call %F.specific_fn(%pair.ref) to %.loc9_20 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc9_23.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %D = call %F.specific_fn(%pair.ref) to %.loc9_23.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T, constants.%U) { @@ -212,7 +212,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple => constants.%tuple.4b9 // CHECK:STDOUT: %tuple.type => constants.%tuple.type.a5e // CHECK:STDOUT: %pattern_type.loc7_26 => constants.%pattern_type.eee -// CHECK:STDOUT: %.loc7_43.1 => constants.%.ead +// CHECK:STDOUT: %.loc7_43.2 => constants.%.ead // CHECK:STDOUT: %pattern_type.loc7_40 => constants.%pattern_type.946 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -227,7 +227,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple => constants.%tuple.a0a // CHECK:STDOUT: %tuple.type => constants.%tuple.type.281 // CHECK:STDOUT: %pattern_type.loc7_26 => constants.%pattern_type.881 -// CHECK:STDOUT: %.loc7_43.1 => constants.%.bb8 +// CHECK:STDOUT: %.loc7_43.2 => constants.%.bb8 // CHECK:STDOUT: %pattern_type.loc7_40 => constants.%pattern_type.9c8 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -460,7 +460,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_60.2: = bound_method %B.ref.loc6_60, %specific_fn [symbolic = %bound_method.loc6_60.3 (constants.%bound_method.dfb)] // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_60.2(%B.ref.loc6_60) [symbolic = %B.loc6_15.1 (constants.%B)] -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -470,7 +470,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %h.ref: %HasPair.867 = name_ref h, %h // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%int_1.5d2, constants.%int_2.ef8) [concrete = constants.%F.specific_fn] // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%h.ref) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @HasPair(constants.%Pair) { @@ -630,7 +630,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %pair.ref: %tuple.type.281 = name_ref pair, %pair -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T) { diff --git a/toolchain/check/testdata/deduce/type_operator.carbon b/toolchain/check/testdata/deduce/type_operator.carbon index 47baf1dc18ed..bcc562d2f473 100644 --- a/toolchain/check/testdata/deduce/type_operator.carbon +++ b/toolchain/check/testdata/deduce/type_operator.carbon @@ -120,7 +120,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc6_23 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_26: type = name_ref T, %T.loc6_6.2 [symbolic = %T.loc6_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc6_26.2: form = init_form %T.ref.loc6_26, call_param1 [symbolic = %.loc6_26.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_26.3: form = init_form %T.ref.loc6_26, call_param1 [symbolic = %.loc6_26.2 (constants.%.e5f)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc6_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %p.param: @F.%ptr.loc6_20.1 (%ptr.e8f) = value_param call_param0 @@ -139,7 +139,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc8_16: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc8_16: form = init_form %C.ref.loc8_16, call_param1 [concrete = constants.%.887] +// CHECK:STDOUT: %.loc8_16.2: form = init_form %C.ref.loc8_16, call_param1 [concrete = constants.%.887] // CHECK:STDOUT: %p.param: %ptr.31e = value_param call_param0 // CHECK:STDOUT: %.loc8_10: type = splice_block %ptr [concrete = constants.%ptr.31e] { // CHECK:STDOUT: %C.ref.loc8_9: type = name_ref C, file.%C.decl [concrete = constants.%C] @@ -163,7 +163,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %T.loc6_6.1: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %ptr.loc6_20.1: type = ptr_type %T.loc6_6.1 [symbolic = %ptr.loc6_20.1 (constants.%ptr.e8f)] // CHECK:STDOUT: %pattern_type.loc6_16: type = pattern_type %ptr.loc6_20.1 [symbolic = %pattern_type.loc6_16 (constants.%pattern_type.4f4)] -// CHECK:STDOUT: %.loc6_26.1: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_26.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_26.2: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_26.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc6_23: type = pattern_type %T.loc6_6.1 [symbolic = %pattern_type.loc6_23 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -176,9 +176,9 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%ptr.loc6_20.1 (%ptr.e8f) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc6_37.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc6_37.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc6_23: ref @F.%T.loc6_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_37.1(%p.ref) to %.loc6_23 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc6_26.1: ref @F.%T.loc6_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_37.1(%p.ref) to %.loc6_26.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -187,16 +187,16 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %ptr.31e = name_ref p, %p // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C) [concrete = constants.%F.specific_fn.540] -// CHECK:STDOUT: %.loc8_13: ref %C = splice_block %return {} -// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%p.ref) to %.loc8_13 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc8_16.1: ref %C = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%p.ref) to %.loc8_16.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T) { // CHECK:STDOUT: %T.loc6_6.1 => constants.%T // CHECK:STDOUT: %ptr.loc6_20.1 => constants.%ptr.e8f // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.4f4 -// CHECK:STDOUT: %.loc6_26.1 => constants.%.e5f +// CHECK:STDOUT: %.loc6_26.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc6_23 => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -209,7 +209,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %T.loc6_6.1 => constants.%C // CHECK:STDOUT: %ptr.loc6_20.1 => constants.%ptr.31e // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.506 -// CHECK:STDOUT: %.loc6_26.1 => constants.%.887 +// CHECK:STDOUT: %.loc6_26.2 => constants.%.887 // CHECK:STDOUT: %pattern_type.loc6_23 => constants.%pattern_type.7c7 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -273,7 +273,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc6_29 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_32: type = name_ref T, %T.loc6_6.2 [symbolic = %T.loc6_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc6_32.2: form = init_form %T.ref.loc6_32, call_param1 [symbolic = %.loc6_32.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_32.3: form = init_form %T.ref.loc6_32, call_param1 [symbolic = %.loc6_32.2 (constants.%.e5f)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc6_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %p.param: @F.%ptr.loc6_26.1 (%ptr.a15) = value_param call_param0 @@ -293,7 +293,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc8_22: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc8_22: form = init_form %C.ref.loc8_22, call_param1 [concrete = constants.%.887] +// CHECK:STDOUT: %.loc8_22.2: form = init_form %C.ref.loc8_22, call_param1 [concrete = constants.%.887] // CHECK:STDOUT: %p.param: %ptr.c45 = value_param call_param0 // CHECK:STDOUT: %.loc8_16: type = splice_block %ptr [concrete = constants.%ptr.c45] { // CHECK:STDOUT: %C.ref.loc8_15: type = name_ref C, file.%C.decl [concrete = constants.%C] @@ -319,7 +319,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %const.loc6_19.1: type = const_type %T.loc6_6.1 [symbolic = %const.loc6_19.1 (constants.%const.4ff)] // CHECK:STDOUT: %ptr.loc6_26.1: type = ptr_type %const.loc6_19.1 [symbolic = %ptr.loc6_26.1 (constants.%ptr.a15)] // CHECK:STDOUT: %pattern_type.loc6_16: type = pattern_type %ptr.loc6_26.1 [symbolic = %pattern_type.loc6_16 (constants.%pattern_type.26f)] -// CHECK:STDOUT: %.loc6_32.1: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_32.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_32.2: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_32.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc6_29: type = pattern_type %T.loc6_6.1 [symbolic = %pattern_type.loc6_29 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -332,9 +332,9 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%ptr.loc6_26.1 (%ptr.a15) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc6_43.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc6_43.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc6_29: ref @F.%T.loc6_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_43.1(%p.ref) to %.loc6_29 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc6_32.1: ref @F.%T.loc6_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_43.1(%p.ref) to %.loc6_32.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -343,9 +343,9 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %ptr.c45 = name_ref p, %p // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C) [concrete = constants.%F.specific_fn.540] -// CHECK:STDOUT: %.loc8_19: ref %C = splice_block %return {} -// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%p.ref) to %.loc8_19 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc8_22.1: ref %C = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %C = call %F.specific_fn(%p.ref) to %.loc8_22.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T) { @@ -353,7 +353,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %const.loc6_19.1 => constants.%const.4ff // CHECK:STDOUT: %ptr.loc6_26.1 => constants.%ptr.a15 // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.26f -// CHECK:STDOUT: %.loc6_32.1 => constants.%.e5f +// CHECK:STDOUT: %.loc6_32.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc6_29 => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -367,7 +367,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %const.loc6_19.1 => constants.%const.0e5 // CHECK:STDOUT: %ptr.loc6_26.1 => constants.%ptr.c45 // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.6eb -// CHECK:STDOUT: %.loc6_32.1 => constants.%.887 +// CHECK:STDOUT: %.loc6_32.2 => constants.%.887 // CHECK:STDOUT: %pattern_type.loc6_29 => constants.%pattern_type.7c7 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -430,7 +430,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc6_23 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_26: type = name_ref T, %T.loc6_6.2 [symbolic = %T.loc6_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc6_26.2: form = init_form %T.ref.loc6_26, call_param1 [symbolic = %.loc6_26.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_26.3: form = init_form %T.ref.loc6_26, call_param1 [symbolic = %.loc6_26.2 (constants.%.e5f)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc6_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %p.param: @F.%ptr.loc6_20.1 (%ptr.e8f) = value_param call_param0 @@ -450,7 +450,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: } { // CHECK:STDOUT: %C.ref.loc8_28: type = name_ref C, file.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %const.loc8_22: type = const_type %C.ref.loc8_28 [concrete = constants.%const] -// CHECK:STDOUT: %.loc8_22: form = init_form %const.loc8_22, call_param1 [concrete = constants.%.b91] +// CHECK:STDOUT: %.loc8_22.2: form = init_form %const.loc8_22, call_param1 [concrete = constants.%.b91] // CHECK:STDOUT: %p.param: %ptr.c45 = value_param call_param0 // CHECK:STDOUT: %.loc8_16: type = splice_block %ptr [concrete = constants.%ptr.c45] { // CHECK:STDOUT: %C.ref.loc8_15: type = name_ref C, file.%C.decl [concrete = constants.%C] @@ -475,7 +475,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %T.loc6_6.1: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %ptr.loc6_20.1: type = ptr_type %T.loc6_6.1 [symbolic = %ptr.loc6_20.1 (constants.%ptr.e8f)] // CHECK:STDOUT: %pattern_type.loc6_16: type = pattern_type %ptr.loc6_20.1 [symbolic = %pattern_type.loc6_16 (constants.%pattern_type.4f4)] -// CHECK:STDOUT: %.loc6_26.1: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_26.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_26.2: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_26.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc6_23: type = pattern_type %T.loc6_6.1 [symbolic = %pattern_type.loc6_23 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -488,9 +488,9 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%ptr.loc6_20.1 (%ptr.e8f) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc6_37.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc6_37.2 (constants.%F.specific_fn.643)] -// CHECK:STDOUT: %.loc6_23: ref @F.%T.loc6_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_37.1(%p.ref) to %.loc6_23 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc6_26.1: ref @F.%T.loc6_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_37.1(%p.ref) to %.loc6_26.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -499,16 +499,16 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %ptr.c45 = name_ref p, %p // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%const) [concrete = constants.%F.specific_fn.98a] -// CHECK:STDOUT: %.loc8_19: ref %const = splice_block %return {} -// CHECK:STDOUT: %F.call: init %const = call %F.specific_fn(%p.ref) to %.loc8_19 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc8_22.1: ref %const = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %const = call %F.specific_fn(%p.ref) to %.loc8_22.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T) { // CHECK:STDOUT: %T.loc6_6.1 => constants.%T // CHECK:STDOUT: %ptr.loc6_20.1 => constants.%ptr.e8f // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.4f4 -// CHECK:STDOUT: %.loc6_26.1 => constants.%.e5f +// CHECK:STDOUT: %.loc6_26.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc6_23 => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -521,7 +521,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %T.loc6_6.1 => constants.%const // CHECK:STDOUT: %ptr.loc6_20.1 => constants.%ptr.c45 // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.6eb -// CHECK:STDOUT: %.loc6_26.1 => constants.%.b91 +// CHECK:STDOUT: %.loc6_26.2 => constants.%.b91 // CHECK:STDOUT: %pattern_type.loc6_23 => constants.%pattern_type.03b // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -583,7 +583,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %return.param_patt: @F.%pattern_type.loc6_29 (%pattern_type.51d) = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc6_32: type = name_ref T, %T.loc6_6.2 [symbolic = %T.loc6_6.1 (constants.%T)] -// CHECK:STDOUT: %.loc6_32.2: form = init_form %T.ref.loc6_32, call_param1 [symbolic = %.loc6_32.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_32.3: form = init_form %T.ref.loc6_32, call_param1 [symbolic = %.loc6_32.2 (constants.%.e5f)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc6_6.2: type = symbolic_binding T, 0 [symbolic = %T.loc6_6.1 (constants.%T)] // CHECK:STDOUT: %p.param: @F.%ptr.loc6_26.1 (%ptr.a15) = value_param call_param0 @@ -629,7 +629,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %const.loc6_19.1: type = const_type %T.loc6_6.1 [symbolic = %const.loc6_19.1 (constants.%const.4ff)] // CHECK:STDOUT: %ptr.loc6_26.1: type = ptr_type %const.loc6_19.1 [symbolic = %ptr.loc6_26.1 (constants.%ptr.a15)] // CHECK:STDOUT: %pattern_type.loc6_16: type = pattern_type %ptr.loc6_26.1 [symbolic = %pattern_type.loc6_16 (constants.%pattern_type.26f)] -// CHECK:STDOUT: %.loc6_32.1: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_32.1 (constants.%.e5f)] +// CHECK:STDOUT: %.loc6_32.2: form = init_form %T.loc6_6.1, call_param1 [symbolic = %.loc6_32.2 (constants.%.e5f)] // CHECK:STDOUT: %pattern_type.loc6_29: type = pattern_type %T.loc6_6.1 [symbolic = %pattern_type.loc6_29 (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -642,9 +642,9 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: @F.%ptr.loc6_26.1 (%ptr.a15) = name_ref p, %p // CHECK:STDOUT: %F.specific_fn.loc6_43.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc6_43.2 (constants.%F.specific_fn)] -// CHECK:STDOUT: %.loc6_29: ref @F.%T.loc6_6.1 (%T) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_43.1(%p.ref) to %.loc6_29 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc6_32.1: ref @F.%T.loc6_6.1 (%T) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%T.loc6_6.1 (%T) = call %F.specific_fn.loc6_43.1(%p.ref) to %.loc6_32.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -652,7 +652,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: %p.ref: %ptr.31e = name_ref p, %p -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T) { @@ -660,7 +660,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %const.loc6_19.1 => constants.%const.4ff // CHECK:STDOUT: %ptr.loc6_26.1 => constants.%ptr.a15 // CHECK:STDOUT: %pattern_type.loc6_16 => constants.%pattern_type.26f -// CHECK:STDOUT: %.loc6_32.1 => constants.%.e5f +// CHECK:STDOUT: %.loc6_32.2 => constants.%.e5f // CHECK:STDOUT: %pattern_type.loc6_29 => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/facet/access.carbon b/toolchain/check/testdata/facet/access.carbon index 6da37c558d4c..cac723ff617c 100644 --- a/toolchain/check/testdata/facet/access.carbon +++ b/toolchain/check/testdata/facet/access.carbon @@ -495,15 +495,15 @@ fn F2(U:! Z) { // CHECK:STDOUT: %impl.elem0.loc10_11.1: @Use.%.loc10_11.2 (%.37d) = impl_witness_access constants.%I.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc10_11.2 (constants.%impl.elem0)] // CHECK:STDOUT: %specific_impl_fn.loc10_11.1: = specific_impl_function %impl.elem0.loc10_11.1, @I.Make(constants.%T) [symbolic = %specific_impl_fn.loc10_11.2 (constants.%specific_impl_fn)] // CHECK:STDOUT: -// CHECK:STDOUT: %I.Make.call: init @Use.%T.binding.as_type (%T.binding.as_type) = call %specific_impl_fn.loc10_11.1() to %.loc8_15 -// CHECK:STDOUT: return %I.Make.call to %return +// CHECK:STDOUT: %I.Make.call: init @Use.%T.binding.as_type (%T.binding.as_type) = call %specific_impl_fn.loc10_11.1() to %.loc8_18.1 +// CHECK:STDOUT: return %I.Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Use(constants.%T) { // CHECK:STDOUT: %T.loc8_8.1 => constants.%T // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type -// CHECK:STDOUT: %.loc8_18.1 => constants.%.a23 +// CHECK:STDOUT: %.loc8_18.2 => constants.%.a23 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.422 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -541,8 +541,8 @@ fn F2(U:! Z) { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc9_24: %I.type = name_ref T, %T.loc9_8.2 [symbolic = %T.loc9_8.1 (constants.%T)] // CHECK:STDOUT: %T.as_type.loc9_24: type = facet_access_type %T.ref.loc9_24 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc9_24.2: type = converted %T.ref.loc9_24, %T.as_type.loc9_24 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc9_24.3: form = init_form %.loc9_24.2, call_param1 [symbolic = %.loc9_24.1 (constants.%.33a)] +// CHECK:STDOUT: %.loc9_24.3: type = converted %T.ref.loc9_24, %T.as_type.loc9_24 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc9_24.4: form = init_form %.loc9_24.3, call_param1 [symbolic = %.loc9_24.2 (constants.%.33a)] // CHECK:STDOUT: %.loc9_12: type = splice_block %I.ref [concrete = constants.%I.type] { // CHECK:STDOUT: // CHECK:STDOUT: %I.ref: type = name_ref I, file.%I.decl [concrete = constants.%I.type] @@ -564,7 +564,7 @@ fn F2(U:! Z) { // CHECK:STDOUT: %T.loc9_8.1: %I.type = symbolic_binding T, 0 [symbolic = %T.loc9_8.1 (constants.%T)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T.loc9_8.1 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.422)] -// CHECK:STDOUT: %.loc9_24.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc9_24.1 (constants.%.33a)] +// CHECK:STDOUT: %.loc9_24.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc9_24.2 (constants.%.33a)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete: = require_complete_type %T.binding.as_type [symbolic = %require_complete (constants.%require_complete)] @@ -581,9 +581,9 @@ fn F2(U:! Z) { // CHECK:STDOUT: %bound_method.loc10_11: = bound_method %x.ref, %impl.elem0.loc10_11.1 // CHECK:STDOUT: %specific_impl_fn.loc10_11.1: = specific_impl_function %impl.elem0.loc10_11.1, @I.Copy(constants.%T) [symbolic = %specific_impl_fn.loc10_11.2 (constants.%specific_impl_fn)] // CHECK:STDOUT: %bound_method.loc10_17: = bound_method %x.ref, %specific_impl_fn.loc10_11.1 -// CHECK:STDOUT: %.loc9_21: ref @Use.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %I.Copy.call: init @Use.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc10_17(%x.ref) to %.loc9_21 -// CHECK:STDOUT: return %I.Copy.call to %return +// CHECK:STDOUT: %.loc9_24.1: ref @Use.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %I.Copy.call: init @Use.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc10_17(%x.ref) to %.loc9_24.1 +// CHECK:STDOUT: return %I.Copy.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -591,7 +591,7 @@ fn F2(U:! Z) { // CHECK:STDOUT: %T.loc9_8.1 => constants.%T // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.422 -// CHECK:STDOUT: %.loc9_24.1 => constants.%.33a +// CHECK:STDOUT: %.loc9_24.2 => constants.%.33a // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- access_selfless_method.carbon @@ -683,8 +683,8 @@ fn F2(U:! Z) { // CHECK:STDOUT: %specific_impl_fn.loc10_14.1: = specific_impl_function %impl.elem0.loc10_14.1, @I.Copy(constants.%T) [symbolic = %specific_impl_fn.loc10_14.2 (constants.%specific_impl_fn)] // CHECK:STDOUT: %bound_method.loc10_21: = bound_method %x.ref, %specific_impl_fn.loc10_14.1 // CHECK:STDOUT: -// CHECK:STDOUT: %I.Copy.call: init @UseIndirect.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc10_21(%x.ref) to %.loc8_29 -// CHECK:STDOUT: return %I.Copy.call to %return +// CHECK:STDOUT: %I.Copy.call: init @UseIndirect.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc10_21(%x.ref) to %.loc8_32.1 +// CHECK:STDOUT: return %I.Copy.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -692,7 +692,7 @@ fn F2(U:! Z) { // CHECK:STDOUT: %T.loc8_16.1 => constants.%T // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.422 -// CHECK:STDOUT: %.loc8_32.1 => constants.%.33a +// CHECK:STDOUT: %.loc8_32.2 => constants.%.33a // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- access_constant_in_self_facet.carbon @@ -765,9 +765,9 @@ fn F2(U:! Z) { // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc7_11.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc7_11.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc7_11.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc7_12: init %empty_tuple.type = converted %.loc7_11.1, %.loc7_11.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc7_12 to %return +// CHECK:STDOUT: return %.loc7_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -929,9 +929,9 @@ fn F2(U:! Z) { // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc15_11.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_11.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc15_11.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc15_12: init %empty_tuple.type = converted %.loc15_11.1, %.loc15_11.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc15_12 to %return +// CHECK:STDOUT: return %.loc15_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -945,9 +945,9 @@ fn F2(U:! Z) { // CHECK:STDOUT: fn() -> %empty_struct_type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc19_11.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc19_11.2: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc19_11.2: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc19_12: init %empty_struct_type = converted %.loc19_11.1, %.loc19_11.2 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc19_12 to %return +// CHECK:STDOUT: return %.loc19_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon b/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon index a92733ece1d7..1f7a41754f4b 100644 --- a/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon +++ b/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon @@ -238,9 +238,9 @@ fn G(holds_to: HoldsType((RuntimeConvertTo, )), from:! RuntimeConvertFrom) { // CHECK:STDOUT: fn @RuntimeConvertFrom.as.ImplicitAs.impl.Convert(%self.param: %RuntimeConvertFrom) -> %return.param: %RuntimeConvertTo { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc24_58.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc24_58.2: init %RuntimeConvertTo = class_init (), %return [concrete = constants.%RuntimeConvertTo.val] +// CHECK:STDOUT: %.loc24_58.2: init %RuntimeConvertTo = class_init (), %return.param [concrete = constants.%RuntimeConvertTo.val] // CHECK:STDOUT: %.loc24_59: init %RuntimeConvertTo = converted %.loc24_58.1, %.loc24_58.2 [concrete = constants.%RuntimeConvertTo.val] -// CHECK:STDOUT: return %.loc24_59 to %return +// CHECK:STDOUT: return %.loc24_59 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @F(%T.loc27_6.2: %tuple.type, %A.loc27_20.2: @F.%tuple.elem0.loc27_25.1 (%tuple.elem0)) { diff --git a/toolchain/check/testdata/facet/period_self.carbon b/toolchain/check/testdata/facet/period_self.carbon index 0401a4720e39..4e03c0b3baa0 100644 --- a/toolchain/check/testdata/facet/period_self.carbon +++ b/toolchain/check/testdata/facet/period_self.carbon @@ -511,9 +511,9 @@ fn F[U:! Core.Destroy where .Self impls I(.Self)](u: U) { // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc9_11.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc9_11.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc9_11.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc9_12: init %empty_tuple.type = converted %.loc9_11.1, %.loc9_11.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc9_12 to %return +// CHECK:STDOUT: return %.loc9_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -527,9 +527,9 @@ fn F[U:! Core.Destroy where .Self impls I(.Self)](u: U) { // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc13_11.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc13_11.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc13_11.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc13_12: init %empty_tuple.type = converted %.loc13_11.1, %.loc13_11.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc13_12 to %return +// CHECK:STDOUT: return %.loc13_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/facet/self_in_interface_param.carbon b/toolchain/check/testdata/facet/self_in_interface_param.carbon index e6a24cd6deb1..37c1a8a057d8 100644 --- a/toolchain/check/testdata/facet/self_in_interface_param.carbon +++ b/toolchain/check/testdata/facet/self_in_interface_param.carbon @@ -100,9 +100,9 @@ fn G(_:! I(.Self) where .I1 = ()) {} // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc19_11.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc19_11.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc19_11.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc19_12: init %empty_tuple.type = converted %.loc19_11.1, %.loc19_11.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc19_12 to %return +// CHECK:STDOUT: return %.loc19_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/for/actual.carbon b/toolchain/check/testdata/for/actual.carbon index d750c2c56b2c..27da1e91803e 100644 --- a/toolchain/check/testdata/for/actual.carbon +++ b/toolchain/check/testdata/for/actual.carbon @@ -282,7 +282,7 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %IntRange.ref.loc26: %IntRange.type = name_ref IntRange, file.%IntRange.decl [concrete = constants.%IntRange.generic] // CHECK:STDOUT: %int_32.loc26_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] // CHECK:STDOUT: %IntRange.loc26: type = class_type @IntRange, @IntRange(constants.%int_32) [concrete = constants.%IntRange.a89] -// CHECK:STDOUT: %.loc26_34: form = init_form %IntRange.loc26, call_param1 [concrete = constants.%.273] +// CHECK:STDOUT: %.loc26_34.2: form = init_form %IntRange.loc26, call_param1 [concrete = constants.%.273] // CHECK:STDOUT: %end.param: %i32 = value_param call_param0 // CHECK:STDOUT: %.loc26_15: type = splice_block %i32 [concrete = constants.%i32] { // CHECK:STDOUT: %int_32.loc26_15: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] @@ -349,9 +349,9 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %N.ref.loc11_73: Core.IntLiteral = name_ref N, @IntRange.%N.loc4_16.2 [symbolic = %N (constants.%N)] // CHECK:STDOUT: %Int.loc11_74: type = class_type @Int, @Int(constants.%N) [symbolic = %Int.loc11_43.1 (constants.%Int.fc6021.1)] // CHECK:STDOUT: %OptionalStorage.facet.loc11_75.2: %OptionalStorage.type = facet_value %Int.loc11_74, (constants.%OptionalStorage.lookup_impl_witness.b62) [symbolic = %OptionalStorage.facet.loc11_75.1 (constants.%OptionalStorage.facet.01e)] -// CHECK:STDOUT: %.loc11_75.3: %OptionalStorage.type = converted %Int.loc11_74, %OptionalStorage.facet.loc11_75.2 [symbolic = %OptionalStorage.facet.loc11_75.1 (constants.%OptionalStorage.facet.01e)] +// CHECK:STDOUT: %.loc11_75.5: %OptionalStorage.type = converted %Int.loc11_74, %OptionalStorage.facet.loc11_75.2 [symbolic = %OptionalStorage.facet.loc11_75.1 (constants.%OptionalStorage.facet.01e)] // CHECK:STDOUT: %Optional.loc11_75.2: type = class_type @Optional, @Optional(constants.%OptionalStorage.facet.01e) [symbolic = %Optional.loc11_75.1 (constants.%Optional.e48)] -// CHECK:STDOUT: %.loc11_75.4: form = init_form %Optional.loc11_75.2, call_param2 [symbolic = %.loc11_75.2 (constants.%.6a7)] +// CHECK:STDOUT: %.loc11_75.6: form = init_form %Optional.loc11_75.2, call_param2 [symbolic = %.loc11_75.4 (constants.%.6a7)] // CHECK:STDOUT: %self.param: @IntRange.as.Iterate.impl.Next.%IntRange (%IntRange.265) = value_param call_param0 // CHECK:STDOUT: %.loc11_19.1: type = splice_block %Self.ref [symbolic = %IntRange (constants.%IntRange.265)] { // CHECK:STDOUT: %.loc11_19.2: type = specific_constant constants.%IntRange.265, @IntRange(constants.%N) [symbolic = %IntRange (constants.%IntRange.265)] @@ -510,18 +510,18 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %specific_impl_fn.loc6_22.1: = specific_impl_function %impl.elem0.loc6_22.1, @Copy.Op(constants.%Copy.facet.3b9) [symbolic = %specific_impl_fn.loc6_22.2 (constants.%specific_impl_fn.62b)] // CHECK:STDOUT: %bound_method.loc6_22.2: = bound_method %start.ref, %specific_impl_fn.loc6_22.1 // CHECK:STDOUT: %Copy.Op.call.loc6_22: init @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = call %bound_method.loc6_22.2(%start.ref) -// CHECK:STDOUT: %.loc6_39.2: ref @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = class_element_access %return, element0 +// CHECK:STDOUT: %.loc6_39.2: ref @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc6_39.3: init @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = initialize_from %Copy.Op.call.loc6_22 to %.loc6_39.2 // CHECK:STDOUT: %impl.elem0.loc6_36: @IntRange.Make.%.loc6_22.2 (%.3676) = impl_witness_access constants.%Copy.lookup_impl_witness.7a8, element0 [symbolic = %impl.elem0.loc6_22.2 (constants.%impl.elem0.053)] // CHECK:STDOUT: %bound_method.loc6_36.1: = bound_method %end.ref, %impl.elem0.loc6_36 // CHECK:STDOUT: %specific_impl_fn.loc6_36: = specific_impl_function %impl.elem0.loc6_36, @Copy.Op(constants.%Copy.facet.3b9) [symbolic = %specific_impl_fn.loc6_22.2 (constants.%specific_impl_fn.62b)] // CHECK:STDOUT: %bound_method.loc6_36.2: = bound_method %end.ref, %specific_impl_fn.loc6_36 // CHECK:STDOUT: %Copy.Op.call.loc6_36: init @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = call %bound_method.loc6_36.2(%end.ref) -// CHECK:STDOUT: %.loc6_39.4: ref @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = class_element_access %return, element1 +// CHECK:STDOUT: %.loc6_39.4: ref @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc6_39.5: init @IntRange.Make.%Int.loc5_28.1 (%Int.fc6021.1) = initialize_from %Copy.Op.call.loc6_36 to %.loc6_39.4 -// CHECK:STDOUT: %.loc6_39.6: init @IntRange.Make.%IntRange (%IntRange.265) = class_init (%.loc6_39.3, %.loc6_39.5), %return +// CHECK:STDOUT: %.loc6_39.6: init @IntRange.Make.%IntRange (%IntRange.265) = class_init (%.loc6_39.3, %.loc6_39.5), %return.param // CHECK:STDOUT: %.loc6_40: init @IntRange.Make.%IntRange (%IntRange.265) = converted %.loc6_39.1, %.loc6_39.6 -// CHECK:STDOUT: return %.loc6_40 to %return +// CHECK:STDOUT: return %.loc6_40 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -557,7 +557,7 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %specific_impl_fn.loc10_60.1: = specific_impl_function %impl.elem0.loc10_60.1, @Copy.Op(constants.%Copy.facet.3b9) [symbolic = %specific_impl_fn.loc10_60.2 (constants.%specific_impl_fn.62b)] // CHECK:STDOUT: %bound_method.loc10_60.2: = bound_method %.loc10_60.2, %specific_impl_fn.loc10_60.1 // CHECK:STDOUT: %Copy.Op.call: init @IntRange.as.Iterate.impl.NewCursor.%Int.loc10_45.1 (%Int.fc6021.1) = call %bound_method.loc10_60.2(%.loc10_60.2) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -570,11 +570,11 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %pattern_type.loc11_25: type = pattern_type %ptr.loc11_44.1 [symbolic = %pattern_type.loc11_25 (constants.%pattern_type.bda)] // CHECK:STDOUT: %Copy.lookup_impl_witness: = lookup_impl_witness %Int.loc11_43.1, @Copy [symbolic = %Copy.lookup_impl_witness (constants.%Copy.lookup_impl_witness.7a8)] // CHECK:STDOUT: %facet_value: %facet_type = facet_value %Int.loc11_43.1, (constants.%custom_witness.8095d9.1, %Copy.lookup_impl_witness) [symbolic = %facet_value (constants.%facet_value)] -// CHECK:STDOUT: %.loc11_75.1: require_specific_def_type = require_specific_def @T.binding.as_type.as.OptionalStorage.impl(%facet_value) [symbolic = %.loc11_75.1 (constants.%.f57)] +// CHECK:STDOUT: %.loc11_75.3: require_specific_def_type = require_specific_def @T.binding.as_type.as.OptionalStorage.impl(%facet_value) [symbolic = %.loc11_75.3 (constants.%.f57)] // CHECK:STDOUT: %OptionalStorage.lookup_impl_witness: = lookup_impl_witness %Int.loc11_43.1, @OptionalStorage [symbolic = %OptionalStorage.lookup_impl_witness (constants.%OptionalStorage.lookup_impl_witness.b62)] // CHECK:STDOUT: %OptionalStorage.facet.loc11_75.1: %OptionalStorage.type = facet_value %Int.loc11_43.1, (%OptionalStorage.lookup_impl_witness) [symbolic = %OptionalStorage.facet.loc11_75.1 (constants.%OptionalStorage.facet.01e)] // CHECK:STDOUT: %Optional.loc11_75.1: type = class_type @Optional, @Optional(%OptionalStorage.facet.loc11_75.1) [symbolic = %Optional.loc11_75.1 (constants.%Optional.e48)] -// CHECK:STDOUT: %.loc11_75.2: form = init_form %Optional.loc11_75.1, call_param2 [symbolic = %.loc11_75.2 (constants.%.6a7)] +// CHECK:STDOUT: %.loc11_75.4: form = init_form %Optional.loc11_75.1, call_param2 [symbolic = %.loc11_75.4 (constants.%.6a7)] // CHECK:STDOUT: %pattern_type.loc11_47: type = pattern_type %Optional.loc11_75.1 [symbolic = %pattern_type.loc11_47 (constants.%pattern_type.0c2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -682,12 +682,12 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %OptionalStorage.facet.loc15_53.2: %OptionalStorage.type = facet_value constants.%Int.fc6021.1, (constants.%OptionalStorage.lookup_impl_witness.b62) [symbolic = %OptionalStorage.facet.loc11_75.1 (constants.%OptionalStorage.facet.01e)] // CHECK:STDOUT: %.loc15_53.2: %OptionalStorage.type = converted constants.%Int.fc6021.1, %OptionalStorage.facet.loc15_53.2 [symbolic = %OptionalStorage.facet.loc11_75.1 (constants.%OptionalStorage.facet.01e)] // CHECK:STDOUT: %Optional.Some.specific_fn.loc15_42.1: = specific_function %Some.ref, @Optional.Some(constants.%OptionalStorage.facet.01e) [symbolic = %Optional.Some.specific_fn.loc15_42.2 (constants.%Optional.Some.specific_fn)] -// CHECK:STDOUT: %.loc11_47.1: ref @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = splice_block %return {} +// CHECK:STDOUT: %.loc11_75.1: ref @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = splice_block %return.param {} // CHECK:STDOUT: %.loc15_48: @IntRange.as.Iterate.impl.Next.%Int.loc11_43.1 (%Int.fc6021.1) = acquire_value %value.ref.loc15 -// CHECK:STDOUT: %Optional.Some.call: init @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = call %Optional.Some.specific_fn.loc15_42.1(%.loc15_48) to %.loc11_47.1 +// CHECK:STDOUT: %Optional.Some.call: init @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = call %Optional.Some.specific_fn.loc15_42.1(%.loc15_48) to %.loc11_75.1 // CHECK:STDOUT: %DestroyOp.bound.loc12_7.1: = bound_method %value.var, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc12_7.1: init %empty_tuple.type = call %DestroyOp.bound.loc12_7.1(%value.var) -// CHECK:STDOUT: return %Optional.Some.call to %return +// CHECK:STDOUT: return %Optional.Some.call to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else: // CHECK:STDOUT: %Core.ref.loc17_16: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -702,11 +702,11 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %.loc17_42: @IntRange.as.Iterate.impl.Next.%Optional.None.type (%Optional.None.type.d56) = specific_constant imports.%Core.import_ref.d20a, @Optional(constants.%OptionalStorage.facet.01e) [symbolic = %Optional.None (constants.%Optional.None.b26)] // CHECK:STDOUT: %None.ref: @IntRange.as.Iterate.impl.Next.%Optional.None.type (%Optional.None.type.d56) = name_ref None, %.loc17_42 [symbolic = %Optional.None (constants.%Optional.None.b26)] // CHECK:STDOUT: %Optional.None.specific_fn.loc17_42.1: = specific_function %None.ref, @Optional.None(constants.%OptionalStorage.facet.01e) [symbolic = %Optional.None.specific_fn.loc17_42.2 (constants.%Optional.None.specific_fn)] -// CHECK:STDOUT: %.loc11_47.2: ref @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = splice_block %return {} -// CHECK:STDOUT: %Optional.None.call: init @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = call %Optional.None.specific_fn.loc17_42.1() to %.loc11_47.2 +// CHECK:STDOUT: %.loc11_75.2: ref @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = splice_block %return.param {} +// CHECK:STDOUT: %Optional.None.call: init @IntRange.as.Iterate.impl.Next.%Optional.loc11_75.1 (%Optional.e48) = call %Optional.None.specific_fn.loc17_42.1() to %.loc11_75.2 // CHECK:STDOUT: %DestroyOp.bound.loc12_7.2: = bound_method %value.var, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc12_7.2: init %empty_tuple.type = call %DestroyOp.bound.loc12_7.2(%value.var) -// CHECK:STDOUT: return %Optional.None.call to %return +// CHECK:STDOUT: return %Optional.None.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -720,7 +720,7 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] // CHECK:STDOUT: %end.ref: %i32 = name_ref end, %end // CHECK:STDOUT: %IntRange.Make.specific_fn: = specific_function %Make.ref, @IntRange.Make(constants.%int_32) [concrete = constants.%IntRange.Make.specific_fn] -// CHECK:STDOUT: %.loc26_20: ref %IntRange.a89 = splice_block %return {} +// CHECK:STDOUT: %.loc26_34.1: ref %IntRange.a89 = splice_block %return.param {} // CHECK:STDOUT: %impl.elem0: %.863 = impl_witness_access constants.%ImplicitAs.impl_witness.6bc, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.0b5] // CHECK:STDOUT: %bound_method.loc27_28.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -728,8 +728,8 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc27_28.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc27_28.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc27_28.2: %i32 = converted %int_0, %.loc27_28.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %IntRange.Make.call: init %IntRange.a89 = call %IntRange.Make.specific_fn(%.loc27_28.2, %end.ref) to %.loc26_20 -// CHECK:STDOUT: return %IntRange.Make.call to %return +// CHECK:STDOUT: %IntRange.Make.call: init %IntRange.a89 = call %IntRange.Make.specific_fn(%.loc27_28.2, %end.ref) to %.loc26_34.1 +// CHECK:STDOUT: return %IntRange.Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @IntRange(constants.%N) { @@ -794,11 +794,11 @@ fn Read(y:! Core.IntLiteral()) { // CHECK:STDOUT: %pattern_type.loc11_25 => constants.%pattern_type.bda // CHECK:STDOUT: %Copy.lookup_impl_witness => constants.%Copy.lookup_impl_witness.7a8 // CHECK:STDOUT: %facet_value => constants.%facet_value -// CHECK:STDOUT: %.loc11_75.1 => constants.%.f57 +// CHECK:STDOUT: %.loc11_75.3 => constants.%.f57 // CHECK:STDOUT: %OptionalStorage.lookup_impl_witness => constants.%OptionalStorage.lookup_impl_witness.b62 // CHECK:STDOUT: %OptionalStorage.facet.loc11_75.1 => constants.%OptionalStorage.facet.01e // CHECK:STDOUT: %Optional.loc11_75.1 => constants.%Optional.e48 -// CHECK:STDOUT: %.loc11_75.2 => constants.%.6a7 +// CHECK:STDOUT: %.loc11_75.4 => constants.%.6a7 // CHECK:STDOUT: %pattern_type.loc11_47 => constants.%pattern_type.0c2 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/builtin/call.carbon b/toolchain/check/testdata/function/builtin/call.carbon index 54032d0ed581..7a0890012fab 100644 --- a/toolchain/check/testdata/function/builtin/call.carbon +++ b/toolchain/check/testdata/function/builtin/call.carbon @@ -196,6 +196,6 @@ fn RuntimeCall(a: i32, b: i32) -> i32 { // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %Add.call: init %i32 = call %Add.ref(%a.ref, %b.ref) -// CHECK:STDOUT: return %Add.call to %return +// CHECK:STDOUT: return %Add.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/builtin/fail_redefined.carbon b/toolchain/check/testdata/function/builtin/fail_redefined.carbon index 56c212c9bdfc..111273ec3040 100644 --- a/toolchain/check/testdata/function/builtin/fail_redefined.carbon +++ b/toolchain/check/testdata/function/builtin/fail_redefined.carbon @@ -265,7 +265,7 @@ fn C(n: i32, m: i32) -> i32 = "int.sadd"; // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc23_38.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc23_38.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B.loc25(%n.param: %i32, %m.param: %i32) -> %i32 { @@ -276,7 +276,7 @@ fn C(n: i32, m: i32) -> i32 = "int.sadd"; // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc25_38.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc25_38.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B.loc33(%n.param: %i32, %m.param: %i32) -> %i32 = "int.sadd"; diff --git a/toolchain/check/testdata/function/call/alias.carbon b/toolchain/check/testdata/function/call/alias.carbon index eb0aec939c64..9d842cd6e165 100644 --- a/toolchain/check/testdata/function/call/alias.carbon +++ b/toolchain/check/testdata/function/call/alias.carbon @@ -71,9 +71,9 @@ fn Main() { // CHECK:STDOUT: fn @A() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc15_24.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_24.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc15_24.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc15_25: init %empty_tuple.type = converted %.loc15_24.1, %.loc15_24.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc15_25 to %return +// CHECK:STDOUT: return %.loc15_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Main() { diff --git a/toolchain/check/testdata/function/call/empty_struct.carbon b/toolchain/check/testdata/function/call/empty_struct.carbon index 56901273de02..7c46d14812ad 100644 --- a/toolchain/check/testdata/function/call/empty_struct.carbon +++ b/toolchain/check/testdata/function/call/empty_struct.carbon @@ -62,9 +62,9 @@ fn Main() { // CHECK:STDOUT: fn @Echo(%a.param: %empty_struct_type) -> %empty_struct_type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %empty_struct_type = name_ref a, %a -// CHECK:STDOUT: %.loc16_10: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc16_10: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc16_11: init %empty_struct_type = converted %a.ref, %.loc16_10 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc16_11 to %return +// CHECK:STDOUT: return %.loc16_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Main() { diff --git a/toolchain/check/testdata/function/call/empty_tuple.carbon b/toolchain/check/testdata/function/call/empty_tuple.carbon index 08e4621b8685..5f9dc453327b 100644 --- a/toolchain/check/testdata/function/call/empty_tuple.carbon +++ b/toolchain/check/testdata/function/call/empty_tuple.carbon @@ -62,9 +62,9 @@ fn Main() { // CHECK:STDOUT: fn @Echo(%a.param: %empty_tuple.type) -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %empty_tuple.type = name_ref a, %a -// CHECK:STDOUT: %.loc16_10: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc16_10: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc16_11: init %empty_tuple.type = converted %a.ref, %.loc16_10 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc16_11 to %return +// CHECK:STDOUT: return %.loc16_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Main() { diff --git a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon index c99d48076e4a..801d987f2501 100644 --- a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon +++ b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon @@ -112,7 +112,7 @@ fn Run() { // CHECK:STDOUT: %bound_method.loc15_29.2: = bound_method %float, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f64.d77 = call %bound_method.loc15_29.2(%float) [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc15_29: init %f64.d77 = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.d20] -// CHECK:STDOUT: return %.loc15_29 to %return +// CHECK:STDOUT: return %.loc15_29 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Run() { diff --git a/toolchain/check/testdata/function/call/i32.carbon b/toolchain/check/testdata/function/call/i32.carbon index 725636210dd6..3e07de98bac8 100644 --- a/toolchain/check/testdata/function/call/i32.carbon +++ b/toolchain/check/testdata/function/call/i32.carbon @@ -122,7 +122,7 @@ fn Main() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc16_10.2: = bound_method %a.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc16_10.2(%a.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Main() { diff --git a/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon b/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon index 46de0b234c51..fa2922cc7919 100644 --- a/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon +++ b/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon @@ -177,7 +177,7 @@ fn Class(F:! type).Inner.G() -> i32 { return F(); } // CHECK:STDOUT: %bound_method.loc8_29.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc8_29.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc8_29: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc8_29 to %return +// CHECK:STDOUT: return %.loc8_29 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -194,7 +194,7 @@ fn Class(F:! type).Inner.G() -> i32 { return F(); } // CHECK:STDOUT: %F.ref: @Inner.G.%Inner.F.type (%Inner.F.type) = name_ref F, %.loc13_46 [symbolic = %Inner.F (constants.%Inner.F)] // CHECK:STDOUT: %Inner.F.specific_fn.loc13_46.1: = specific_function %F.ref, @Inner.F(constants.%F) [symbolic = %Inner.F.specific_fn.loc13_46.2 (constants.%Inner.F.specific_fn)] // CHECK:STDOUT: %Inner.F.call: init %i32 = call %Inner.F.specific_fn.loc13_46.1() -// CHECK:STDOUT: return %Inner.F.call to %return.loc13 +// CHECK:STDOUT: return %Inner.F.call to %return.param.loc13 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/definition/fail_decl_param_mismatch.carbon b/toolchain/check/testdata/function/definition/fail_decl_param_mismatch.carbon index c90af02a4d52..d9d33c4db8e4 100644 --- a/toolchain/check/testdata/function/definition/fail_decl_param_mismatch.carbon +++ b/toolchain/check/testdata/function/definition/fail_decl_param_mismatch.carbon @@ -227,9 +227,9 @@ fn K() -> {} { return {}; } // CHECK:STDOUT: fn @I.loc50() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc50_24.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc50_24.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc50_24.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc50_25: init %empty_tuple.type = converted %.loc50_24.1, %.loc50_24.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc50_25 to %return +// CHECK:STDOUT: return %.loc50_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @J.loc52() -> %empty_tuple.type; @@ -244,8 +244,8 @@ fn K() -> {} { return {}; } // CHECK:STDOUT: fn @K.loc70() -> %empty_struct_type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc70_24.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc70_24.2: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc70_24.2: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc70_25: init %empty_struct_type = converted %.loc70_24.1, %.loc70_24.2 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc70_25 to %return +// CHECK:STDOUT: return %.loc70_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/definition/import.carbon b/toolchain/check/testdata/function/definition/import.carbon index 9bd903accf36..e52d5434dc4e 100644 --- a/toolchain/check/testdata/function/definition/import.carbon +++ b/toolchain/check/testdata/function/definition/import.carbon @@ -230,7 +230,7 @@ fn D() {} // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc5_30.2: = bound_method %b.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc5_30.2(%b.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C(%c.param: %tuple.type.a1c) -> %struct_type.c { @@ -244,9 +244,9 @@ fn D() {} // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_46.2: = bound_method %tuple.elem0, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_46.2(%tuple.elem0) -// CHECK:STDOUT: %.loc6_48.2: init %struct_type.c = struct_init (%Int.as.Copy.impl.Op.call) to %return +// CHECK:STDOUT: %.loc6_48.2: init %struct_type.c = struct_init (%Int.as.Copy.impl.Op.call) to %return.param // CHECK:STDOUT: %.loc6_49: init %struct_type.c = converted %.loc6_48.1, %.loc6_48.2 -// CHECK:STDOUT: return %.loc6_49 to %return +// CHECK:STDOUT: return %.loc6_49 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @D(); diff --git a/toolchain/check/testdata/function/definition/syntactic_merge.carbon b/toolchain/check/testdata/function/definition/syntactic_merge.carbon index 541e160fba31..ec450b700503 100644 --- a/toolchain/check/testdata/function/definition/syntactic_merge.carbon +++ b/toolchain/check/testdata/function/definition/syntactic_merge.carbon @@ -817,9 +817,9 @@ fn Foo(a: const (const C)) {} // CHECK:STDOUT: fn @Foo() -> %return.param.loc8: %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc8_25.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc8_25.2: init %C = class_init (), %return.loc8 [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc8_25.2: init %C = class_init (), %return.param.loc8 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc8_26: init %C = converted %.loc8_25.1, %.loc8_25.2 [concrete = constants.%C.val] -// CHECK:STDOUT: return %.loc8_26 to %return.loc8 +// CHECK:STDOUT: return %.loc8_26 to %return.param.loc8 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- alias_two_file.carbon diff --git a/toolchain/check/testdata/function/generic/call.carbon b/toolchain/check/testdata/function/generic/call.carbon index 94f241a14f58..2d0799d52b9a 100644 --- a/toolchain/check/testdata/function/generic/call.carbon +++ b/toolchain/check/testdata/function/generic/call.carbon @@ -137,8 +137,8 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc5_37: %Copy.type = name_ref T, %T.loc5_13.2 [symbolic = %T.loc5_13.1 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc5_37: type = facet_access_type %T.ref.loc5_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc5_37.2: type = converted %T.ref.loc5_37, %T.as_type.loc5_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc5_37.3: form = init_form %.loc5_37.2, call_param1 [symbolic = %.loc5_37.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc5_37.3: type = converted %T.ref.loc5_37, %T.as_type.loc5_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc5_37.4: form = init_form %.loc5_37.3, call_param1 [symbolic = %.loc5_37.2 (constants.%.075d25.1)] // CHECK:STDOUT: %.loc5_21: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -161,7 +161,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc5_13.1: %Copy.type = symbolic_binding T, 0 [symbolic = %T.loc5_13.1 (constants.%T.035)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T.loc5_13.1 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc5_37.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc5_37.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc5_37.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc5_37.2 (constants.%.075d25.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete: = require_complete_type %T.binding.as_type [symbolic = %require_complete (constants.%require_complete.67c)] @@ -177,9 +177,9 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %bound_method.loc6_10.1: = bound_method %x.ref, %impl.elem0.loc6_10.1 // CHECK:STDOUT: %specific_impl_fn.loc6_10.1: = specific_impl_function %impl.elem0.loc6_10.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc6_10.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %x.ref, %specific_impl_fn.loc6_10.1 -// CHECK:STDOUT: %.loc5_34: ref @Function.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @Function.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc6_10.2(%x.ref) to %.loc5_34 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc5_37.1: ref @Function.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @Function.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc6_10.2(%x.ref) to %.loc5_37.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -199,8 +199,8 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %.loc12_23.2: %Copy.type = converted constants.%T.binding.as_type, constants.%T.035 [symbolic = %T.loc10_16.1 (constants.%T.035)] // CHECK:STDOUT: %Function.specific_fn.loc12_10.1: = specific_function %Function.ref, @Function(constants.%T.035) [symbolic = %Function.specific_fn.loc12_10.2 (constants.%Function.specific_fn.a87)] // CHECK:STDOUT: -// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.binding.as_type (%T.binding.as_type) = call %Function.specific_fn.loc12_10.1(%x.ref) to %.loc10_37 -// CHECK:STDOUT: return %Function.call to %return +// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.binding.as_type (%T.binding.as_type) = call %Function.specific_fn.loc12_10.1(%x.ref) to %.loc10_40.1 +// CHECK:STDOUT: return %Function.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -228,7 +228,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %.loc18_24.3: %Copy.type = converted constants.%ptr.e8f, %Copy.facet.loc18_24.3 [symbolic = %Copy.facet.loc18_24.4 (constants.%Copy.facet.c25)] // CHECK:STDOUT: %Function.specific_fn.loc18_10.1: = specific_function %Function.ref, @Function(constants.%Copy.facet.c25) [symbolic = %Function.specific_fn.loc18_10.2 (constants.%Function.specific_fn.919)] // CHECK:STDOUT: %Function.call: init @CallGenericPtr.%ptr.loc16_33.1 (%ptr.e8f) = call %Function.specific_fn.loc18_10.1(%x.ref) -// CHECK:STDOUT: return %Function.call to %return +// CHECK:STDOUT: return %Function.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -246,14 +246,14 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %.loc26_24.3: %Copy.type = converted constants.%ptr.31e, %Copy.facet.loc26_24.3 [concrete = constants.%Copy.facet.a7f] // CHECK:STDOUT: %Function.specific_fn: = specific_function %Function.ref, @Function(constants.%Copy.facet.a7f) [concrete = constants.%Function.specific_fn.9da] // CHECK:STDOUT: %Function.call: init %ptr.31e = call %Function.specific_fn(%x.ref) -// CHECK:STDOUT: return %Function.call to %return +// CHECK:STDOUT: return %Function.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Function(constants.%T.035) { // CHECK:STDOUT: %T.loc5_13.1 => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc5_37.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc5_37.2 => constants.%.075d25.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%require_complete.67c @@ -267,7 +267,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc10_16.1 => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc10_40.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc10_40.2 => constants.%.075d25.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @CallGenericPtr(constants.%T.67d) { @@ -281,7 +281,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc5_13.1 => constants.%Copy.facet.c25 // CHECK:STDOUT: %T.binding.as_type => constants.%ptr.e8f // CHECK:STDOUT: %pattern_type => constants.%pattern_type.4f4 -// CHECK:STDOUT: %.loc5_37.1 => constants.%.ba4 +// CHECK:STDOUT: %.loc5_37.2 => constants.%.ba4 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%require_complete.ef1 @@ -295,7 +295,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc5_13.1 => constants.%Copy.facet.a7f // CHECK:STDOUT: %T.binding.as_type => constants.%ptr.31e // CHECK:STDOUT: %pattern_type => constants.%pattern_type.506 -// CHECK:STDOUT: %.loc5_37.1 => constants.%.485 +// CHECK:STDOUT: %.loc5_37.2 => constants.%.485 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%complete_type.17a @@ -372,8 +372,8 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc5_37: %Copy.type = name_ref T, %T.loc5_13.2 [symbolic = %T.loc5_13.1 (constants.%T.035)] // CHECK:STDOUT: %T.as_type.loc5_37: type = facet_access_type %T.ref.loc5_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc5_37.2: type = converted %T.ref.loc5_37, %T.as_type.loc5_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc5_37.3: form = init_form %.loc5_37.2, call_param1 [symbolic = %.loc5_37.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc5_37.3: type = converted %T.ref.loc5_37, %T.as_type.loc5_37 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc5_37.4: form = init_form %.loc5_37.3, call_param1 [symbolic = %.loc5_37.2 (constants.%.075d25.1)] // CHECK:STDOUT: %.loc5_21: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -396,7 +396,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc5_13.1: %Copy.type = symbolic_binding T, 0 [symbolic = %T.loc5_13.1 (constants.%T.035)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T.loc5_13.1 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc5_37.1: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc5_37.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc5_37.2: form = init_form %T.binding.as_type, call_param1 [symbolic = %.loc5_37.2 (constants.%.075d25.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete: = require_complete_type %T.binding.as_type [symbolic = %require_complete (constants.%require_complete.67c)] @@ -412,9 +412,9 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %bound_method.loc6_10.1: = bound_method %x.ref, %impl.elem0.loc6_10.1 // CHECK:STDOUT: %specific_impl_fn.loc6_10.1: = specific_impl_function %impl.elem0.loc6_10.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc6_10.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %x.ref, %specific_impl_fn.loc6_10.1 -// CHECK:STDOUT: %.loc5_34: ref @Function.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @Function.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc6_10.2(%x.ref) to %.loc5_34 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc5_37.1: ref @Function.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @Function.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc6_10.2(%x.ref) to %.loc5_37.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -433,8 +433,8 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %.loc12_20.2: %Copy.type = converted constants.%T.binding.as_type, constants.%T.035 [symbolic = %T.loc10_16.1 (constants.%T.035)] // CHECK:STDOUT: %Function.specific_fn.loc12_10.1: = specific_function %Function.ref, @Function(constants.%T.035) [symbolic = %Function.specific_fn.loc12_10.2 (constants.%Function.specific_fn.a87)] // CHECK:STDOUT: -// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.binding.as_type (%T.binding.as_type) = call %Function.specific_fn.loc12_10.1(%x.ref) to %.loc10_37 -// CHECK:STDOUT: return %Function.call to %return +// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.binding.as_type (%T.binding.as_type) = call %Function.specific_fn.loc12_10.1(%x.ref) to %.loc10_40.1 +// CHECK:STDOUT: return %Function.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -458,7 +458,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %.loc18_20.2: %Copy.type = converted constants.%ptr.e8f, %Copy.facet.loc18_20.2 [symbolic = %Copy.facet.loc18_20.3 (constants.%Copy.facet.c25)] // CHECK:STDOUT: %Function.specific_fn.loc18_10.1: = specific_function %Function.ref, @Function(constants.%Copy.facet.c25) [symbolic = %Function.specific_fn.loc18_10.2 (constants.%Function.specific_fn.919)] // CHECK:STDOUT: %Function.call: init @CallGenericPtr.%ptr.loc16_33.1 (%ptr.e8f) = call %Function.specific_fn.loc18_10.1(%x.ref) -// CHECK:STDOUT: return %Function.call to %return +// CHECK:STDOUT: return %Function.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -472,14 +472,14 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %.loc26_20.2: %Copy.type = converted constants.%ptr.31e, %Copy.facet.loc26_20.2 [concrete = constants.%Copy.facet.a7f] // CHECK:STDOUT: %Function.specific_fn: = specific_function %Function.ref, @Function(constants.%Copy.facet.a7f) [concrete = constants.%Function.specific_fn.9da] // CHECK:STDOUT: %Function.call: init %ptr.31e = call %Function.specific_fn(%x.ref) -// CHECK:STDOUT: return %Function.call to %return +// CHECK:STDOUT: return %Function.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Function(constants.%T.035) { // CHECK:STDOUT: %T.loc5_13.1 => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc5_37.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc5_37.2 => constants.%.075d25.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%require_complete.67c @@ -493,7 +493,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc10_16.1 => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc10_40.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc10_40.2 => constants.%.075d25.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @CallGenericPtr(constants.%T.67d) { @@ -507,7 +507,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc5_13.1 => constants.%Copy.facet.c25 // CHECK:STDOUT: %T.binding.as_type => constants.%ptr.e8f // CHECK:STDOUT: %pattern_type => constants.%pattern_type.4f4 -// CHECK:STDOUT: %.loc5_37.1 => constants.%.ba4 +// CHECK:STDOUT: %.loc5_37.2 => constants.%.ba4 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%require_complete.ef1 @@ -521,7 +521,7 @@ fn CallSpecific(x: C*) -> C* { // CHECK:STDOUT: %T.loc5_13.1 => constants.%Copy.facet.a7f // CHECK:STDOUT: %T.binding.as_type => constants.%ptr.31e // CHECK:STDOUT: %pattern_type => constants.%pattern_type.506 -// CHECK:STDOUT: %.loc5_37.1 => constants.%.485 +// CHECK:STDOUT: %.loc5_37.2 => constants.%.485 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%complete_type.17a diff --git a/toolchain/check/testdata/function/generic/deduce.carbon b/toolchain/check/testdata/function/generic/deduce.carbon index 661590cb3537..a261b6399bee 100644 --- a/toolchain/check/testdata/function/generic/deduce.carbon +++ b/toolchain/check/testdata/function/generic/deduce.carbon @@ -321,7 +321,7 @@ fn F() { // CHECK:STDOUT: %T.ref.loc4_71: type = name_ref T, %T.loc4_25.2 [symbolic = %T.loc4_25.1 (constants.%T)] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.1: = specific_function %ExplicitGenericParam.ref, @ExplicitGenericParam(constants.%T) [symbolic = %ExplicitGenericParam.specific_fn.loc4_50.2 (constants.%ExplicitGenericParam.specific_fn.409)] // CHECK:STDOUT: %ExplicitGenericParam.call: init @ExplicitGenericParam.%ptr.loc4_39.1 (%ptr.e8f) = call %ExplicitGenericParam.specific_fn.loc4_50.1() -// CHECK:STDOUT: return %ExplicitGenericParam.call to %return +// CHECK:STDOUT: return %ExplicitGenericParam.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -332,7 +332,7 @@ fn F() { // CHECK:STDOUT: %i32.loc7: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn: = specific_function %ExplicitGenericParam.ref, @ExplicitGenericParam(constants.%i32) [concrete = constants.%ExplicitGenericParam.specific_fn.3d2] // CHECK:STDOUT: %ExplicitGenericParam.call: init %ptr.235 = call %ExplicitGenericParam.specific_fn() -// CHECK:STDOUT: return %ExplicitGenericParam.call to %return +// CHECK:STDOUT: return %ExplicitGenericParam.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @CallExplicitGenericParamWithGenericArg(%T.loc10_43.2: type) { @@ -353,7 +353,7 @@ fn F() { // CHECK:STDOUT: %struct_type.a.loc11: type = struct_type {.a: @CallExplicitGenericParamWithGenericArg.%T.loc10_43.1 (%T)} [symbolic = %struct_type.a.loc10_62.1 (constants.%struct_type.a)] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc11_10.1: = specific_function %ExplicitGenericParam.ref, @ExplicitGenericParam(constants.%struct_type.a) [symbolic = %ExplicitGenericParam.specific_fn.loc11_10.2 (constants.%ExplicitGenericParam.specific_fn.55c)] // CHECK:STDOUT: %ExplicitGenericParam.call: init @CallExplicitGenericParamWithGenericArg.%ptr.loc10_63.1 (%ptr.88d) = call %ExplicitGenericParam.specific_fn.loc11_10.1() -// CHECK:STDOUT: return %ExplicitGenericParam.call to %return +// CHECK:STDOUT: return %ExplicitGenericParam.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -477,7 +477,7 @@ fn F() { // CHECK:STDOUT: %T.ref.loc4_71: type = name_ref T, %T.loc4_25.2 [symbolic = %T.loc4_25.1 (constants.%T)] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.1: = specific_function %ExplicitGenericParam.ref, @ExplicitGenericParam(constants.%T) [symbolic = %ExplicitGenericParam.specific_fn.loc4_50.2 (constants.%ExplicitGenericParam.specific_fn)] // CHECK:STDOUT: %ExplicitGenericParam.call: init @ExplicitGenericParam.%ptr.loc4_39.1 (%ptr) = call %ExplicitGenericParam.specific_fn.loc4_50.1() -// CHECK:STDOUT: return %ExplicitGenericParam.call to %return +// CHECK:STDOUT: return %ExplicitGenericParam.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -632,7 +632,7 @@ fn F() { // CHECK:STDOUT: %x.ref: @ExplicitAndAlsoDeduced.%T.loc6_27.1 (%T) = name_ref x, %x // CHECK:STDOUT: %ExplicitAndAlsoDeduced.specific_fn.loc7_10.1: = specific_function %ExplicitAndAlsoDeduced.ref, @ExplicitAndAlsoDeduced(constants.%T) [symbolic = %ExplicitAndAlsoDeduced.specific_fn.loc7_10.2 (constants.%ExplicitAndAlsoDeduced.specific_fn.7e7)] // CHECK:STDOUT: %ExplicitAndAlsoDeduced.call: init @ExplicitAndAlsoDeduced.%ptr.loc6_47.1 (%ptr.e8f) = call %ExplicitAndAlsoDeduced.specific_fn.loc7_10.1(%x.ref) -// CHECK:STDOUT: return %ExplicitAndAlsoDeduced.call to %return +// CHECK:STDOUT: return %ExplicitAndAlsoDeduced.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -650,7 +650,7 @@ fn F() { // CHECK:STDOUT: %ExplicitAndAlsoDeduced.call: init %ptr.643 = call %ExplicitAndAlsoDeduced.specific_fn(%.loc11_37.6) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc11_37.4, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc11_37.4) -// CHECK:STDOUT: return %ExplicitAndAlsoDeduced.call to %return +// CHECK:STDOUT: return %ExplicitAndAlsoDeduced.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %A) = "no_op"; @@ -786,7 +786,7 @@ fn F() { // CHECK:STDOUT: %x.ref: @ImplicitGenericParam.%T.loc4_25.1 (%T) = name_ref x, %x // CHECK:STDOUT: %ImplicitGenericParam.specific_fn.loc4_56.1: = specific_function %ImplicitGenericParam.ref, @ImplicitGenericParam(constants.%T) [symbolic = %ImplicitGenericParam.specific_fn.loc4_56.2 (constants.%ImplicitGenericParam.specific_fn.7cc)] // CHECK:STDOUT: %ImplicitGenericParam.call: init @ImplicitGenericParam.%ptr.loc4_45.1 (%ptr.e8f) = call %ImplicitGenericParam.specific_fn.loc4_56.1(%x.ref) -// CHECK:STDOUT: return %ImplicitGenericParam.call to %return +// CHECK:STDOUT: return %ImplicitGenericParam.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -796,7 +796,7 @@ fn F() { // CHECK:STDOUT: %n.ref: %i32 = name_ref n, %n // CHECK:STDOUT: %ImplicitGenericParam.specific_fn: = specific_function %ImplicitGenericParam.ref, @ImplicitGenericParam(constants.%i32) [concrete = constants.%ImplicitGenericParam.specific_fn.be5] // CHECK:STDOUT: %ImplicitGenericParam.call: init %ptr.235 = call %ImplicitGenericParam.specific_fn(%n.ref) -// CHECK:STDOUT: return %ImplicitGenericParam.call to %return +// CHECK:STDOUT: return %ImplicitGenericParam.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @ImplicitGenericParam(constants.%T) { diff --git a/toolchain/check/testdata/function/generic/indirect_generic_type.carbon b/toolchain/check/testdata/function/generic/indirect_generic_type.carbon index 22443b5005a4..7fa68c3fa8a2 100644 --- a/toolchain/check/testdata/function/generic/indirect_generic_type.carbon +++ b/toolchain/check/testdata/function/generic/indirect_generic_type.carbon @@ -64,7 +64,7 @@ fn F(T:! type, p: T**) -> T* { // CHECK:STDOUT: %specific_impl_fn.loc6_10.1: = specific_impl_function %impl.elem0.loc6_10.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc6_10.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %.loc6_10.2, %specific_impl_fn.loc6_10.1 // CHECK:STDOUT: %Copy.Op.call: init @F.%ptr.loc4_20.1 (%ptr.e8f) = call %bound_method.loc6_10.2(%.loc6_10.2) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/redeclare.carbon b/toolchain/check/testdata/function/generic/redeclare.carbon index a5703fd37abb..fec31b5e1f05 100644 --- a/toolchain/check/testdata/function/generic/redeclare.carbon +++ b/toolchain/check/testdata/function/generic/redeclare.carbon @@ -167,7 +167,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %T.ref.loc7: type = name_ref T, %T.loc6 [symbolic = %T.loc4_6.1 (constants.%T)] // CHECK:STDOUT: %F.specific_fn.loc7_10.1: = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc7_10.2 (constants.%F.specific_fn)] // CHECK:STDOUT: %F.call: init @F.%ptr.loc4_20.1 (%ptr) = call %F.specific_fn.loc7_10.1() -// CHECK:STDOUT: return %F.call to %return.loc6 +// CHECK:STDOUT: return %F.call to %return.param.loc6 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -274,7 +274,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %F.type.117dbc.1 = name_ref F, file.%F.decl.loc4 [concrete = constants.%F.d98bd5.1] // CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc13_6.2 [symbolic = %T.loc13_6.1 (constants.%T)] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -388,7 +388,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %F.type.117dbc.1 = name_ref F, file.%F.decl.loc4 [concrete = constants.%F.d98bd5.1] // CHECK:STDOUT: %T.ref.loc21: type = name_ref T, %T.loc13_16.2 [symbolic = %T.loc13_16.1 (constants.%T.091)] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -502,7 +502,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %F.type.117dbc.1 = name_ref F, file.%F.decl.loc4 [concrete = constants.%F.d98bd5.1] // CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc13_16.2 [symbolic = %T.loc13_16.1 (constants.%T.091)] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/return_slot.carbon b/toolchain/check/testdata/function/generic/return_slot.carbon index d9ce36315990..c5c4a94c7a42 100644 --- a/toolchain/check/testdata/function/generic/return_slot.carbon +++ b/toolchain/check/testdata/function/generic/return_slot.carbon @@ -128,7 +128,7 @@ fn G() { // CHECK:STDOUT: %return.param_patt: @Wrap.Make.%pattern_type (%pattern_type.51d) = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref: type = name_ref T, @Wrap.%T.loc15_12.2 [symbolic = %T (constants.%T)] -// CHECK:STDOUT: %.loc16_16.2: form = init_form %T.ref, call_param0 [symbolic = %.loc16_16.1 (constants.%.c6c)] +// CHECK:STDOUT: %.loc16_16.3: form = init_form %T.ref, call_param0 [symbolic = %.loc16_16.2 (constants.%.c6c)] // CHECK:STDOUT: %return.param: ref @Wrap.Make.%T (%T) = out_param call_param0 // CHECK:STDOUT: %return: ref @Wrap.Make.%T (%T) = return_slot %return.param // CHECK:STDOUT: } @@ -158,7 +158,7 @@ fn G() { // CHECK:STDOUT: // CHECK:STDOUT: generic fn @Wrap.Make(@Wrap.%T.loc15_12.2: type) { // CHECK:STDOUT: %T: type = symbolic_binding T, 0 [symbolic = %T (constants.%T)] -// CHECK:STDOUT: %.loc16_16.1: form = init_form %T, call_param0 [symbolic = %.loc16_16.1 (constants.%.c6c)] +// CHECK:STDOUT: %.loc16_16.2: form = init_form %T, call_param0 [symbolic = %.loc16_16.2 (constants.%.c6c)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T [symbolic = %pattern_type (constants.%pattern_type.51d)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -172,9 +172,9 @@ fn G() { // CHECK:STDOUT: %.loc16_27: @Wrap.Make.%Wrap.Make.type (%Wrap.Make.type.6e9) = specific_constant @Wrap.%Wrap.Make.decl, @Wrap(constants.%T) [symbolic = %Wrap.Make (constants.%Wrap.Make.e25)] // CHECK:STDOUT: %Make.ref: @Wrap.Make.%Wrap.Make.type (%Wrap.Make.type.6e9) = name_ref Make, %.loc16_27 [symbolic = %Wrap.Make (constants.%Wrap.Make.e25)] // CHECK:STDOUT: %Wrap.Make.specific_fn.loc16_27.1: = specific_function %Make.ref, @Wrap.Make(constants.%T) [symbolic = %Wrap.Make.specific_fn.loc16_27.2 (constants.%Wrap.Make.specific_fn.5c8)] -// CHECK:STDOUT: %.loc16_13: ref @Wrap.Make.%T (%T) = splice_block %return {} -// CHECK:STDOUT: %Wrap.Make.call: init @Wrap.Make.%T (%T) = call %Wrap.Make.specific_fn.loc16_27.1() to %.loc16_13 -// CHECK:STDOUT: return %Wrap.Make.call to %return +// CHECK:STDOUT: %.loc16_16.1: ref @Wrap.Make.%T (%T) = splice_block %return.param {} +// CHECK:STDOUT: %Wrap.Make.call: init @Wrap.Make.%T (%T) = call %Wrap.Make.specific_fn.loc16_27.1() to %.loc16_16.1 +// CHECK:STDOUT: return %Wrap.Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -259,7 +259,7 @@ fn G() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Wrap.Make(constants.%T) { // CHECK:STDOUT: %T => constants.%T -// CHECK:STDOUT: %.loc16_16.1 => constants.%.c6c +// CHECK:STDOUT: %.loc16_16.2 => constants.%.c6c // CHECK:STDOUT: %pattern_type => constants.%pattern_type.51d // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -279,7 +279,7 @@ fn G() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Wrap.Make(constants.%i32) { // CHECK:STDOUT: %T => constants.%i32 -// CHECK:STDOUT: %.loc16_16.1 => constants.%.941 +// CHECK:STDOUT: %.loc16_16.2 => constants.%.941 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.7ce // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -299,7 +299,7 @@ fn G() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Wrap.Make(constants.%empty_tuple.type) { // CHECK:STDOUT: %T => constants.%empty_tuple.type -// CHECK:STDOUT: %.loc16_16.1 => constants.%.62c +// CHECK:STDOUT: %.loc16_16.2 => constants.%.62c // CHECK:STDOUT: %pattern_type => constants.%pattern_type.cb1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -319,7 +319,7 @@ fn G() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Wrap.Make(constants.%C) { // CHECK:STDOUT: %T => constants.%C -// CHECK:STDOUT: %.loc16_16.1 => constants.%.64f +// CHECK:STDOUT: %.loc16_16.2 => constants.%.64f // CHECK:STDOUT: %pattern_type => constants.%pattern_type.7c7 // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/function/generic/type_param_scope.carbon b/toolchain/check/testdata/function/generic/type_param_scope.carbon index 66c911278cb8..6e1892cb83b9 100644 --- a/toolchain/check/testdata/function/generic/type_param_scope.carbon +++ b/toolchain/check/testdata/function/generic/type_param_scope.carbon @@ -70,7 +70,7 @@ fn F(T:! type, n: T*) -> T* { // CHECK:STDOUT: %specific_impl_fn.loc7_10.1: = specific_impl_function %impl.elem0.loc7_10.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc7_10.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc7_10.2: = bound_method %m.ref, %specific_impl_fn.loc7_10.1 // CHECK:STDOUT: %Copy.Op.call: init @F.%ptr.loc4_20.1 (%ptr) = call %bound_method.loc7_10.2(%m.ref) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/generic/dependent_param.carbon b/toolchain/check/testdata/generic/dependent_param.carbon index dc35e8067a87..98990f58fbcf 100644 --- a/toolchain/check/testdata/generic/dependent_param.carbon +++ b/toolchain/check/testdata/generic/dependent_param.carbon @@ -147,8 +147,8 @@ var n: i32 = Outer(i32).Inner(42).Get(); // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref: %Copy.type = name_ref T, @Outer.%T.loc4_13.2 [symbolic = %T (constants.%T.035)] // CHECK:STDOUT: %T.as_type: type = facet_access_type %T.ref [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc7_17.2: type = converted %T.ref, %T.as_type [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc7_17.3: form = init_form %.loc7_17.2, call_param0 [symbolic = %.loc7_17.1 (constants.%.504)] +// CHECK:STDOUT: %.loc7_17.3: type = converted %T.ref, %T.as_type [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc7_17.4: form = init_form %.loc7_17.3, call_param0 [symbolic = %.loc7_17.2 (constants.%.504)] // CHECK:STDOUT: %return.param: ref @Inner.Get.%T.binding.as_type (%T.binding.as_type) = out_param call_param0 // CHECK:STDOUT: %return: ref @Inner.Get.%T.binding.as_type (%T.binding.as_type) = return_slot %return.param // CHECK:STDOUT: } @@ -166,7 +166,7 @@ var n: i32 = Outer(i32).Inner(42).Get(); // CHECK:STDOUT: generic fn @Inner.Get(@Outer.%T.loc4_13.2: %Copy.type, @Inner.%U.loc5_15.2: @Inner.%T.binding.as_type (%T.binding.as_type)) { // CHECK:STDOUT: %T: %Copy.type = symbolic_binding T, 0 [symbolic = %T (constants.%T.035)] // CHECK:STDOUT: %T.binding.as_type: type = symbolic_binding_type T, 0, %T [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc7_17.1: form = init_form %T.binding.as_type, call_param0 [symbolic = %.loc7_17.1 (constants.%.504)] +// CHECK:STDOUT: %.loc7_17.2: form = init_form %T.binding.as_type, call_param0 [symbolic = %.loc7_17.2 (constants.%.504)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -186,9 +186,9 @@ var n: i32 = Outer(i32).Inner(42).Get(); // CHECK:STDOUT: %bound_method.loc7_28.1: = bound_method %U.ref, %impl.elem0.loc7_28.1 [symbolic = %bound_method.loc7_28.3 (constants.%bound_method.949)] // CHECK:STDOUT: %specific_impl_fn.loc7_28.1: = specific_impl_function %impl.elem0.loc7_28.1, @Copy.Op(constants.%T.035) [symbolic = %specific_impl_fn.loc7_28.2 (constants.%specific_impl_fn.2c9)] // CHECK:STDOUT: %bound_method.loc7_28.2: = bound_method %U.ref, %specific_impl_fn.loc7_28.1 [symbolic = %bound_method.loc7_28.4 (constants.%bound_method.397)] -// CHECK:STDOUT: %.loc7_14: ref @Inner.Get.%T.binding.as_type (%T.binding.as_type) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @Inner.Get.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc7_28.2(%U.ref) to %.loc7_14 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc7_17.1: ref @Inner.Get.%T.binding.as_type (%T.binding.as_type) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @Inner.Get.%T.binding.as_type (%T.binding.as_type) = call %bound_method.loc7_28.2(%U.ref) to %.loc7_17.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -243,7 +243,7 @@ var n: i32 = Outer(i32).Inner(42).Get(); // CHECK:STDOUT: specific @Inner.Get(constants.%T.035, constants.%U.959) { // CHECK:STDOUT: %T => constants.%T.035 // CHECK:STDOUT: %T.binding.as_type => constants.%T.binding.as_type -// CHECK:STDOUT: %.loc7_17.1 => constants.%.504 +// CHECK:STDOUT: %.loc7_17.2 => constants.%.504 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -269,7 +269,7 @@ var n: i32 = Outer(i32).Inner(42).Get(); // CHECK:STDOUT: specific @Inner.Get(constants.%Copy.facet.de4, constants.%int_42.c68) { // CHECK:STDOUT: %T => constants.%Copy.facet.de4 // CHECK:STDOUT: %T.binding.as_type => constants.%i32 -// CHECK:STDOUT: %.loc7_17.1 => constants.%.941 +// CHECK:STDOUT: %.loc7_17.2 => constants.%.941 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.7ce // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/generic/template/convert.carbon b/toolchain/check/testdata/generic/template/convert.carbon index 557fc39ddd1b..9784b8da6ce2 100644 --- a/toolchain/check/testdata/generic/template/convert.carbon +++ b/toolchain/check/testdata/generic/template/convert.carbon @@ -281,7 +281,7 @@ fn Test(d: D) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_10.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -291,7 +291,7 @@ fn Test(d: D) -> i32 { // CHECK:STDOUT: %n.ref: %i32 = name_ref n, %n // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%i32) [concrete = constants.%F.specific_fn.d18] // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%n.ref) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert(%self.param: %C) -> %i32 { @@ -305,7 +305,7 @@ fn Test(d: D) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc16_50.2: = bound_method %.loc16_50.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc16_50.2(%.loc16_50.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Test2(%c.param: %C) -> %i32 { @@ -314,7 +314,7 @@ fn Test(d: D) -> i32 { // CHECK:STDOUT: %c.ref: %C = name_ref c, %c // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C) [concrete = constants.%F.specific_fn.540] // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%c.ref) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T.67db0b.1) { @@ -484,7 +484,7 @@ fn Test(d: D) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc12_10.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc12_10.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -494,7 +494,7 @@ fn Test(d: D) -> i32 { // CHECK:STDOUT: %d.ref: %D = name_ref d, %d // CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%D) [concrete = constants.%F.specific_fn] // CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%d.ref) -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%T.67db0b.1) { diff --git a/toolchain/check/testdata/generic/template/member_access.carbon b/toolchain/check/testdata/generic/template/member_access.carbon index 84831a7a59f2..1df370bf605b 100644 --- a/toolchain/check/testdata/generic/template/member_access.carbon +++ b/toolchain/check/testdata/generic/template/member_access.carbon @@ -259,7 +259,7 @@ fn Test(e: E) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_10.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -451,7 +451,7 @@ fn Test(e: E) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc9_10.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc9_10.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -643,7 +643,7 @@ fn Test(e: E) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc12_10.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc12_10.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/generic/template/unimplemented.carbon b/toolchain/check/testdata/generic/template/unimplemented.carbon index d6d35ab41aee..6b8a513e1fe6 100644 --- a/toolchain/check/testdata/generic/template/unimplemented.carbon +++ b/toolchain/check/testdata/generic/template/unimplemented.carbon @@ -145,7 +145,7 @@ fn F[template T:! Core.Destroy](x: T) { // CHECK:STDOUT: %.loc11_11.1: @F.%T.loc6_15.1 (%T) = splice_inst %.loc11_11.3 // CHECK:STDOUT: %.loc11_11.2: @F.%.loc11_11.5 (@F.%.loc11_11.5) = splice_inst %.loc11_11.4 // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -239,7 +239,7 @@ fn F[template T:! Core.Destroy](x: T) { // CHECK:STDOUT: %c.ref: %C = name_ref c, %c.loc11_15.2 [template = %c.loc11_15.1 (constants.%c)] // CHECK:STDOUT: %.loc16_11.1: @F.%.loc16_11.3 (@F.%.loc16_11.3) = splice_inst %.loc16_11.2 // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/generic/template_dependence.carbon b/toolchain/check/testdata/generic/template_dependence.carbon index 9817df827355..393b4c11bc25 100644 --- a/toolchain/check/testdata/generic/template_dependence.carbon +++ b/toolchain/check/testdata/generic/template_dependence.carbon @@ -110,7 +110,7 @@ fn F(template T:! type, U:! type) -> (T, U) { // CHECK:STDOUT: %specific_impl_fn.loc6_10.1: = specific_impl_function %impl.elem0.loc6_10.1, @Copy.Op(constants.%Copy.facet) [template = %specific_impl_fn.loc6_10.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %.loc6_10.2, %specific_impl_fn.loc6_10.1 // CHECK:STDOUT: %Copy.Op.call: init @F.%ptr.loc5_29.1 (%ptr.e8f8f9.1) = call %bound_method.loc6_10.2(%.loc6_10.2) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -152,9 +152,9 @@ fn F(template T:! type, U:! type) -> (T, U) { // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc5: type = name_ref T, %T.loc5_15.2 [template = %T.loc5_15.1 (constants.%T)] // CHECK:STDOUT: %U.ref.loc5: type = name_ref U, %U.loc5_25.2 [symbolic = %U.loc5_25.1 (constants.%U)] -// CHECK:STDOUT: %.loc5_43.2: %tuple.type.24b = tuple_literal (%T.ref.loc5, %U.ref.loc5) [template = %tuple (constants.%tuple)] -// CHECK:STDOUT: %.loc5_43.3: type = converted %.loc5_43.2, constants.%tuple.type.a5e [template = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc5_43.4: form = init_form %.loc5_43.3, call_param0 [template = %.loc5_43.1 (constants.%.5b7)] +// CHECK:STDOUT: %.loc5_43.3: %tuple.type.24b = tuple_literal (%T.ref.loc5, %U.ref.loc5) [template = %tuple (constants.%tuple)] +// CHECK:STDOUT: %.loc5_43.4: type = converted %.loc5_43.3, constants.%tuple.type.a5e [template = %tuple.type (constants.%tuple.type.a5e)] +// CHECK:STDOUT: %.loc5_43.5: form = init_form %.loc5_43.4, call_param0 [template = %.loc5_43.2 (constants.%.5b7)] // CHECK:STDOUT: // CHECK:STDOUT: %T.loc5_15.2: type = symbolic_binding T, 0, template [template = %T.loc5_15.1 (constants.%T)] // CHECK:STDOUT: @@ -169,7 +169,7 @@ fn F(template T:! type, U:! type) -> (T, U) { // CHECK:STDOUT: %U.loc5_25.1: type = symbolic_binding U, 1 [symbolic = %U.loc5_25.1 (constants.%U)] // CHECK:STDOUT: %tuple: %tuple.type.24b = tuple_value (%T.loc5_15.1, %U.loc5_25.1) [template = %tuple (constants.%tuple)] // CHECK:STDOUT: %tuple.type: type = tuple_type (%T.loc5_15.1, %U.loc5_25.1) [template = %tuple.type (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc5_43.1: form = init_form %tuple.type, call_param0 [template = %.loc5_43.1 (constants.%.5b7)] +// CHECK:STDOUT: %.loc5_43.2: form = init_form %tuple.type, call_param0 [template = %.loc5_43.2 (constants.%.5b7)] // CHECK:STDOUT: %pattern_type: type = pattern_type %tuple.type [template = %pattern_type (constants.%pattern_type.eee)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -182,9 +182,9 @@ fn F(template T:! type, U:! type) -> (T, U) { // CHECK:STDOUT: %T.ref.loc6: type = name_ref T, %T.loc5_15.2 [template = %T.loc5_15.1 (constants.%T)] // CHECK:STDOUT: %U.ref.loc6: type = name_ref U, %U.loc5_25.2 [symbolic = %U.loc5_25.1 (constants.%U)] // CHECK:STDOUT: %F.specific_fn.loc6_10.1: = specific_function %F.ref, @F(constants.%T, constants.%U) [template = %F.specific_fn.loc6_10.2 (constants.%F.specific_fn)] -// CHECK:STDOUT: %.loc5_35: ref @F.%tuple.type (%tuple.type.a5e) = splice_block %return {} -// CHECK:STDOUT: %F.call: init @F.%tuple.type (%tuple.type.a5e) = call %F.specific_fn.loc6_10.1() to %.loc5_35 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc5_43.1: ref @F.%tuple.type (%tuple.type.a5e) = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init @F.%tuple.type (%tuple.type.a5e) = call %F.specific_fn.loc6_10.1() to %.loc5_43.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -193,7 +193,7 @@ fn F(template T:! type, U:! type) -> (T, U) { // CHECK:STDOUT: %U.loc5_25.1 => constants.%U // CHECK:STDOUT: %tuple => constants.%tuple // CHECK:STDOUT: %tuple.type => constants.%tuple.type.a5e -// CHECK:STDOUT: %.loc5_43.1 => constants.%.5b7 +// CHECK:STDOUT: %.loc5_43.2 => constants.%.5b7 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.eee // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/if/basics.carbon b/toolchain/check/testdata/if/basics.carbon index f6fe0e3e3151..701b31e53b5d 100644 --- a/toolchain/check/testdata/if/basics.carbon +++ b/toolchain/check/testdata/if/basics.carbon @@ -272,13 +272,13 @@ fn VarScope(b: bool) -> bool { // CHECK:STDOUT: %impl.elem0.loc6: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method.loc6: = bound_method %false, %impl.elem0.loc6 [concrete = constants.%bool.as.Copy.impl.Op.bound.082] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc6: init bool = call %bound_method.loc6(%false) [concrete = constants.%false] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call.loc6 to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call.loc6 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else: // CHECK:STDOUT: %true: bool = bool_literal true [concrete = constants.%true] // CHECK:STDOUT: %impl.elem0.loc8: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method.loc8: = bound_method %true, %impl.elem0.loc8 [concrete = constants.%bool.as.Copy.impl.Op.bound.12b] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc8: init bool = call %bound_method.loc8(%true) [concrete = constants.%true] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call.loc8 to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call.loc8 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/if_expr/basic.carbon b/toolchain/check/testdata/if_expr/basic.carbon index 0092ca118e44..2a887358b46f 100644 --- a/toolchain/check/testdata/if_expr/basic.carbon +++ b/toolchain/check/testdata/if_expr/basic.carbon @@ -193,7 +193,7 @@ fn F(b: bool, n: i32, m: i32) -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_10.2(%.loc17_10) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %x.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%x.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %array_type) = "no_op"; diff --git a/toolchain/check/testdata/if_expr/constant_condition.carbon b/toolchain/check/testdata/if_expr/constant_condition.carbon index e1f2dff8da8f..58ad7303922e 100644 --- a/toolchain/check/testdata/if_expr/constant_condition.carbon +++ b/toolchain/check/testdata/if_expr/constant_condition.carbon @@ -218,7 +218,7 @@ fn PartiallyConstant(t: type) -> i32 { // CHECK:STDOUT: %bound_method.loc15_25.2: = bound_method %int_1, %specific_fn [concrete = constants.%bound_method.38b] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc15_25.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc15_25: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: return %.loc15_25 to %return +// CHECK:STDOUT: return %.loc15_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B() -> %i32 { @@ -230,7 +230,7 @@ fn PartiallyConstant(t: type) -> i32 { // CHECK:STDOUT: %bound_method.loc16_25.2: = bound_method %int_2, %specific_fn [concrete = constants.%bound_method.646] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc16_25.2(%int_2) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc16_25: init %i32 = converted %int_2, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: return %.loc16_25 to %return +// CHECK:STDOUT: return %.loc16_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() -> %i32 { @@ -259,7 +259,7 @@ fn PartiallyConstant(t: type) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc19_10.2: = bound_method %.loc19_10, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc19_10.2(%.loc19_10) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G() -> %i32 { @@ -288,7 +288,7 @@ fn PartiallyConstant(t: type) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc23_10.2: = bound_method %.loc23_10, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc23_10.2(%.loc23_10) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Constant() -> %i32 { @@ -378,7 +378,7 @@ fn PartiallyConstant(t: type) -> i32 { // CHECK:STDOUT: %DestroyOp.call.loc28: init %empty_tuple.type = call %DestroyOp.bound.loc28(%w.var) // CHECK:STDOUT: %DestroyOp.bound.loc27: = bound_method %v.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call.loc27: init %empty_tuple.type = call %DestroyOp.bound.loc27(%v.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc28(%self.param: %ptr.235) = "no_op"; @@ -469,6 +469,6 @@ fn PartiallyConstant(t: type) -> i32 { // CHECK:STDOUT: %DestroyOp.call.loc34: init %empty_tuple.type = call %DestroyOp.bound.loc34(%w.var) // CHECK:STDOUT: %DestroyOp.bound.loc33: = bound_method %v.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call.loc33: init %empty_tuple.type = call %DestroyOp.bound.loc33(%v.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/if_expr/control_flow.carbon b/toolchain/check/testdata/if_expr/control_flow.carbon index 7953038bef48..37f46c95c81a 100644 --- a/toolchain/check/testdata/if_expr/control_flow.carbon +++ b/toolchain/check/testdata/if_expr/control_flow.carbon @@ -149,7 +149,7 @@ fn F(b: bool) -> i32 { // CHECK:STDOUT: %bound_method.loc15_25.2: = bound_method %int_1, %specific_fn [concrete = constants.%bound_method.38b] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc15_25.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc15_25: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: return %.loc15_25 to %return +// CHECK:STDOUT: return %.loc15_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B() -> %i32 { @@ -161,7 +161,7 @@ fn F(b: bool) -> i32 { // CHECK:STDOUT: %bound_method.loc16_25.2: = bound_method %int_2, %specific_fn [concrete = constants.%bound_method.646] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc16_25.2(%int_2) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc16_25: init %i32 = converted %int_2, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: return %.loc16_25 to %return +// CHECK:STDOUT: return %.loc16_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F(%b.param: bool) -> %i32 { @@ -190,6 +190,6 @@ fn F(b: bool) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc19_10.2: = bound_method %.loc19_10, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc19_10.2(%.loc19_10) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/if_expr/nested.carbon b/toolchain/check/testdata/if_expr/nested.carbon index d3e391043db9..5f871b4ce6a7 100644 --- a/toolchain/check/testdata/if_expr/nested.carbon +++ b/toolchain/check/testdata/if_expr/nested.carbon @@ -212,6 +212,6 @@ fn F(a: bool, b: bool, c: bool) -> i32 { // CHECK:STDOUT: %specific_fn.loc16_10: = specific_function %impl.elem0.loc16_10, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc16_10.2: = bound_method %.loc16_10, %specific_fn.loc16_10 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc16_10.2(%.loc16_10) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/assoc_const_self.carbon b/toolchain/check/testdata/impl/assoc_const_self.carbon index ad3cb095e73b..6ad3a79a92a1 100644 --- a/toolchain/check/testdata/impl/assoc_const_self.carbon +++ b/toolchain/check/testdata/impl/assoc_const_self.carbon @@ -544,9 +544,9 @@ fn CallF() { // CHECK:STDOUT: fn @empty_tuple.type.as.ImplicitAs.impl.Convert(%self.param: %empty_tuple.type) -> %return.param: %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc11_41.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc11_41.2: init %C = class_init (), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc11_41.2: init %C = class_init (), %return.param [concrete = constants.%C.val] // CHECK:STDOUT: %.loc11_42: init %C = converted %.loc11_41.1, %.loc11_41.2 [concrete = constants.%C.val] -// CHECK:STDOUT: return %.loc11_42 to %return +// CHECK:STDOUT: return %.loc11_42 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @V(constants.%Self.ab9) { diff --git a/toolchain/check/testdata/impl/extend_impl_generic.carbon b/toolchain/check/testdata/impl/extend_impl_generic.carbon index 8ada338d398a..9a9b824d312e 100644 --- a/toolchain/check/testdata/impl/extend_impl_generic.carbon +++ b/toolchain/check/testdata/impl/extend_impl_generic.carbon @@ -283,11 +283,11 @@ class X(U:! type) { // CHECK:STDOUT: %bound_method.loc15_21.2: = bound_method %int_2, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc15_21.2(%int_2) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc15_21.2: init %i32 = converted %int_2, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc15_21.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc15_21.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc15_21.4: init %i32 = initialize_from %.loc15_21.2 to %.loc15_21.3 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc15_21.5: init %Param = class_init (%.loc15_21.4), %return [concrete = constants.%Param.val] +// CHECK:STDOUT: %.loc15_21.5: init %Param = class_init (%.loc15_21.4), %return.param [concrete = constants.%Param.val] // CHECK:STDOUT: %.loc15_22: init %Param = converted %.loc15_21.1, %.loc15_21.5 [concrete = constants.%Param.val] -// CHECK:STDOUT: return %.loc15_22 to %return +// CHECK:STDOUT: return %.loc15_22 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G(%c.param: %C) { diff --git a/toolchain/check/testdata/impl/fail_impl_bad_assoc_fn.carbon b/toolchain/check/testdata/impl/fail_impl_bad_assoc_fn.carbon index bae2fd1e4105..d25289dfc4bd 100644 --- a/toolchain/check/testdata/impl/fail_impl_bad_assoc_fn.carbon +++ b/toolchain/check/testdata/impl/fail_impl_bad_assoc_fn.carbon @@ -1260,7 +1260,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %b.ref: bool = name_ref b, %b.param // CHECK:STDOUT: %return.ref: ref bool = name_ref , %return.param // CHECK:STDOUT: %FMissingParam.as.J.impl.F.bound: = bound_method %self.ref, %F.ref -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @FMissingImplicitParam.as.J.impl.F.loc130_26.1(%b.param: bool) -> bool; @@ -1272,7 +1272,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %b.ref: bool = name_ref b, %b.param // CHECK:STDOUT: %return.ref: ref bool = name_ref , %return.param // CHECK:STDOUT: %FMissingImplicitParam.as.J.impl.F.call: init bool = call %F.ref(%b.ref) -// CHECK:STDOUT: return %FMissingImplicitParam.as.J.impl.F.call to %return +// CHECK:STDOUT: return %FMissingImplicitParam.as.J.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @FMissingReturnType.as.J.impl.F.loc152_30.1(%self.param: bool, %b.param: bool); @@ -1286,7 +1286,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %FMissingReturnType.as.J.impl.F.bound: = bound_method %self.ref, %F.ref // CHECK:STDOUT: %FMissingReturnType.as.J.impl.F.call: init %empty_tuple.type = call %FMissingReturnType.as.J.impl.F.bound(%self.ref, %b.ref) // CHECK:STDOUT: %.loc152: bool = converted %FMissingReturnType.as.J.impl.F.call, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @FDifferentParamType.as.J.impl.F.loc171_38.1(%self.param: bool, %b.param: %FDifferentParamType) -> bool; @@ -1300,7 +1300,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %FDifferentParamType.as.J.impl.F.bound: = bound_method %self.ref, %F.ref // CHECK:STDOUT: %.loc103: %FDifferentParamType = converted %b.ref, [concrete = ] // CHECK:STDOUT: %FDifferentParamType.as.J.impl.F.call: init bool = call %FDifferentParamType.as.J.impl.F.bound(%self.ref, ) -// CHECK:STDOUT: return %FDifferentParamType.as.J.impl.F.call to %return +// CHECK:STDOUT: return %FDifferentParamType.as.J.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @FDifferentImplicitParamType.as.J.impl.F.loc184_38.1(%self.param: %FDifferentImplicitParamType, %b.param: bool) -> bool; @@ -1314,7 +1314,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %FDifferentImplicitParamType.as.J.impl.F.bound: = bound_method %self.ref, %F.ref // CHECK:STDOUT: %.loc103: %FDifferentImplicitParamType = converted %self.ref, [concrete = ] // CHECK:STDOUT: %FDifferentImplicitParamType.as.J.impl.F.call: init bool = call %FDifferentImplicitParamType.as.J.impl.F.bound(, %b.ref) -// CHECK:STDOUT: return %FDifferentImplicitParamType.as.J.impl.F.call to %return +// CHECK:STDOUT: return %FDifferentImplicitParamType.as.J.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @FDifferentReturnType.as.J.impl.F.loc200_38.1(%self.param: bool, %b.param: bool) -> %return.param: %FDifferentReturnType; @@ -1329,7 +1329,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %.loc200_38.1: ref %FDifferentReturnType = temporary_storage // CHECK:STDOUT: %FDifferentReturnType.as.J.impl.F.call: init %FDifferentReturnType = call %FDifferentReturnType.as.J.impl.F.bound(%self.ref, %b.ref) to %.loc200_38.1 // CHECK:STDOUT: %.loc200_38.2: bool = converted %FDifferentReturnType.as.J.impl.F.call, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @SelfNested.F(@SelfNested.%Self: %SelfNested.type) { @@ -1354,13 +1354,13 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %F.ref: %SelfNestedBadParam.as.SelfNested.impl.F.type.789632.1 = name_ref F, @SelfNestedBadParam.as.SelfNested.impl.%SelfNestedBadParam.as.SelfNested.impl.F.decl.loc223_87.1 [concrete = constants.%SelfNestedBadParam.as.SelfNested.impl.F.6e1661.1] // CHECK:STDOUT: %x.ref: %tuple.type.7ea = name_ref x, %x.param // CHECK:STDOUT: %return.ref: ref %array_type.388 = name_ref , %return.param -// CHECK:STDOUT: %.loc211_41: ref %array_type.388 = splice_block %return {} +// CHECK:STDOUT: %.loc211_57: ref %array_type.388 = splice_block %return.param {} // CHECK:STDOUT: %tuple.elem0: %ptr.cf2 = tuple_access %x.ref, element0 // CHECK:STDOUT: %tuple.elem1: %struct_type.x.y.62a = tuple_access %x.ref, element1 // CHECK:STDOUT: %.loc211_9.1: %SelfNestedBadParam = struct_access %tuple.elem1, element0 // CHECK:STDOUT: %.loc211_9.2: %i32 = converted %.loc211_9.1, [concrete = ] -// CHECK:STDOUT: %SelfNestedBadParam.as.SelfNested.impl.F.call: init %array_type.388 = call %F.ref() to %.loc211_41 -// CHECK:STDOUT: return %SelfNestedBadParam.as.SelfNested.impl.F.call to %return +// CHECK:STDOUT: %SelfNestedBadParam.as.SelfNested.impl.F.call: init %array_type.388 = call %F.ref() to %.loc211_57 +// CHECK:STDOUT: return %SelfNestedBadParam.as.SelfNested.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @SelfNestedBadReturnType.as.SelfNested.impl.F.loc239_112.1(%x.param: %tuple.type.064) -> %return.param: %array_type.388; @@ -1373,7 +1373,7 @@ class SelfNestedBadReturnType { // CHECK:STDOUT: %.loc239_112.1: ref %array_type.388 = temporary_storage // CHECK:STDOUT: %SelfNestedBadReturnType.as.SelfNested.impl.F.call: init %array_type.388 = call %F.ref(%x.ref) to %.loc239_112.1 // CHECK:STDOUT: %.loc239_112.2: %array_type.31b = converted %SelfNestedBadReturnType.as.SelfNested.impl.F.call, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @I.F(constants.%Self.ab9) {} diff --git a/toolchain/check/testdata/impl/generic_redeclaration.carbon b/toolchain/check/testdata/impl/generic_redeclaration.carbon index 90e025328642..0ce1dbb7d2e6 100644 --- a/toolchain/check/testdata/impl/generic_redeclaration.carbon +++ b/toolchain/check/testdata/impl/generic_redeclaration.carbon @@ -760,9 +760,9 @@ impl forall [T:! type] T as I { // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc19_26.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc19_26.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc19_26.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc19_27: init %empty_tuple.type = converted %.loc19_26.1, %.loc19_26.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc19_27 to %return +// CHECK:STDOUT: return %.loc19_27 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -779,7 +779,7 @@ impl forall [T:! type] T as I { // CHECK:STDOUT: %C.ref: @T.as.I.impl.D.%T.as.I.impl.C.type (%T.as.I.impl.C.type) = name_ref C, %.loc21 [symbolic = %T.as.I.impl.C (constants.%T.as.I.impl.C)] // CHECK:STDOUT: %T.as.I.impl.C.specific_fn.loc21_12.1: = specific_function %C.ref, @T.as.I.impl.C(constants.%T) [symbolic = %T.as.I.impl.C.specific_fn.loc21_12.2 (constants.%T.as.I.impl.C.specific_fn)] // CHECK:STDOUT: %T.as.I.impl.C.call: init %empty_tuple.type = call %T.as.I.impl.C.specific_fn.loc21_12.1() -// CHECK:STDOUT: return %T.as.I.impl.C.call to %return +// CHECK:STDOUT: return %T.as.I.impl.C.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/impl_thunk.carbon b/toolchain/check/testdata/impl/impl_thunk.carbon index 0d5bde1dc01b..b9de12ec656b 100644 --- a/toolchain/check/testdata/impl/impl_thunk.carbon +++ b/toolchain/check/testdata/impl/impl_thunk.carbon @@ -398,18 +398,18 @@ impl () as I({}) { // CHECK:STDOUT: %empty_tuple.type.as.I.impl.F.call: init %struct_type.d.c.b36 = call %F.ref(%.loc5_9.3) to %.loc10_48.1 // CHECK:STDOUT: %.loc10_48.2: ref %struct_type.d.c.b36 = temporary %.loc10_48.1, %empty_tuple.type.as.I.impl.F.call // CHECK:STDOUT: %.loc10_48.3: ref %empty_tuple.type = struct_access %.loc10_48.2, element1 -// CHECK:STDOUT: %.loc10_48.4: ref %empty_tuple.type = struct_access %return, element1 +// CHECK:STDOUT: %.loc10_48.4: ref %empty_tuple.type = struct_access %return.param, element1 // CHECK:STDOUT: %.loc10_48.5: init %empty_tuple.type = tuple_init () to %.loc10_48.4 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc10_48.6: init %empty_tuple.type = converted %.loc10_48.3, %.loc10_48.5 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc10_48.7: ref %empty_struct_type = struct_access %.loc10_48.2, element0 -// CHECK:STDOUT: %.loc10_48.8: ref %empty_struct_type = struct_access %return, element0 +// CHECK:STDOUT: %.loc10_48.8: ref %empty_struct_type = struct_access %return.param, element0 // CHECK:STDOUT: %.loc10_48.9: init %empty_struct_type = struct_init () to %.loc10_48.8 [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc10_48.10: init %empty_struct_type = converted %.loc10_48.7, %.loc10_48.9 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc10_48.11: init %struct_type.c.d.15a = struct_init (%.loc10_48.6, %.loc10_48.10) to %return [concrete = constants.%struct] +// CHECK:STDOUT: %.loc10_48.11: init %struct_type.c.d.15a = struct_init (%.loc10_48.6, %.loc10_48.10) to %return.param [concrete = constants.%struct] // CHECK:STDOUT: %.loc10_48.12: init %struct_type.c.d.15a = converted %empty_tuple.type.as.I.impl.F.call, %.loc10_48.11 [concrete = constants.%struct] // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc10_48.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc10_48.2) -// CHECK:STDOUT: return %.loc10_48.12 to %return +// CHECK:STDOUT: return %.loc10_48.12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %struct_type.d.c.b36) = "no_op"; @@ -508,7 +508,7 @@ impl () as I({}) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%B) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_37.2: = bound_method %.loc14_37.5, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.27c = call %bound_method.loc14_37.2(%.loc14_37.5) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- inheritance_value_conversion.carbon @@ -660,7 +660,7 @@ impl () as I({}) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%B) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_37.2: = bound_method %.loc14_37.5, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.27c = call %bound_method.loc14_37.2(%.loc14_37.5) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- inheritance_value_conversion_pointer_addr.carbon @@ -757,7 +757,7 @@ impl () as I({}) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%B) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_37.2: = bound_method %.loc14_37.5, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.27c = call %bound_method.loc14_37.2(%.loc14_37.5) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_inheritance_value_conversion_copy_return.carbon @@ -817,7 +817,7 @@ impl () as I({}) { // CHECK:STDOUT: %.loc23_14.5: %A = acquire_value %.loc23_14.4 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc23_14.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc23_14.2) -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %B) = "no_op"; @@ -874,8 +874,8 @@ impl () as I({}) { // CHECK:STDOUT: } { // CHECK:STDOUT: %U.ref.loc10_32: %Copy.type = name_ref U, %U.loc10_8.2 [symbolic = %U.loc10_8.1 (constants.%U.035)] // CHECK:STDOUT: %U.as_type.loc10_32: type = facet_access_type %U.ref.loc10_32 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] -// CHECK:STDOUT: %.loc10_32.2: type = converted %U.ref.loc10_32, %U.as_type.loc10_32 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] -// CHECK:STDOUT: %.loc10_32.3: form = init_form %.loc10_32.2, call_param1 [symbolic = %.loc10_32.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc10_32.3: type = converted %U.ref.loc10_32, %U.as_type.loc10_32 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] +// CHECK:STDOUT: %.loc10_32.4: form = init_form %.loc10_32.3, call_param1 [symbolic = %.loc10_32.2 (constants.%.075d25.1)] // CHECK:STDOUT: %.loc10_16: type = splice_block %Copy.ref [concrete = constants.%Copy.type] { // CHECK:STDOUT: // CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [concrete = imports.%Core] @@ -909,7 +909,7 @@ impl () as I({}) { // CHECK:STDOUT: %U.loc10_8.1: %Copy.type = symbolic_binding U, 0 [symbolic = %U.loc10_8.1 (constants.%U.035)] // CHECK:STDOUT: %U.binding.as_type: type = symbolic_binding_type U, 0, %U.loc10_8.1 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] // CHECK:STDOUT: %pattern_type: type = pattern_type %U.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc10_32.1: form = init_form %U.binding.as_type, call_param1 [symbolic = %.loc10_32.1 (constants.%.075d25.1)] +// CHECK:STDOUT: %.loc10_32.2: form = init_form %U.binding.as_type, call_param1 [symbolic = %.loc10_32.2 (constants.%.075d25.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete: = require_complete_type %U.binding.as_type [symbolic = %require_complete (constants.%require_complete.67ca8d.1)] @@ -925,9 +925,9 @@ impl () as I({}) { // CHECK:STDOUT: %bound_method.loc10_43.1: = bound_method %x.ref, %impl.elem0.loc10_43.1 // CHECK:STDOUT: %specific_impl_fn.loc10_43.1: = specific_impl_function %impl.elem0.loc10_43.1, @Copy.Op(constants.%U.035) [symbolic = %specific_impl_fn.loc10_43.2 (constants.%specific_impl_fn.2c9874.2)] // CHECK:STDOUT: %bound_method.loc10_43.2: = bound_method %x.ref, %specific_impl_fn.loc10_43.1 -// CHECK:STDOUT: %.loc10_29: ref @empty_tuple.type.as.I.impl.F.loc10_34.1.%U.binding.as_type (%U.binding.as_type.14b) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @empty_tuple.type.as.I.impl.F.loc10_34.1.%U.binding.as_type (%U.binding.as_type.14b) = call %bound_method.loc10_43.2(%x.ref) to %.loc10_29 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc10_32.1: ref @empty_tuple.type.as.I.impl.F.loc10_34.1.%U.binding.as_type (%U.binding.as_type.14b) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @empty_tuple.type.as.I.impl.F.loc10_34.1.%U.binding.as_type (%U.binding.as_type.14b) = call %bound_method.loc10_43.2(%x.ref) to %.loc10_32.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -951,7 +951,7 @@ impl () as I({}) { // CHECK:STDOUT: %.loc10_34.2: %Copy.type = converted constants.%ptr.e8f, %Copy.facet.loc10_34.2 [symbolic = %Copy.facet.loc10_34.3 (constants.%Copy.facet)] // CHECK:STDOUT: %empty_tuple.type.as.I.impl.F.specific_fn.loc10_34.1: = specific_function %F.ref, @empty_tuple.type.as.I.impl.F.loc10_34.1(constants.%Copy.facet) [symbolic = %empty_tuple.type.as.I.impl.F.specific_fn.loc10_34.2 (constants.%empty_tuple.type.as.I.impl.F.specific_fn)] // CHECK:STDOUT: %empty_tuple.type.as.I.impl.F.call: init @empty_tuple.type.as.I.impl.F.loc10_34.2.%ptr (%ptr.e8f) = call %empty_tuple.type.as.I.impl.F.specific_fn.loc10_34.1(%x.ref) -// CHECK:STDOUT: return %empty_tuple.type.as.I.impl.F.call to %return +// CHECK:STDOUT: return %empty_tuple.type.as.I.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -959,7 +959,7 @@ impl () as I({}) { // CHECK:STDOUT: %U.loc10_8.1 => constants.%U.035 // CHECK:STDOUT: %U.binding.as_type => constants.%U.binding.as_type.14b // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc10_32.1 => constants.%.075d25.1 +// CHECK:STDOUT: %.loc10_32.2 => constants.%.075d25.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @empty_tuple.type.as.I.impl.F.loc10_34.2(constants.%T.67d) { @@ -973,7 +973,7 @@ impl () as I({}) { // CHECK:STDOUT: %U.loc10_8.1 => constants.%Copy.facet // CHECK:STDOUT: %U.binding.as_type => constants.%ptr.e8f // CHECK:STDOUT: %pattern_type => constants.%pattern_type.4f4 -// CHECK:STDOUT: %.loc10_32.1 => constants.%.ba4 +// CHECK:STDOUT: %.loc10_32.2 => constants.%.ba4 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%require_complete.ef1 @@ -1040,8 +1040,8 @@ impl () as I({}) { // CHECK:STDOUT: } { // CHECK:STDOUT: %U.ref.loc10_42: %Copy.type = name_ref U, %U.loc10_18.2 [symbolic = %U.loc10_18.1 (constants.%U.035)] // CHECK:STDOUT: %U.as_type.loc10_42: type = facet_access_type %U.ref.loc10_42 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] -// CHECK:STDOUT: %.loc10_42.2: type = converted %U.ref.loc10_42, %U.as_type.loc10_42 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] -// CHECK:STDOUT: %.loc10_42.3: form = init_form %.loc10_42.2, call_param2 [symbolic = %.loc10_42.1 (constants.%.784)] +// CHECK:STDOUT: %.loc10_42.3: type = converted %U.ref.loc10_42, %U.as_type.loc10_42 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] +// CHECK:STDOUT: %.loc10_42.4: form = init_form %.loc10_42.3, call_param2 [symbolic = %.loc10_42.2 (constants.%.784)] // CHECK:STDOUT: %self.param: %empty_tuple.type = value_param call_param0 // CHECK:STDOUT: %.loc10_15.1: type = splice_block %.loc10_15.3 [concrete = constants.%empty_tuple.type] { // CHECK:STDOUT: %.loc10_15.2: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] @@ -1081,7 +1081,7 @@ impl () as I({}) { // CHECK:STDOUT: %U.loc10_18.1: %Copy.type = symbolic_binding U, 0 [symbolic = %U.loc10_18.1 (constants.%U.035)] // CHECK:STDOUT: %U.binding.as_type: type = symbolic_binding_type U, 0, %U.loc10_18.1 [symbolic = %U.binding.as_type (constants.%U.binding.as_type.14b)] // CHECK:STDOUT: %pattern_type: type = pattern_type %U.binding.as_type [symbolic = %pattern_type (constants.%pattern_type.9b9f0c.1)] -// CHECK:STDOUT: %.loc10_42.1: form = init_form %U.binding.as_type, call_param2 [symbolic = %.loc10_42.1 (constants.%.784)] +// CHECK:STDOUT: %.loc10_42.2: form = init_form %U.binding.as_type, call_param2 [symbolic = %.loc10_42.2 (constants.%.784)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete: = require_complete_type %U.binding.as_type [symbolic = %require_complete (constants.%require_complete.67ca8d.1)] @@ -1097,9 +1097,9 @@ impl () as I({}) { // CHECK:STDOUT: %bound_method.loc10_53.1: = bound_method %x.ref, %impl.elem0.loc10_53.1 // CHECK:STDOUT: %specific_impl_fn.loc10_53.1: = specific_impl_function %impl.elem0.loc10_53.1, @Copy.Op(constants.%U.035) [symbolic = %specific_impl_fn.loc10_53.2 (constants.%specific_impl_fn.2c9874.2)] // CHECK:STDOUT: %bound_method.loc10_53.2: = bound_method %x.ref, %specific_impl_fn.loc10_53.1 -// CHECK:STDOUT: %.loc10_39: ref @empty_tuple.type.as.I.impl.F.loc10_44.1.%U.binding.as_type (%U.binding.as_type.14b) = splice_block %return {} -// CHECK:STDOUT: %Copy.Op.call: init @empty_tuple.type.as.I.impl.F.loc10_44.1.%U.binding.as_type (%U.binding.as_type.14b) = call %bound_method.loc10_53.2(%x.ref) to %.loc10_39 -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: %.loc10_42.1: ref @empty_tuple.type.as.I.impl.F.loc10_44.1.%U.binding.as_type (%U.binding.as_type.14b) = splice_block %return.param {} +// CHECK:STDOUT: %Copy.Op.call: init @empty_tuple.type.as.I.impl.F.loc10_44.1.%U.binding.as_type (%U.binding.as_type.14b) = call %bound_method.loc10_53.2(%x.ref) to %.loc10_42.1 +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1125,7 +1125,7 @@ impl () as I({}) { // CHECK:STDOUT: %empty_tuple.type.as.I.impl.F.specific_fn.loc10_44.1: = specific_function %F.ref, @empty_tuple.type.as.I.impl.F.loc10_44.1(constants.%Copy.facet) [symbolic = %empty_tuple.type.as.I.impl.F.specific_fn.loc10_44.2 (constants.%empty_tuple.type.as.I.impl.F.specific_fn)] // CHECK:STDOUT: %bound_method: = bound_method %self.ref, %empty_tuple.type.as.I.impl.F.specific_fn.loc10_44.1 // CHECK:STDOUT: %empty_tuple.type.as.I.impl.F.call: init @empty_tuple.type.as.I.impl.F.loc10_44.2.%ptr (%ptr.e8f) = call %bound_method(%self.ref, %x.ref) -// CHECK:STDOUT: return %empty_tuple.type.as.I.impl.F.call to %return +// CHECK:STDOUT: return %empty_tuple.type.as.I.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1133,7 +1133,7 @@ impl () as I({}) { // CHECK:STDOUT: %U.loc10_18.1 => constants.%U.035 // CHECK:STDOUT: %U.binding.as_type => constants.%U.binding.as_type.14b // CHECK:STDOUT: %pattern_type => constants.%pattern_type.9b9f0c.1 -// CHECK:STDOUT: %.loc10_42.1 => constants.%.784 +// CHECK:STDOUT: %.loc10_42.2 => constants.%.784 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @empty_tuple.type.as.I.impl.F.loc10_44.2(constants.%T.67d) { @@ -1147,7 +1147,7 @@ impl () as I({}) { // CHECK:STDOUT: %U.loc10_18.1 => constants.%Copy.facet // CHECK:STDOUT: %U.binding.as_type => constants.%ptr.e8f // CHECK:STDOUT: %pattern_type => constants.%pattern_type.4f4 -// CHECK:STDOUT: %.loc10_42.1 => constants.%.7c9 +// CHECK:STDOUT: %.loc10_42.2 => constants.%.7c9 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete => constants.%require_complete.ef1 @@ -1216,18 +1216,18 @@ impl () as I({}) { // CHECK:STDOUT: %empty_tuple.type.as.I.impl.F.call: init %struct_type.b.a.1b0 = call %F.ref() to %.loc10_29.1 // CHECK:STDOUT: %.loc10_29.2: ref %struct_type.b.a.1b0 = temporary %.loc10_29.1, %empty_tuple.type.as.I.impl.F.call // CHECK:STDOUT: %.loc10_29.3: ref %empty_struct_type = struct_access %.loc10_29.2, element1 -// CHECK:STDOUT: %.loc10_29.4: ref %empty_struct_type = struct_access %return, element1 +// CHECK:STDOUT: %.loc10_29.4: ref %empty_struct_type = struct_access %return.param, element1 // CHECK:STDOUT: %.loc10_29.5: init %empty_struct_type = struct_init () to %.loc10_29.4 [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc10_29.6: init %empty_struct_type = converted %.loc10_29.3, %.loc10_29.5 [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc10_29.7: ref %empty_struct_type = struct_access %.loc10_29.2, element0 -// CHECK:STDOUT: %.loc10_29.8: ref %empty_struct_type = struct_access %return, element0 +// CHECK:STDOUT: %.loc10_29.8: ref %empty_struct_type = struct_access %return.param, element0 // CHECK:STDOUT: %.loc10_29.9: init %empty_struct_type = struct_init () to %.loc10_29.8 [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc10_29.10: init %empty_struct_type = converted %.loc10_29.7, %.loc10_29.9 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc10_29.11: init %struct_type.a.b.f95 = struct_init (%.loc10_29.6, %.loc10_29.10) to %return [concrete = constants.%struct] +// CHECK:STDOUT: %.loc10_29.11: init %struct_type.a.b.f95 = struct_init (%.loc10_29.6, %.loc10_29.10) to %return.param [concrete = constants.%struct] // CHECK:STDOUT: %.loc10_29.12: init %struct_type.a.b.f95 = converted %empty_tuple.type.as.I.impl.F.call, %.loc10_29.11 [concrete = constants.%struct] // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc10_29.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc10_29.2) -// CHECK:STDOUT: return %.loc10_29.12 to %return +// CHECK:STDOUT: return %.loc10_29.12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %struct_type.b.a.1b0) = "no_op"; diff --git a/toolchain/check/testdata/impl/import_builtin_call.carbon b/toolchain/check/testdata/impl/import_builtin_call.carbon index 7ed99c3f4122..0460722b749d 100644 --- a/toolchain/check/testdata/impl/import_builtin_call.carbon +++ b/toolchain/check/testdata/impl/import_builtin_call.carbon @@ -374,7 +374,7 @@ var n: Int(64) = MakeFromClass(FromLiteral(64) as OtherInt); // CHECK:STDOUT: %specific_impl_fn.loc20_11.1: = specific_impl_function %impl.elem0.loc20_11.1, @Add.Op(constants.%Add.facet.9ab) [symbolic = %specific_impl_fn.loc20_11.2 (constants.%specific_impl_fn)] // CHECK:STDOUT: %bound_method.loc20_22: = bound_method %x.ref.loc20_10, %specific_impl_fn.loc20_11.1 // CHECK:STDOUT: %Add.Op.call: init @Double.%MyInt.loc19_39.1 (%MyInt) = call %bound_method.loc20_22(%x.ref.loc20_10, %x.ref.loc20_21) -// CHECK:STDOUT: return %Add.Op.call to %return +// CHECK:STDOUT: return %Add.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -585,7 +585,7 @@ var n: Int(64) = MakeFromClass(FromLiteral(64) as OtherInt); // CHECK:STDOUT: %n.ref: %MyInt.f9e = name_ref n, %n // CHECK:STDOUT: %Double.specific_fn: = specific_function %Double.ref, @Double(constants.%int_64) [concrete = constants.%Double.specific_fn] // CHECK:STDOUT: %Double.call: init %MyInt.f9e = call %Double.specific_fn(%n.ref) -// CHECK:STDOUT: return %Double.call to %return +// CHECK:STDOUT: return %Double.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @Double(imports.%Main.import_ref.6b552a.2: Core.IntLiteral) [from "generic_impl.carbon"] { @@ -986,7 +986,7 @@ var n: Int(64) = MakeFromClass(FromLiteral(64) as OtherInt); // CHECK:STDOUT: %N.ref.loc9_57: %i32.builtin = name_ref N, %N.loc9_9.2 [symbolic = %N.loc9_9.1 (constants.%N.7e8)] // CHECK:STDOUT: %Make.specific_fn.loc9_52.1: = specific_function %Make.ref, @Make(constants.%N.7e8) [symbolic = %Make.specific_fn.loc9_52.2 (constants.%Make.specific_fn)] // CHECK:STDOUT: %Make.call: init @Make.%iN.builtin (%iN.builtin.b5d) = call %Make.specific_fn.loc9_52.1() -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1010,7 +1010,7 @@ var n: Int(64) = MakeFromClass(FromLiteral(64) as OtherInt); // CHECK:STDOUT: %N.ref.loc18_77: %OtherInt = name_ref N, %N.loc18_18.2 [symbolic = %N.loc18_18.1 (constants.%N.0f7)] // CHECK:STDOUT: %MakeFromClass.specific_fn.loc18_63.1: = specific_function %MakeFromClass.ref, @MakeFromClass(constants.%N.0f7) [symbolic = %MakeFromClass.specific_fn.loc18_63.2 (constants.%MakeFromClass.specific_fn)] // CHECK:STDOUT: %MakeFromClass.call: init @MakeFromClass.%iN.builtin (%iN.builtin.63a) = call %MakeFromClass.specific_fn.loc18_63.1() -// CHECK:STDOUT: return %MakeFromClass.call to %return +// CHECK:STDOUT: return %MakeFromClass.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/import_self.carbon b/toolchain/check/testdata/impl/import_self.carbon index b0e25481b2cc..399239752959 100644 --- a/toolchain/check/testdata/impl/import_self.carbon +++ b/toolchain/check/testdata/impl/import_self.carbon @@ -265,11 +265,11 @@ fn F(x: C, y: C) -> C { // CHECK:STDOUT: %.loc9_54.1: %C = as_compatible %empty_tuple [concrete = constants.%empty_tuple.bfb] // CHECK:STDOUT: %.loc9_54.2: %C = converted %.loc9_52, %.loc9_54.1 [concrete = constants.%empty_tuple.bfb] // CHECK:STDOUT: %.loc9_58.1: %empty_tuple.type = as_compatible %.loc9_54.2 [concrete = constants.%empty_tuple.af4] -// CHECK:STDOUT: %.loc9_58.2: ref %empty_tuple.type = as_compatible %return +// CHECK:STDOUT: %.loc9_58.2: ref %empty_tuple.type = as_compatible %return.param // CHECK:STDOUT: %.loc9_58.3: init %empty_tuple.type = tuple_init () to %.loc9_58.2 [concrete = constants.%empty_tuple.af4] // CHECK:STDOUT: %.loc9_58.4: init %C = as_compatible %.loc9_58.3 [concrete = constants.%empty_tuple.bfb] // CHECK:STDOUT: %.loc9_58.5: init %C = converted %.loc9_54.2, %.loc9_58.4 [concrete = constants.%empty_tuple.bfb] -// CHECK:STDOUT: return %.loc9_58.5 to %return +// CHECK:STDOUT: return %.loc9_58.5 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F(%x.param: %C, %y.param: %C) -> %C { @@ -281,7 +281,7 @@ fn F(x: C, y: C) -> C { // CHECK:STDOUT: %bound_method: = bound_method %x.ref, %impl.elem0 // CHECK:STDOUT: %y.ref: %C = name_ref y, %y // CHECK:STDOUT: %C.as.Add.impl.Op.call: init %C = call %bound_method(%x.ref, %y.ref) -// CHECK:STDOUT: return %C.as.Add.impl.Op.call to %return +// CHECK:STDOUT: return %C.as.Add.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Add.Op(constants.%Self) { diff --git a/toolchain/check/testdata/impl/interface_args.carbon b/toolchain/check/testdata/impl/interface_args.carbon index e3ead00b316b..0346c8a1a836 100644 --- a/toolchain/check/testdata/impl/interface_args.carbon +++ b/toolchain/check/testdata/impl/interface_args.carbon @@ -1177,7 +1177,7 @@ fn InstanceC(a: A) -> C { // CHECK:STDOUT: %return.param_patt: %pattern_type.1f4 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %B.ref.loc4: type = name_ref B, imports.%Main.B [concrete = constants.%B] -// CHECK:STDOUT: %.loc4_15: form = init_form %B.ref.loc4, call_param0 [concrete = constants.%.312] +// CHECK:STDOUT: %.loc4_15.2: form = init_form %B.ref.loc4, call_param0 [concrete = constants.%.312] // CHECK:STDOUT: %return.param: ref %B = out_param call_param0 // CHECK:STDOUT: %return: ref %B = return_slot %return.param // CHECK:STDOUT: } @@ -1188,7 +1188,7 @@ fn InstanceC(a: A) -> C { // CHECK:STDOUT: %return.param_patt: %pattern_type.1f4 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %B.ref.loc7: type = name_ref B, imports.%Main.B [concrete = constants.%B] -// CHECK:STDOUT: %.loc7_23: form = init_form %B.ref.loc7, call_param1 [concrete = constants.%.521] +// CHECK:STDOUT: %.loc7_23.2: form = init_form %B.ref.loc7, call_param1 [concrete = constants.%.521] // CHECK:STDOUT: %a.param: %A = value_param call_param0 // CHECK:STDOUT: %A.ref: type = name_ref A, imports.%Main.A [concrete = constants.%A] // CHECK:STDOUT: %a: %A = value_binding a, %a.param @@ -1274,9 +1274,9 @@ fn InstanceC(a: A) -> C { // CHECK:STDOUT: %Factory.facet: %Factory.type.5dd = facet_value %A.ref, (constants.%Factory.impl_witness) [concrete = constants.%Factory.facet] // CHECK:STDOUT: %.loc5_11: %Factory.type.5dd = converted %A.ref, %Factory.facet [concrete = constants.%Factory.facet] // CHECK:STDOUT: %impl.elem0: %.d31 = impl_witness_access constants.%Factory.impl_witness, element0 [concrete = constants.%A.as.Factory.impl.Make] -// CHECK:STDOUT: %.loc4_12: ref %B = splice_block %return {} -// CHECK:STDOUT: %A.as.Factory.impl.Make.call: init %B = call %impl.elem0() to %.loc4_12 -// CHECK:STDOUT: return %A.as.Factory.impl.Make.call to %return +// CHECK:STDOUT: %.loc4_15.1: ref %B = splice_block %return.param {} +// CHECK:STDOUT: %A.as.Factory.impl.Make.call: init %B = call %impl.elem0() to %.loc4_15.1 +// CHECK:STDOUT: return %A.as.Factory.impl.Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @A.as.Factory.impl.Make [from "factory.carbon"]; @@ -1291,9 +1291,9 @@ fn InstanceC(a: A) -> C { // CHECK:STDOUT: %Method.ref: %Factory.assoc_type.3bd = name_ref Method, %.loc8 [concrete = constants.%assoc1.be2] // CHECK:STDOUT: %impl.elem1: %.b77 = impl_witness_access constants.%Factory.impl_witness, element1 [concrete = constants.%A.as.Factory.impl.Method] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 -// CHECK:STDOUT: %.loc7_20: ref %B = splice_block %return {} -// CHECK:STDOUT: %A.as.Factory.impl.Method.call: init %B = call %bound_method(%a.ref) to %.loc7_20 -// CHECK:STDOUT: return %A.as.Factory.impl.Method.call to %return +// CHECK:STDOUT: %.loc7_23.1: ref %B = splice_block %return.param {} +// CHECK:STDOUT: %A.as.Factory.impl.Method.call: init %B = call %bound_method(%a.ref) to %.loc7_23.1 +// CHECK:STDOUT: return %A.as.Factory.impl.Method.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @A.as.Factory.impl.Method [from "factory.carbon"]; @@ -1545,7 +1545,7 @@ fn InstanceC(a: A) -> C { // CHECK:STDOUT: %Factory.type: type = facet_type <@Factory, @Factory(constants.%C)> [concrete = constants.%Factory.type.2db] // CHECK:STDOUT: %.loc13: %Factory.assoc_type.930 = specific_constant imports.%Main.import_ref.6f2, @Factory(constants.%C) [concrete = constants.%assoc0.4ac] // CHECK:STDOUT: %Make.ref: %Factory.assoc_type.930 = name_ref Make, %.loc13 [concrete = constants.%assoc0.4ac] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @InstanceC(%a.param: %A) -> %return.param: %C { @@ -1556,7 +1556,7 @@ fn InstanceC(a: A) -> C { // CHECK:STDOUT: %Factory.type: type = facet_type <@Factory, @Factory(constants.%C)> [concrete = constants.%Factory.type.2db] // CHECK:STDOUT: %.loc21: %Factory.assoc_type.930 = specific_constant imports.%Main.import_ref.fb1, @Factory(constants.%C) [concrete = constants.%assoc1.09b] // CHECK:STDOUT: %Method.ref: %Factory.assoc_type.930 = name_ref Method, %.loc21 [concrete = constants.%assoc1.09b] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Factory(constants.%T) { diff --git a/toolchain/check/testdata/impl/lookup/generic.carbon b/toolchain/check/testdata/impl/lookup/generic.carbon index 773257c45adc..f8d053e463b5 100644 --- a/toolchain/check/testdata/impl/lookup/generic.carbon +++ b/toolchain/check/testdata/impl/lookup/generic.carbon @@ -532,7 +532,7 @@ fn G(x: A) { // CHECK:STDOUT: %specific_impl_fn.loc9_37.1: = specific_impl_function %impl.elem0.loc9_37.1, @Copy.Op(constants.%Copy.facet.c25) [symbolic = %specific_impl_fn.loc9_37.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc9_37.2: = bound_method %self.ref, %specific_impl_fn.loc9_37.1 // CHECK:STDOUT: %Copy.Op.call: init @ptr.as.HasF.impl.F.%ptr.loc9_14 (%ptr.e8f) = call %bound_method.loc9_37.2(%self.ref) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -546,7 +546,7 @@ fn G(x: A) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.HasF.impl.F(constants.%empty_struct_type) [concrete = constants.%ptr.as.HasF.impl.F.specific_fn] // CHECK:STDOUT: %bound_method.loc13_21: = bound_method %x.ref, %specific_fn // CHECK:STDOUT: %ptr.as.HasF.impl.F.call: init %ptr.c28 = call %bound_method.loc13_21(%x.ref) -// CHECK:STDOUT: return %ptr.as.HasF.impl.F.call to %return +// CHECK:STDOUT: return %ptr.as.HasF.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @HasF.F(constants.%Self.f09) { diff --git a/toolchain/check/testdata/impl/lookup/impl_forall.carbon b/toolchain/check/testdata/impl/lookup/impl_forall.carbon index 945759809c5b..d8a091203a7c 100644 --- a/toolchain/check/testdata/impl/lookup/impl_forall.carbon +++ b/toolchain/check/testdata/impl/lookup/impl_forall.carbon @@ -215,7 +215,7 @@ fn TestSpecific(a: A({})*) -> {}* { // CHECK:STDOUT: %specific_impl_fn.loc14_12.1: = specific_impl_function %impl.elem0.loc14_12.1, @Copy.Op(constants.%Copy.facet.c25) [symbolic = %specific_impl_fn.loc14_12.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc14_12.2: = bound_method %addr, %specific_impl_fn.loc14_12.1 // CHECK:STDOUT: %Copy.Op.call: init @A.as.I.impl.F.%ptr.loc13_30.1 (%ptr.e8f8f9.2) = call %bound_method.loc14_12.2(%addr) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -251,7 +251,7 @@ fn TestSpecific(a: A({})*) -> {}* { // CHECK:STDOUT: %specific_impl_fn.loc21_11.1: = specific_impl_function %impl.elem0.loc21_11.1, @I.F(constants.%W, constants.%I.facet.558) [symbolic = %specific_impl_fn.loc21_11.2 (constants.%specific_impl_fn.898)] // CHECK:STDOUT: %bound_method.loc21_22: = bound_method %.loc21_11.1, %specific_impl_fn.loc21_11.1 // CHECK:STDOUT: %I.F.call: init @TestGeneric.%ptr.loc19_40.1 (%ptr.e8f8f9.4) = call %bound_method.loc21_22(%.loc21_11.1) -// CHECK:STDOUT: return %I.F.call to %return +// CHECK:STDOUT: return %I.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -270,7 +270,7 @@ fn TestSpecific(a: A({})*) -> {}* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @A.as.I.impl.F(constants.%empty_struct_type) [concrete = constants.%A.as.I.impl.F.specific_fn] // CHECK:STDOUT: %bound_method.loc27_23: = bound_method %.loc27_11, %specific_fn // CHECK:STDOUT: %A.as.I.impl.F.call: init %ptr.c28 = call %bound_method.loc27_23(%.loc27_11) -// CHECK:STDOUT: return %A.as.I.impl.F.call to %return +// CHECK:STDOUT: return %A.as.I.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @A.as.I.impl(constants.%V.67d) { diff --git a/toolchain/check/testdata/impl/lookup/instance_method.carbon b/toolchain/check/testdata/impl/lookup/instance_method.carbon index 0d8ca6913e5a..d0acbd0eb2c1 100644 --- a/toolchain/check/testdata/impl/lookup/instance_method.carbon +++ b/toolchain/check/testdata/impl/lookup/instance_method.carbon @@ -182,7 +182,7 @@ fn F(c: C) -> i32 { // CHECK:STDOUT: %impl.elem0: %.7a3 = impl_witness_access constants.%I.impl_witness, element0 [concrete = constants.%C.as.I.impl.F] // CHECK:STDOUT: %bound_method: = bound_method %c.ref, %impl.elem0 // CHECK:STDOUT: %C.as.I.impl.F.call: init %i32 = call %bound_method(%c.ref) -// CHECK:STDOUT: return %C.as.I.impl.F.call to %return +// CHECK:STDOUT: return %C.as.I.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @I.F(constants.%Self) { diff --git a/toolchain/check/testdata/impl/lookup/specialization_with_symbolic_rewrite.carbon b/toolchain/check/testdata/impl/lookup/specialization_with_symbolic_rewrite.carbon index 3e7266b539ce..3a4466d240b2 100644 --- a/toolchain/check/testdata/impl/lookup/specialization_with_symbolic_rewrite.carbon +++ b/toolchain/check/testdata/impl/lookup/specialization_with_symbolic_rewrite.carbon @@ -946,7 +946,7 @@ fn F[T:! Ptr](var t: T) -> T.(Ptr.Type) { // CHECK:STDOUT: %specific_impl_fn.loc10_10.1: = specific_impl_function %impl.elem0.loc10_10.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc10_10.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc10_10.2: = bound_method %addr, %specific_impl_fn.loc10_10.1 // CHECK:STDOUT: %Copy.Op.call: init @F.%ptr (%ptr.e8f8f9.2) = call %bound_method.loc10_10.2(%addr) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1162,7 +1162,7 @@ fn F[T:! Ptr](var t: T) -> T.(Ptr.Type) { // CHECK:STDOUT: %specific_impl_fn.loc10_10.1: = specific_impl_function %impl.elem0.loc10_10.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc10_10.2 (constants.%specific_impl_fn.4b3)] // CHECK:STDOUT: %bound_method.loc10_10.2: = bound_method %addr, %specific_impl_fn.loc10_10.1 // CHECK:STDOUT: %Copy.Op.call: init @F.%ptr (%ptr.a86) = call %bound_method.loc10_10.2(%addr) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1377,7 +1377,7 @@ fn F[T:! Ptr](var t: T) -> T.(Ptr.Type) { // CHECK:STDOUT: %specific_impl_fn.loc10_10.1: = specific_impl_function %impl.elem0.loc10_10.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc10_10.2 (constants.%specific_impl_fn.4b3)] // CHECK:STDOUT: %bound_method.loc10_10.2: = bound_method %addr, %specific_impl_fn.loc10_10.1 // CHECK:STDOUT: %Copy.Op.call: init @F.%ptr (%ptr.a86) = call %bound_method.loc10_10.2(%addr) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/self_in_class.carbon b/toolchain/check/testdata/impl/self_in_class.carbon index 4ca735f68d14..3c152b6ea4c5 100644 --- a/toolchain/check/testdata/impl/self_in_class.carbon +++ b/toolchain/check/testdata/impl/self_in_class.carbon @@ -138,9 +138,9 @@ class A { // CHECK:STDOUT: fn @C.as.DefaultConstructible.impl.Make() -> %return.param: %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc25_33.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc25_33.2: init %C = class_init (), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc25_33.2: init %C = class_init (), %return.param [concrete = constants.%C.val] // CHECK:STDOUT: %.loc25_34: init %C = converted %.loc25_33.1, %.loc25_33.2 [concrete = constants.%C.val] -// CHECK:STDOUT: return %.loc25_34 to %return +// CHECK:STDOUT: return %.loc25_34 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @DefaultConstructible.Make(constants.%Self) { diff --git a/toolchain/check/testdata/impl/self_in_signature.carbon b/toolchain/check/testdata/impl/self_in_signature.carbon index 221e56e6c11a..64260a86474d 100644 --- a/toolchain/check/testdata/impl/self_in_signature.carbon +++ b/toolchain/check/testdata/impl/self_in_signature.carbon @@ -347,17 +347,17 @@ impl D as SelfNested { // CHECK:STDOUT: fn @C.as.UseSelf.impl.F(%self.param: %C, %x.param: %C) -> %return.param: %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc24_38.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc24_38.2: init %C = class_init (), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc24_38.2: init %C = class_init (), %return.param [concrete = constants.%C.val] // CHECK:STDOUT: %.loc24_39: init %C = converted %.loc24_38.1, %.loc24_38.2 [concrete = constants.%C.val] -// CHECK:STDOUT: return %.loc24_39 to %return +// CHECK:STDOUT: return %.loc24_39 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @D.as.UseSelf.impl.F(%self.param: %D, %x.param: %D) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc28_47.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc28_47.2: init %D = class_init (), %return [concrete = constants.%D.val] +// CHECK:STDOUT: %.loc28_47.2: init %D = class_init (), %return.param [concrete = constants.%D.val] // CHECK:STDOUT: %.loc28_48: init %D = converted %.loc28_47.1, %.loc28_47.2 [concrete = constants.%D.val] -// CHECK:STDOUT: return %.loc28_48 to %return +// CHECK:STDOUT: return %.loc28_48 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @SelfNested.F(@SelfNested.%Self: %SelfNested.type) { diff --git a/toolchain/check/testdata/impl/use_assoc_entity.carbon b/toolchain/check/testdata/impl/use_assoc_entity.carbon index 0052c8cdd90e..3df36b8ecdf0 100644 --- a/toolchain/check/testdata/impl/use_assoc_entity.carbon +++ b/toolchain/check/testdata/impl/use_assoc_entity.carbon @@ -647,7 +647,7 @@ fn F() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem1, @Int.as.Negate.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Negate.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc9_44.2: = bound_method %u.ref, %specific_fn // CHECK:STDOUT: %Int.as.Negate.impl.Op.call: init %i32 = call %bound_method.loc9_44.2(%u.ref) -// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallMethod(%x.param: %empty_tuple.type) -> %i32 { @@ -666,18 +666,18 @@ fn F() { // CHECK:STDOUT: %.loc13_18.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_40.518] // CHECK:STDOUT: %.loc13_18.2: %i32 = converted %int_40, %.loc13_18.1 [concrete = constants.%int_40.518] // CHECK:STDOUT: %empty_tuple.type.as.J.impl.F.call: init %i32 = call %bound_method.loc13_11(%x.ref, %.loc13_18.2) -// CHECK:STDOUT: return %empty_tuple.type.as.J.impl.F.call to %return +// CHECK:STDOUT: return %empty_tuple.type.as.J.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.J.impl.F(%self.param: %C, %u.param: %C) -> %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %self.ref: %C = name_ref self, %self // CHECK:STDOUT: %.loc22_44.1: %empty_struct_type = as_compatible %self.ref -// CHECK:STDOUT: %.loc22_44.2: ref %empty_struct_type = as_compatible %return +// CHECK:STDOUT: %.loc22_44.2: ref %empty_struct_type = as_compatible %return.param // CHECK:STDOUT: %.loc22_44.3: init %empty_struct_type = struct_init () to %.loc22_44.2 [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc22_44.4: init %C = as_compatible %.loc22_44.3 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc22_44.5: init %C = converted %self.ref, %.loc22_44.4 [concrete = constants.%C.val] -// CHECK:STDOUT: return %.loc22_44.5 to %return +// CHECK:STDOUT: return %.loc22_44.5 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @U(constants.%Self.8a1) {} @@ -928,7 +928,7 @@ fn F() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem1, @Int.as.Negate.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Negate.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc11_32.2: = bound_method %u.ref, %specific_fn // CHECK:STDOUT: %Int.as.Negate.impl.Op.call: init %i32 = call %bound_method.loc11_32.2(%u.ref) -// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallFunction() -> %i32 { @@ -948,7 +948,7 @@ fn F() { // CHECK:STDOUT: %.loc15_18.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_4.940] // CHECK:STDOUT: %.loc15_18.2: %i32 = converted %int_4, %.loc15_18.1 [concrete = constants.%int_4.940] // CHECK:STDOUT: %D.as.J.impl.F.call: init %i32 = call %impl.elem1(%.loc15_18.2) -// CHECK:STDOUT: return %D.as.J.impl.F.call to %return +// CHECK:STDOUT: return %D.as.J.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @U(constants.%Self.8a1) {} @@ -1136,9 +1136,9 @@ fn F() { // CHECK:STDOUT: %T.ref.loc28_41: %J.type = name_ref T, %T.loc28_17.2 [symbolic = %T.loc28_17.1 (constants.%T)] // CHECK:STDOUT: %U.ref.loc28_42: %J.assoc_type = name_ref U, @U.%assoc0 [concrete = constants.%assoc0.d5c] // CHECK:STDOUT: %T.as_type.loc28_42: type = facet_access_type %T.ref.loc28_41 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc28_42.2: type = converted %T.ref.loc28_41, %T.as_type.loc28_42 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc28_42.3: type = converted %T.ref.loc28_41, %T.as_type.loc28_42 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %impl.elem0.loc28_42: type = impl_witness_access constants.%J.lookup_impl_witness.264, element0 [symbolic = %impl.elem0.loc28_34.1 (constants.%impl.elem0.560)] -// CHECK:STDOUT: %.loc28_42.3: form = init_form %impl.elem0.loc28_42, call_param2 [symbolic = %.loc28_42.1 (constants.%.722)] +// CHECK:STDOUT: %.loc28_42.4: form = init_form %impl.elem0.loc28_42, call_param2 [symbolic = %.loc28_42.2 (constants.%.722)] // CHECK:STDOUT: %.loc28_21: type = splice_block %J.ref [concrete = constants.%J.type] { // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self.c39] // CHECK:STDOUT: %J.ref: type = name_ref J, file.%J.decl [concrete = constants.%J.type] @@ -1357,7 +1357,7 @@ fn F() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem1, @Int.as.Negate.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Negate.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc12_14.2: = bound_method %u.ref, %specific_fn // CHECK:STDOUT: %Int.as.Negate.impl.Op.call: init %i32 = call %bound_method.loc12_14.2(%u.ref) -// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @E.as.J.impl.G(%self.param: %E, %v.param: %i32) -> %i32 { @@ -1368,7 +1368,7 @@ fn F() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem1, @Int.as.Negate.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Negate.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc15_14.2: = bound_method %v.ref, %specific_fn // CHECK:STDOUT: %Int.as.Negate.impl.Op.call: init %i32 = call %bound_method.loc15_14.2(%v.ref) -// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Negate.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CallBoth(%e.param: %E) { @@ -1498,7 +1498,7 @@ fn F() { // CHECK:STDOUT: %J.lookup_impl_witness: = lookup_impl_witness %T.loc28_17.1, @J [symbolic = %J.lookup_impl_witness (constants.%J.lookup_impl_witness.264)] // CHECK:STDOUT: %impl.elem0.loc28_34.1: type = impl_witness_access %J.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc28_34.1 (constants.%impl.elem0.560)] // CHECK:STDOUT: %pattern_type.loc28_30: type = pattern_type %impl.elem0.loc28_34.1 [symbolic = %pattern_type.loc28_30 (constants.%pattern_type.ad6)] -// CHECK:STDOUT: %.loc28_42.1: form = init_form %impl.elem0.loc28_34.1, call_param2 [symbolic = %.loc28_42.1 (constants.%.722)] +// CHECK:STDOUT: %.loc28_42.2: form = init_form %impl.elem0.loc28_34.1, call_param2 [symbolic = %.loc28_42.2 (constants.%.722)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete.loc28_42: = require_complete_type %impl.elem0.loc28_34.1 [symbolic = %require_complete.loc28_42 (constants.%require_complete.06a)] @@ -1514,9 +1514,9 @@ fn F() { // CHECK:STDOUT: %impl.elem1.loc29_11.1: @GenericCallF.%.loc29 (%.322) = impl_witness_access constants.%J.lookup_impl_witness.264, element1 [symbolic = %impl.elem1.loc29_11.2 (constants.%impl.elem1)] // CHECK:STDOUT: %u.ref: @GenericCallF.%impl.elem0.loc28_34.1 (%impl.elem0.560) = name_ref u, %u // CHECK:STDOUT: %specific_impl_fn.loc29_11.1: = specific_impl_function %impl.elem1.loc29_11.1, @J.F(constants.%T) [symbolic = %specific_impl_fn.loc29_11.2 (constants.%specific_impl_fn)] -// CHECK:STDOUT: %.loc28_38: ref @GenericCallF.%impl.elem0.loc28_34.1 (%impl.elem0.560) = splice_block %return {} -// CHECK:STDOUT: %J.F.call: init @GenericCallF.%impl.elem0.loc28_34.1 (%impl.elem0.560) = call %specific_impl_fn.loc29_11.1(%u.ref) to %.loc28_38 -// CHECK:STDOUT: return %J.F.call to %return +// CHECK:STDOUT: %.loc28_42.1: ref @GenericCallF.%impl.elem0.loc28_34.1 (%impl.elem0.560) = splice_block %return.param {} +// CHECK:STDOUT: %J.F.call: init @GenericCallF.%impl.elem0.loc28_34.1 (%impl.elem0.560) = call %specific_impl_fn.loc29_11.1(%u.ref) to %.loc28_42.1 +// CHECK:STDOUT: return %J.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1538,7 +1538,7 @@ fn F() { // CHECK:STDOUT: %.loc33_26.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc33_26.2: %i32 = converted %int_2, %.loc33_26.1 [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %GenericCallF.call: init %i32 = call %GenericCallF.specific_fn(%e.ref, %.loc33_26.2) -// CHECK:STDOUT: return %GenericCallF.call to %return +// CHECK:STDOUT: return %GenericCallF.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @U(constants.%Self.8a1) {} @@ -1590,7 +1590,7 @@ fn F() { // CHECK:STDOUT: %J.lookup_impl_witness => constants.%J.lookup_impl_witness.264 // CHECK:STDOUT: %impl.elem0.loc28_34.1 => constants.%impl.elem0.560 // CHECK:STDOUT: %pattern_type.loc28_30 => constants.%pattern_type.ad6 -// CHECK:STDOUT: %.loc28_42.1 => constants.%.722 +// CHECK:STDOUT: %.loc28_42.2 => constants.%.722 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @J.F(constants.%T) { @@ -1608,7 +1608,7 @@ fn F() { // CHECK:STDOUT: %J.lookup_impl_witness => constants.%J.impl_witness // CHECK:STDOUT: %impl.elem0.loc28_34.1 => constants.%i32 // CHECK:STDOUT: %pattern_type.loc28_30 => constants.%pattern_type.7ce -// CHECK:STDOUT: %.loc28_42.1 => constants.%.88a +// CHECK:STDOUT: %.loc28_42.2 => constants.%.88a // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete.loc28_42 => constants.%complete_type.f8a @@ -1712,11 +1712,11 @@ fn F() { // CHECK:STDOUT: %T.ref.loc12_42: %J.type = name_ref T, %T.loc12_18.2 [symbolic = %T.loc12_18.1 (constants.%T)] // CHECK:STDOUT: %U.ref.loc12_43: %J.assoc_type = name_ref U, @U.%assoc0 [concrete = constants.%assoc0.918] // CHECK:STDOUT: %T.as_type.loc12_43: type = facet_access_type %T.ref.loc12_42 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc12_43.2: type = converted %T.ref.loc12_42, %T.as_type.loc12_43 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc12_43.3: type = converted %T.ref.loc12_42, %T.as_type.loc12_43 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %impl.elem0.loc12_43: %facet_type = impl_witness_access constants.%J.lookup_impl_witness.264, element0 [symbolic = %impl.elem0.loc12_35.1 (constants.%impl.elem0.397)] // CHECK:STDOUT: %as_type.loc12_43: type = facet_access_type %impl.elem0.loc12_43 [symbolic = %as_type.loc12_35.1 (constants.%as_type.baf)] -// CHECK:STDOUT: %.loc12_43.3: type = converted %impl.elem0.loc12_43, %as_type.loc12_43 [symbolic = %as_type.loc12_35.1 (constants.%as_type.baf)] -// CHECK:STDOUT: %.loc12_43.4: form = init_form %.loc12_43.3, call_param2 [symbolic = %.loc12_43.1 (constants.%.997)] +// CHECK:STDOUT: %.loc12_43.4: type = converted %impl.elem0.loc12_43, %as_type.loc12_43 [symbolic = %as_type.loc12_35.1 (constants.%as_type.baf)] +// CHECK:STDOUT: %.loc12_43.5: form = init_form %.loc12_43.4, call_param2 [symbolic = %.loc12_43.2 (constants.%.997)] // CHECK:STDOUT: %.loc12_22: type = splice_block %J.ref [concrete = constants.%J.type] { // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %J.ref: type = name_ref J, file.%J.decl [concrete = constants.%J.type] @@ -1857,7 +1857,7 @@ fn F() { // CHECK:STDOUT: %impl.elem0.loc12_35.1: %facet_type = impl_witness_access %J.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc12_35.1 (constants.%impl.elem0.397)] // CHECK:STDOUT: %as_type.loc12_35.1: type = facet_access_type %impl.elem0.loc12_35.1 [symbolic = %as_type.loc12_35.1 (constants.%as_type.baf)] // CHECK:STDOUT: %pattern_type.loc12_31: type = pattern_type %as_type.loc12_35.1 [symbolic = %pattern_type.loc12_31 (constants.%pattern_type.bba)] -// CHECK:STDOUT: %.loc12_43.1: form = init_form %as_type.loc12_35.1, call_param2 [symbolic = %.loc12_43.1 (constants.%.997)] +// CHECK:STDOUT: %.loc12_43.2: form = init_form %as_type.loc12_35.1, call_param2 [symbolic = %.loc12_43.2 (constants.%.997)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete.loc12_43: = require_complete_type %as_type.loc12_35.1 [symbolic = %require_complete.loc12_43 (constants.%require_complete.9b3)] @@ -1905,18 +1905,18 @@ fn F() { // CHECK:STDOUT: %.loc13_30.2: %I.type = converted constants.%as_type.baf, %I.facet.loc13_30.2 [symbolic = %I.facet.loc13_16 (constants.%I.facet)] // CHECK:STDOUT: %specific_impl_fn.loc13_16.1: = specific_impl_function %impl.elem0.loc13_16.1, @I.Op(constants.%I.facet) [symbolic = %specific_impl_fn.loc13_16.2 (constants.%specific_impl_fn.dcb)] // CHECK:STDOUT: %bound_method.loc13_30: = bound_method %J.F.call.loc13_15, %specific_impl_fn.loc13_16.1 -// CHECK:STDOUT: %.loc12_39: ref @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = splice_block %return {} +// CHECK:STDOUT: %.loc12_43.1: ref @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = splice_block %return.param {} // CHECK:STDOUT: %.loc13_15.4: ref @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = temporary %.loc13_15.3, %J.F.call.loc13_15 // CHECK:STDOUT: %.loc13_15.5: @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = acquire_value %.loc13_15.4 // CHECK:STDOUT: %.loc13_29.4: ref @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = temporary %.loc13_29.3, %J.F.call.loc13_29 // CHECK:STDOUT: %.loc13_29.5: @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = acquire_value %.loc13_29.4 -// CHECK:STDOUT: %I.Op.call: init @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = call %bound_method.loc13_30(%.loc13_15.5, %.loc13_29.5) to %.loc12_39 +// CHECK:STDOUT: %I.Op.call: init @GenericResult.%as_type.loc12_35.1 (%as_type.baf) = call %bound_method.loc13_30(%.loc13_15.5, %.loc13_29.5) to %.loc12_43.1 // CHECK:STDOUT: %as_type.loc13: type = facet_access_type constants.%impl.elem0.397 [symbolic = %as_type.loc12_35.1 (constants.%as_type.baf)] // CHECK:STDOUT: %DestroyOp.bound.loc13_29: = bound_method %.loc13_29.4, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc13_29: init %empty_tuple.type = call %DestroyOp.bound.loc13_29(%.loc13_29.4) // CHECK:STDOUT: %DestroyOp.bound.loc13_15: = bound_method %.loc13_15.4, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc13_15: init %empty_tuple.type = call %DestroyOp.bound.loc13_15(%.loc13_15.4) -// CHECK:STDOUT: return %I.Op.call to %return +// CHECK:STDOUT: return %I.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1950,7 +1950,7 @@ fn F() { // CHECK:STDOUT: %impl.elem0.loc12_35.1 => constants.%impl.elem0.397 // CHECK:STDOUT: %as_type.loc12_35.1 => constants.%as_type.baf // CHECK:STDOUT: %pattern_type.loc12_31 => constants.%pattern_type.bba -// CHECK:STDOUT: %.loc12_43.1 => constants.%.997 +// CHECK:STDOUT: %.loc12_43.2 => constants.%.997 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @J.F(constants.%T) { @@ -2031,9 +2031,9 @@ fn F() { // CHECK:STDOUT: %T.ref.loc8_58: %J.type = name_ref T, %T.loc8_34.2 [symbolic = %T.loc8_34.1 (constants.%T)] // CHECK:STDOUT: %U.ref.loc8_59: %J.assoc_type = name_ref U, @U.%assoc0 [concrete = constants.%assoc0] // CHECK:STDOUT: %T.as_type.loc8_59: type = facet_access_type %T.ref.loc8_58 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] -// CHECK:STDOUT: %.loc8_59.2: type = converted %T.ref.loc8_58, %T.as_type.loc8_59 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] +// CHECK:STDOUT: %.loc8_59.3: type = converted %T.ref.loc8_58, %T.as_type.loc8_59 [symbolic = %T.binding.as_type (constants.%T.binding.as_type)] // CHECK:STDOUT: %impl.elem0.loc8_59: type = impl_witness_access constants.%J.lookup_impl_witness.264, element0 [symbolic = %impl.elem0.loc8_51.1 (constants.%impl.elem0.560)] -// CHECK:STDOUT: %.loc8_59.3: form = init_form %impl.elem0.loc8_59, call_param2 [symbolic = %.loc8_59.1 (constants.%.722)] +// CHECK:STDOUT: %.loc8_59.4: form = init_form %impl.elem0.loc8_59, call_param2 [symbolic = %.loc8_59.2 (constants.%.722)] // CHECK:STDOUT: %.loc8_38: type = splice_block %J.ref.loc8 [concrete = constants.%J.type] { // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %J.ref.loc8: type = name_ref J, file.%J.decl [concrete = constants.%J.type] @@ -2126,7 +2126,7 @@ fn F() { // CHECK:STDOUT: %J.lookup_impl_witness: = lookup_impl_witness %T.loc8_34.1, @J [symbolic = %J.lookup_impl_witness (constants.%J.lookup_impl_witness.264)] // CHECK:STDOUT: %impl.elem0.loc8_51.1: type = impl_witness_access %J.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc8_51.1 (constants.%impl.elem0.560)] // CHECK:STDOUT: %pattern_type.loc8_47: type = pattern_type %impl.elem0.loc8_51.1 [symbolic = %pattern_type.loc8_47 (constants.%pattern_type.ad6)] -// CHECK:STDOUT: %.loc8_59.1: form = init_form %impl.elem0.loc8_51.1, call_param2 [symbolic = %.loc8_59.1 (constants.%.722)] +// CHECK:STDOUT: %.loc8_59.2: form = init_form %impl.elem0.loc8_51.1, call_param2 [symbolic = %.loc8_59.2 (constants.%.722)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %require_complete.loc8_59: = require_complete_type %impl.elem0.loc8_51.1 [symbolic = %require_complete.loc8_59 (constants.%require_complete.06a)] @@ -2145,9 +2145,9 @@ fn F() { // CHECK:STDOUT: %u.ref: @GenericCallInterfaceQualified.%impl.elem0.loc8_51.1 (%impl.elem0.560) = name_ref u, %u // CHECK:STDOUT: %specific_impl_fn.loc9_11.1: = specific_impl_function %impl.elem1.loc9_11.1, @J.G(constants.%T) [symbolic = %specific_impl_fn.loc9_11.2 (constants.%specific_impl_fn)] // CHECK:STDOUT: %bound_method.loc9_19: = bound_method %t.ref, %specific_impl_fn.loc9_11.1 -// CHECK:STDOUT: %.loc8_55: ref @GenericCallInterfaceQualified.%impl.elem0.loc8_51.1 (%impl.elem0.560) = splice_block %return {} -// CHECK:STDOUT: %J.G.call: init @GenericCallInterfaceQualified.%impl.elem0.loc8_51.1 (%impl.elem0.560) = call %bound_method.loc9_19(%t.ref, %u.ref) to %.loc8_55 -// CHECK:STDOUT: return %J.G.call to %return +// CHECK:STDOUT: %.loc8_59.1: ref @GenericCallInterfaceQualified.%impl.elem0.loc8_51.1 (%impl.elem0.560) = splice_block %return.param {} +// CHECK:STDOUT: %J.G.call: init @GenericCallInterfaceQualified.%impl.elem0.loc8_51.1 (%impl.elem0.560) = call %bound_method.loc9_19(%t.ref, %u.ref) to %.loc8_59.1 +// CHECK:STDOUT: return %J.G.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2172,7 +2172,7 @@ fn F() { // CHECK:STDOUT: %J.lookup_impl_witness => constants.%J.lookup_impl_witness.264 // CHECK:STDOUT: %impl.elem0.loc8_51.1 => constants.%impl.elem0.560 // CHECK:STDOUT: %pattern_type.loc8_47 => constants.%pattern_type.ad6 -// CHECK:STDOUT: %.loc8_59.1 => constants.%.722 +// CHECK:STDOUT: %.loc8_59.2 => constants.%.722 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @J.G(constants.%T) { @@ -2379,7 +2379,7 @@ fn F() { // CHECK:STDOUT: %.loc9_14.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc9_14.2: %i32 = converted %int_2, %.loc9_14.1 [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %J.F.call: init %i32 = call %specific_impl_fn.loc9_11.1(%.loc9_14.2) -// CHECK:STDOUT: return %J.F.call to %return +// CHECK:STDOUT: return %J.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2593,7 +2593,7 @@ fn F() { // CHECK:STDOUT: %u.ref: %i32 = name_ref u, %u.param // CHECK:STDOUT: %return.ref: ref %i32 = name_ref , %return.param // CHECK:STDOUT: %E.as.J.impl.F.call: = call %F.ref() -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @U(constants.%Self.8a1) {} @@ -3220,9 +3220,9 @@ fn F() { // CHECK:STDOUT: fn @empty_tuple.type.as.J2.impl.F.loc23_33.1(%self.param: %empty_tuple.type, %z.param: %empty_struct_type) -> %empty_struct_type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %z.ref: %empty_struct_type = name_ref z, %z -// CHECK:STDOUT: %.loc23_42: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc23_42: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc23_43: init %empty_struct_type = converted %z.ref, %.loc23_42 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc23_43 to %return +// CHECK:STDOUT: return %.loc23_43 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @empty_tuple.type.as.J2.impl.F.loc23_33.2(%self.param: %empty_tuple.type, %.param: ) [thunk @empty_tuple.type.as.J2.impl.%empty_tuple.type.as.J2.impl.F.decl.loc23_33.1] { @@ -3239,11 +3239,11 @@ fn F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %self.ref: %C2 = name_ref self, %self // CHECK:STDOUT: %.loc32_46.1: %empty_struct_type = as_compatible %self.ref -// CHECK:STDOUT: %.loc32_46.2: ref %empty_struct_type = as_compatible %return +// CHECK:STDOUT: %.loc32_46.2: ref %empty_struct_type = as_compatible %return.param // CHECK:STDOUT: %.loc32_46.3: init %empty_struct_type = struct_init () to %.loc32_46.2 [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc32_46.4: init %C2 = as_compatible %.loc32_46.3 [concrete = constants.%C2.val] // CHECK:STDOUT: %.loc32_46.5: init %C2 = converted %self.ref, %.loc32_46.4 [concrete = constants.%C2.val] -// CHECK:STDOUT: return %.loc32_46.5 to %return +// CHECK:STDOUT: return %.loc32_46.5 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C2.as.J2.impl.F.loc32_33.2(%self.param: %C2, %.param: ) [thunk @C2.as.J2.impl.%C2.as.J2.impl.F.decl.loc32_33.1] { @@ -3471,12 +3471,12 @@ fn F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %v.ref: %struct_type.x = name_ref v, %v // CHECK:STDOUT: %.loc26_54.1: %empty_tuple.type = struct_access %v.ref, element0 -// CHECK:STDOUT: %.loc26_54.2: ref %empty_tuple.type = struct_access %return, element0 +// CHECK:STDOUT: %.loc26_54.2: ref %empty_tuple.type = struct_access %return.param, element0 // CHECK:STDOUT: %.loc26_54.3: init %empty_tuple.type = tuple_init () to %.loc26_54.2 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc26_54.4: init %empty_tuple.type = converted %.loc26_54.1, %.loc26_54.3 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc26_54.5: init %struct_type.x = struct_init (%.loc26_54.4) to %return [concrete = constants.%struct] +// CHECK:STDOUT: %.loc26_54.5: init %struct_type.x = struct_init (%.loc26_54.4) to %return.param [concrete = constants.%struct] // CHECK:STDOUT: %.loc26_55: init %struct_type.x = converted %v.ref, %.loc26_54.5 [concrete = constants.%struct] -// CHECK:STDOUT: return %.loc26_55 to %return +// CHECK:STDOUT: return %.loc26_55 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @empty_tuple.type.as.K.impl.F.loc26_45.2(%self.param: %empty_tuple.type, %v.param: %struct_type.a) -> %struct_type.a [thunk @empty_tuple.type.as.K.impl.%empty_tuple.type.as.K.impl.F.decl.loc26_45.1] { @@ -3491,7 +3491,7 @@ fn F() { // CHECK:STDOUT: %.loc26_45.2: ref %struct_type.x = temporary %.loc26_45.1, %empty_tuple.type.as.K.impl.F.call // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc26_45.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc26_45.2) -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %struct_type.x) = "no_op"; @@ -3652,9 +3652,9 @@ fn F() { // CHECK:STDOUT: %.loc10_23: type = converted %.loc10_18, %as_type [concrete = constants.%empty_tuple.type] // CHECK:STDOUT: %impl.elem0: %struct_type.b.347 = impl_witness_access constants.%M.impl_witness, element0 [concrete = constants.%struct] // CHECK:STDOUT: %.loc10_25.1: %empty_struct_type = struct_access %impl.elem0, element0 [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc10_25.2: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc10_25.2: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc10_27: init %empty_struct_type = converted %.loc10_25.1, %.loc10_25.2 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc10_27 to %return +// CHECK:STDOUT: return %.loc10_27 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Z(constants.%Self) {} @@ -3893,7 +3893,7 @@ fn F() { // CHECK:STDOUT: %impl.elem0.loc12_25: %.436 = impl_witness_access constants.%Copy.impl_witness.b47, element0 [concrete = constants.%type.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc12_25, %impl.elem0.loc12_25 [concrete = constants.%type.as.Copy.impl.Op.bound.bca] // CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method(%.loc12_25) [concrete = constants.%empty_struct_type] -// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.M.impl.G.loc17() -> type { @@ -3910,7 +3910,7 @@ fn F() { // CHECK:STDOUT: %impl.elem0.loc18_25: %.436 = impl_witness_access constants.%Copy.impl_witness.b47, element0 [concrete = constants.%type.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc18_25, %impl.elem0.loc18_25 [concrete = constants.%type.as.Copy.impl.Op.bound.f05] // CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method(%.loc18_25) [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%T.67d) { @@ -4184,17 +4184,17 @@ fn F() { // CHECK:STDOUT: %bound_method.loc9_50: = bound_method %true, %impl.elem0.loc9_50 [concrete = constants.%bool.as.Copy.impl.Op.bound.12b] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc9_50: init bool = call %bound_method.loc9_50(%true) [concrete = constants.%true] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] -// CHECK:STDOUT: %.loc9_61.2: ref bool = array_index %return, %int_0 +// CHECK:STDOUT: %.loc9_61.2: ref bool = array_index %return.param, %int_0 // CHECK:STDOUT: %.loc9_61.3: init bool = initialize_from %bool.as.Copy.impl.Op.call.loc9_50 to %.loc9_61.2 [concrete = constants.%true] // CHECK:STDOUT: %impl.elem0.loc9_56: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method.loc9_56: = bound_method %false, %impl.elem0.loc9_56 [concrete = constants.%bool.as.Copy.impl.Op.bound.082] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc9_56: init bool = call %bound_method.loc9_56(%false) [concrete = constants.%false] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] -// CHECK:STDOUT: %.loc9_61.4: ref bool = array_index %return, %int_1 +// CHECK:STDOUT: %.loc9_61.4: ref bool = array_index %return.param, %int_1 // CHECK:STDOUT: %.loc9_61.5: init bool = initialize_from %bool.as.Copy.impl.Op.call.loc9_56 to %.loc9_61.4 [concrete = constants.%false] -// CHECK:STDOUT: %.loc9_61.6: init %array_type.c9b = array_init (%.loc9_61.3, %.loc9_61.5) to %return [concrete = constants.%array] +// CHECK:STDOUT: %.loc9_61.6: init %array_type.c9b = array_init (%.loc9_61.3, %.loc9_61.5) to %return.param [concrete = constants.%array] // CHECK:STDOUT: %.loc9_62: init %array_type.c9b = converted %.loc9_61.1, %.loc9_61.6 [concrete = constants.%array] -// CHECK:STDOUT: return %.loc9_62 to %return +// CHECK:STDOUT: return %.loc9_62 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @N(constants.%Self.ab9) {} diff --git a/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon b/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon index be341c84957c..fa68d043a6f2 100644 --- a/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon +++ b/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon @@ -370,7 +370,7 @@ fn Interface.C.F[self: Self](U:! type, u: U*) -> U* { return u; } // CHECK:STDOUT: %specific_impl_fn.loc20_62.1: = specific_impl_function %impl.elem0.loc20_62.1, @Copy.Op(constants.%Copy.facet) [symbolic = %specific_impl_fn.loc20_62.2 (constants.%specific_impl_fn.9f4)] // CHECK:STDOUT: %bound_method.loc20_62.2: = bound_method %u.ref, %specific_impl_fn.loc20_62.1 // CHECK:STDOUT: %Copy.Op.call: init @C.F.%ptr.loc14_36.1 (%ptr.18e) = call %bound_method.loc20_62.2(%u.ref) -// CHECK:STDOUT: return %Copy.Op.call to %return.loc20 +// CHECK:STDOUT: return %Copy.Op.call to %return.param.loc20 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interface/generic.carbon b/toolchain/check/testdata/interface/generic.carbon index e7291c2031a5..844f2cfb3ced 100644 --- a/toolchain/check/testdata/interface/generic.carbon +++ b/toolchain/check/testdata/interface/generic.carbon @@ -316,9 +316,9 @@ fn F(T:! Generic((), ())) {} // CHECK:STDOUT: fn @C.as.WithAssocFn.impl.F() -> %return.param: %X { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc17_15.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc17_15.2: init %X = class_init (), %return [concrete = constants.%X.val] +// CHECK:STDOUT: %.loc17_15.2: init %X = class_init (), %return.param [concrete = constants.%X.val] // CHECK:STDOUT: %.loc17_16: init %X = converted %.loc17_15.1, %.loc17_15.2 [concrete = constants.%X.val] -// CHECK:STDOUT: return %.loc17_16 to %return +// CHECK:STDOUT: return %.loc17_16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @Receive(%T.loc24_12.2: %Simple.type.12a) { diff --git a/toolchain/check/testdata/interface/generic_method.carbon b/toolchain/check/testdata/interface/generic_method.carbon index d3f9a09f945c..afa68771d4fe 100644 --- a/toolchain/check/testdata/interface/generic_method.carbon +++ b/toolchain/check/testdata/interface/generic_method.carbon @@ -414,10 +414,10 @@ fn CallIndirect() { // CHECK:STDOUT: %.loc17_18.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] // CHECK:STDOUT: %u.ref: @Y.as.A.impl.F.%ptr.loc16_22.1 (%ptr.e8f8f9.1) = name_ref u, %u // CHECK:STDOUT: %.loc17_22.1: @Y.as.A.impl.F.%tuple.type.loc17 (%tuple.type.dd2) = tuple_literal (%.loc17_14.1, %.loc17_18.1, %u.ref) -// CHECK:STDOUT: %tuple.elem0: ref %X = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0: ref %X = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc17_14.2: init %X = class_init (), %tuple.elem0 [concrete = constants.%X.val] // CHECK:STDOUT: %.loc17_22.2: init %X = converted %.loc17_14.1, %.loc17_14.2 [concrete = constants.%X.val] -// CHECK:STDOUT: %tuple.elem1: ref %Y = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1: ref %Y = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc17_18.2: init %Y = class_init (), %tuple.elem1 [concrete = constants.%Y.val] // CHECK:STDOUT: %.loc17_22.3: init %Y = converted %.loc17_18.1, %.loc17_18.2 [concrete = constants.%Y.val] // CHECK:STDOUT: %impl.elem0.loc17_21.1: @Y.as.A.impl.F.%.loc17_21.2 (%.b46) = impl_witness_access constants.%Copy.lookup_impl_witness.2e6, element0 [symbolic = %impl.elem0.loc17_21.2 (constants.%impl.elem0.201)] @@ -425,11 +425,11 @@ fn CallIndirect() { // CHECK:STDOUT: %specific_impl_fn.loc17_21.1: = specific_impl_function %impl.elem0.loc17_21.1, @Copy.Op(constants.%Copy.facet.c25) [symbolic = %specific_impl_fn.loc17_21.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc17_21.2: = bound_method %u.ref, %specific_impl_fn.loc17_21.1 // CHECK:STDOUT: %Copy.Op.call: init @Y.as.A.impl.F.%ptr.loc16_22.1 (%ptr.e8f8f9.1) = call %bound_method.loc17_21.2(%u.ref) -// CHECK:STDOUT: %tuple.elem2: ref @Y.as.A.impl.F.%ptr.loc16_22.1 (%ptr.e8f8f9.1) = tuple_access %return, element2 +// CHECK:STDOUT: %tuple.elem2: ref @Y.as.A.impl.F.%ptr.loc16_22.1 (%ptr.e8f8f9.1) = tuple_access %return.param, element2 // CHECK:STDOUT: %.loc17_22.4: init @Y.as.A.impl.F.%ptr.loc16_22.1 (%ptr.e8f8f9.1) = initialize_from %Copy.Op.call to %tuple.elem2 -// CHECK:STDOUT: %.loc17_22.5: init @Y.as.A.impl.F.%tuple.type.loc16 (%tuple.type.244) = tuple_init (%.loc17_22.2, %.loc17_22.3, %.loc17_22.4) to %return +// CHECK:STDOUT: %.loc17_22.5: init @Y.as.A.impl.F.%tuple.type.loc16 (%tuple.type.244) = tuple_init (%.loc17_22.2, %.loc17_22.3, %.loc17_22.4) to %return.param // CHECK:STDOUT: %.loc17_23: init @Y.as.A.impl.F.%tuple.type.loc16 (%tuple.type.244) = converted %.loc17_22.1, %.loc17_22.5 -// CHECK:STDOUT: return %.loc17_23 to %return +// CHECK:STDOUT: return %.loc17_23 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -916,10 +916,10 @@ fn CallIndirect() { // CHECK:STDOUT: %V2.ref: type = name_ref V2, @tuple.type.as.A.impl.%V2.loc14_25.2 [symbolic = %V2 (constants.%V2)] // CHECK:STDOUT: %.loc17_38: %tuple.type.24b = tuple_literal (%V1.ref, %V2.ref) [symbolic = %tuple.loc17_38 (constants.%tuple.4b9)] // CHECK:STDOUT: %U.ref.loc17_41: type = name_ref U, %U.loc17_8.2 [symbolic = %U.loc17_8.1 (constants.%U.ce4)] -// CHECK:STDOUT: %.loc17_42.2: %tuple.type.11f = tuple_literal (%W.ref, %.loc17_38, %U.ref.loc17_41) [symbolic = %tuple.loc17_42 (constants.%tuple.117)] -// CHECK:STDOUT: %.loc17_42.3: type = converted constants.%tuple.4b9, constants.%tuple.type.a5e [symbolic = %tuple.type.loc17_42.1 (constants.%tuple.type.a5e)] -// CHECK:STDOUT: %.loc17_42.4: type = converted %.loc17_42.2, constants.%tuple.type.897 [symbolic = %tuple.type.loc17_42.2 (constants.%tuple.type.897)] -// CHECK:STDOUT: %.loc17_42.5: form = init_form %.loc17_42.4, call_param1 [symbolic = %.loc17_42.1 (constants.%.c84)] +// CHECK:STDOUT: %.loc17_42.3: %tuple.type.11f = tuple_literal (%W.ref, %.loc17_38, %U.ref.loc17_41) [symbolic = %tuple.loc17_42 (constants.%tuple.117)] +// CHECK:STDOUT: %.loc17_42.4: type = converted constants.%tuple.4b9, constants.%tuple.type.a5e [symbolic = %tuple.type.loc17_42.1 (constants.%tuple.type.a5e)] +// CHECK:STDOUT: %.loc17_42.5: type = converted %.loc17_42.3, constants.%tuple.type.897 [symbolic = %tuple.type.loc17_42.2 (constants.%tuple.type.897)] +// CHECK:STDOUT: %.loc17_42.6: form = init_form %.loc17_42.5, call_param1 [symbolic = %.loc17_42.2 (constants.%.c84)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %U.loc17_8.2: type = symbolic_binding U, 3 [symbolic = %U.loc17_8.1 (constants.%U.ce4)] // CHECK:STDOUT: %u.param: @tuple.type.as.A.impl.F.%U.loc17_8.1 (%U.ce4) = value_param call_param0 @@ -998,7 +998,7 @@ fn CallIndirect() { // CHECK:STDOUT: %tuple.loc17_42: %tuple.type.11f = tuple_value (%W, %tuple.loc17_38, %U.loc17_8.1) [symbolic = %tuple.loc17_42 (constants.%tuple.117)] // CHECK:STDOUT: %tuple.type.loc17_42.1: type = tuple_type (%V1, %V2) [symbolic = %tuple.type.loc17_42.1 (constants.%tuple.type.a5e)] // CHECK:STDOUT: %tuple.type.loc17_42.2: type = tuple_type (%W, %tuple.type.loc17_42.1, %U.loc17_8.1) [symbolic = %tuple.type.loc17_42.2 (constants.%tuple.type.897)] -// CHECK:STDOUT: %.loc17_42.1: form = init_form %tuple.type.loc17_42.2, call_param1 [symbolic = %.loc17_42.1 (constants.%.c84)] +// CHECK:STDOUT: %.loc17_42.2: form = init_form %tuple.type.loc17_42.2, call_param1 [symbolic = %.loc17_42.2 (constants.%.c84)] // CHECK:STDOUT: %pattern_type.loc17_24: type = pattern_type %tuple.type.loc17_42.2 [symbolic = %pattern_type.loc17_24 (constants.%pattern_type.5cc)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -1015,9 +1015,9 @@ fn CallIndirect() { // CHECK:STDOUT: %U.ref.loc18: type = name_ref U, %U.loc17_8.2 [symbolic = %U.loc17_8.1 (constants.%U.ce4)] // CHECK:STDOUT: %u.ref: @tuple.type.as.A.impl.F.%U.loc17_8.1 (%U.ce4) = name_ref u, %u // CHECK:STDOUT: %tuple.type.as.A.impl.F.specific_fn.loc18_12.1: = specific_function %F.ref, @tuple.type.as.A.impl.F(constants.%V1, constants.%V2, constants.%W, constants.%U.ce4) [symbolic = %tuple.type.as.A.impl.F.specific_fn.loc18_12.2 (constants.%tuple.type.as.A.impl.F.specific_fn.009)] -// CHECK:STDOUT: %.loc17_24: ref @tuple.type.as.A.impl.F.%tuple.type.loc17_42.2 (%tuple.type.897) = splice_block %return {} -// CHECK:STDOUT: %tuple.type.as.A.impl.F.call: init @tuple.type.as.A.impl.F.%tuple.type.loc17_42.2 (%tuple.type.897) = call %tuple.type.as.A.impl.F.specific_fn.loc18_12.1(%u.ref) to %.loc17_24 -// CHECK:STDOUT: return %tuple.type.as.A.impl.F.call to %return +// CHECK:STDOUT: %.loc17_42.1: ref @tuple.type.as.A.impl.F.%tuple.type.loc17_42.2 (%tuple.type.897) = splice_block %return.param {} +// CHECK:STDOUT: %tuple.type.as.A.impl.F.call: init @tuple.type.as.A.impl.F.%tuple.type.loc17_42.2 (%tuple.type.897) = call %tuple.type.as.A.impl.F.specific_fn.loc18_12.1(%u.ref) to %.loc17_42.1 +// CHECK:STDOUT: return %tuple.type.as.A.impl.F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1172,7 +1172,7 @@ fn CallIndirect() { // CHECK:STDOUT: %tuple.loc17_42 => constants.%tuple.117 // CHECK:STDOUT: %tuple.type.loc17_42.1 => constants.%tuple.type.a5e // CHECK:STDOUT: %tuple.type.loc17_42.2 => constants.%tuple.type.897 -// CHECK:STDOUT: %.loc17_42.1 => constants.%.c84 +// CHECK:STDOUT: %.loc17_42.2 => constants.%.c84 // CHECK:STDOUT: %pattern_type.loc17_24 => constants.%pattern_type.5cc // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -1234,7 +1234,7 @@ fn CallIndirect() { // CHECK:STDOUT: %tuple.loc17_42 => constants.%tuple.66d // CHECK:STDOUT: %tuple.type.loc17_42.1 => constants.%tuple.type.ab2 // CHECK:STDOUT: %tuple.type.loc17_42.2 => constants.%tuple.type.65a -// CHECK:STDOUT: %.loc17_42.1 => constants.%.d4d +// CHECK:STDOUT: %.loc17_42.2 => constants.%.d4d // CHECK:STDOUT: %pattern_type.loc17_24 => constants.%pattern_type.30b // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/interface/member_lookup.carbon b/toolchain/check/testdata/interface/member_lookup.carbon index a7cba649be51..10cb00979320 100644 --- a/toolchain/check/testdata/interface/member_lookup.carbon +++ b/toolchain/check/testdata/interface/member_lookup.carbon @@ -260,7 +260,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %specific_impl_fn.loc9_11.1: = specific_impl_function %impl.elem0.loc9_11.2, @Copy.Op(constants.%Copy.facet.c25) [symbolic = %specific_impl_fn.loc9_11.2 (constants.%specific_impl_fn.b84)] // CHECK:STDOUT: %bound_method.loc9_11.2: = bound_method %impl.elem0.loc9_11.1, %specific_impl_fn.loc9_11.1 [symbolic = %bound_method.loc9_11.4 (constants.%bound_method.a76)] // CHECK:STDOUT: %Copy.Op.call: init @AccessGeneric.%ptr.loc8_50.1 (%ptr.e8f) = call %bound_method.loc9_11.2(%impl.elem0.loc9_11.1) -// CHECK:STDOUT: return %Copy.Op.call to %return +// CHECK:STDOUT: return %Copy.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -287,7 +287,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc13_11.2, @ptr.as.Copy.impl.Op(constants.%i32) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc13_11.2: = bound_method %impl.elem0.loc13_11.1, %specific_fn [symbolic = %bound_method.loc13_11.3 (constants.%bound_method.06d)] // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.235 = call %bound_method.loc13_11.2(%impl.elem0.loc13_11.1) [symbolic = %impl.elem0.loc13_11.3 (constants.%impl.elem0.322)] -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -496,7 +496,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %I.ref: @AccessMissingGeneric.%Interface.type.loc8_50.1 (%Interface.type.442) = name_ref I, %I.loc8_35.2 [symbolic = %I.loc8_35.1 (constants.%I.682)] // CHECK:STDOUT: %nonesuch.ref: = name_ref nonesuch, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -509,7 +509,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %I.ref: %Interface.type.389 = name_ref I, %I.loc16_26.2 [symbolic = %I.loc16_26.1 (constants.%I.50d)] // CHECK:STDOUT: %nonesuch.ref: = name_ref nonesuch, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/class/abstract.carbon b/toolchain/check/testdata/interop/cpp/class/abstract.carbon index ddcd7db71075..cc74b3ef3811 100644 --- a/toolchain/check/testdata/interop/cpp/class/abstract.carbon +++ b/toolchain/check/testdata/interop/cpp/class/abstract.carbon @@ -115,7 +115,7 @@ fn F() -> Cpp.AbstractFinal { // CHECK:STDOUT: } { // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %AbstractFinal.ref: type = name_ref AbstractFinal, imports.%AbstractFinal.decl [concrete = constants.%AbstractFinal] -// CHECK:STDOUT: %.loc11_14: form = init_form %AbstractFinal.ref, call_param0 [concrete = constants.%.fd6] +// CHECK:STDOUT: %.loc11_14.2: form = init_form %AbstractFinal.ref, call_param0 [concrete = constants.%.fd6] // CHECK:STDOUT: %return.param: ref %AbstractFinal = out_param call_param0 // CHECK:STDOUT: %return: ref %AbstractFinal = return_slot %return.param // CHECK:STDOUT: } @@ -124,8 +124,8 @@ fn F() -> Cpp.AbstractFinal { // CHECK:STDOUT: fn @F() -> %return.param: %AbstractFinal { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] -// CHECK:STDOUT: %.loc11_8: ref %AbstractFinal = splice_block %return {} -// CHECK:STDOUT: %F.call: init %AbstractFinal = call %F.ref() to %.loc11_8 -// CHECK:STDOUT: return %F.call to %return +// CHECK:STDOUT: %.loc11_14.1: ref %AbstractFinal = splice_block %return.param {} +// CHECK:STDOUT: %F.call: init %AbstractFinal = call %F.ref() to %.loc11_14.1 +// CHECK:STDOUT: return %F.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/class/access.carbon b/toolchain/check/testdata/interop/cpp/class/access.carbon index 8dbdc91a885b..ed3253fa664e 100644 --- a/toolchain/check/testdata/interop/cpp/class/access.carbon +++ b/toolchain/check/testdata/interop/cpp/class/access.carbon @@ -2113,7 +2113,7 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %addr.loc11_49: %ptr.dfa = addr_of %.loc11_49.1 // CHECK:STDOUT: %PublicCall__carbon_thunk.call: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc11_49) // CHECK:STDOUT: %.loc11_49.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call, %.loc11_49.1 -// CHECK:STDOUT: %.loc11_51.1: ref %C = class_element_access %return, element0 +// CHECK:STDOUT: %.loc11_51.1: ref %C = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc11_49.3: ref %PublicCall = temporary %.loc11_49.1, %.loc11_49.2 // CHECK:STDOUT: %.loc11_49.4: %PublicCall = acquire_value %.loc11_49.3 // CHECK:STDOUT: %.loc11_49.5: ref %PublicCall = value_as_ref %.loc11_49.4 @@ -2122,11 +2122,11 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl.8acdfe.1(%addr.loc11_50.1, %addr.loc11_50.2) // CHECK:STDOUT: %.loc11_50: init %C = in_place_init %C__carbon_thunk.call, %.loc11_51.1 // CHECK:STDOUT: %.loc11_51.2: %struct_type.base.7c3 = struct_literal (%.loc11_50) -// CHECK:STDOUT: %.loc11_51.3: init %D = class_init (%.loc11_50), %return +// CHECK:STDOUT: %.loc11_51.3: init %D = class_init (%.loc11_50), %return.param // CHECK:STDOUT: %.loc11_52: init %D = converted %.loc11_51.2, %.loc11_51.3 // CHECK:STDOUT: %PublicCall.cpp_destructor.bound: = bound_method %.loc11_49.3, constants.%PublicCall.cpp_destructor // CHECK:STDOUT: %PublicCall.cpp_destructor.call: init %empty_tuple.type = call %PublicCall.cpp_destructor.bound(%.loc11_49.3) -// CHECK:STDOUT: return %.loc11_52 to %return +// CHECK:STDOUT: return %.loc11_52 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @D.MakeProtected() -> %return.param: %D { @@ -2139,7 +2139,7 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %addr.loc17_55: %ptr.8e6 = addr_of %.loc17_55.1 // CHECK:STDOUT: %ProtectedCall__carbon_thunk.call: init %empty_tuple.type = call imports.%ProtectedCall__carbon_thunk.decl(%addr.loc17_55) // CHECK:STDOUT: %.loc17_55.2: init %ProtectedCall = in_place_init %ProtectedCall__carbon_thunk.call, %.loc17_55.1 -// CHECK:STDOUT: %.loc17_57.1: ref %C = class_element_access %return, element0 +// CHECK:STDOUT: %.loc17_57.1: ref %C = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc17_55.3: ref %ProtectedCall = temporary %.loc17_55.1, %.loc17_55.2 // CHECK:STDOUT: %.loc17_55.4: %ProtectedCall = acquire_value %.loc17_55.3 // CHECK:STDOUT: %.loc17_55.5: ref %ProtectedCall = value_as_ref %.loc17_55.4 @@ -2148,11 +2148,11 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl.8acdfe.2(%addr.loc17_56.1, %addr.loc17_56.2) // CHECK:STDOUT: %.loc17_56: init %C = in_place_init %C__carbon_thunk.call, %.loc17_57.1 // CHECK:STDOUT: %.loc17_57.2: %struct_type.base.7c3 = struct_literal (%.loc17_56) -// CHECK:STDOUT: %.loc17_57.3: init %D = class_init (%.loc17_56), %return +// CHECK:STDOUT: %.loc17_57.3: init %D = class_init (%.loc17_56), %return.param // CHECK:STDOUT: %.loc17_58: init %D = converted %.loc17_57.2, %.loc17_57.3 // CHECK:STDOUT: %ProtectedCall.cpp_destructor.bound: = bound_method %.loc17_55.3, constants.%ProtectedCall.cpp_destructor // CHECK:STDOUT: %ProtectedCall.cpp_destructor.call: init %empty_tuple.type = call %ProtectedCall.cpp_destructor.bound(%.loc17_55.3) -// CHECK:STDOUT: return %.loc17_58 to %return +// CHECK:STDOUT: return %.loc17_58 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @D.CallPublic() { diff --git a/toolchain/check/testdata/interop/cpp/class/base.carbon b/toolchain/check/testdata/interop/cpp/class/base.carbon index 3092de9fc515..f343d5f48313 100644 --- a/toolchain/check/testdata/interop/cpp/class/base.carbon +++ b/toolchain/check/testdata/interop/cpp/class/base.carbon @@ -545,7 +545,7 @@ class V { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%Base) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_11.2: = bound_method %.loc8_11.3, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.fb2 = call %bound_method.loc8_11.2(%.loc8_11.3) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ConvertVal(%d.param: %Derived) { @@ -655,7 +655,7 @@ class V { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_11.2: = bound_method %.loc8_11.4, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc8_11.2(%.loc8_11.4) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @AccessQualified(%d.param: %Derived) -> %i32 { @@ -673,7 +673,7 @@ class V { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_11.2: = bound_method %.loc14_11.4, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc14_11.2(%.loc14_11.4) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- use_base_method.carbon diff --git a/toolchain/check/testdata/interop/cpp/class/field.carbon b/toolchain/check/testdata/interop/cpp/class/field.carbon index fa6aaaaf0cca..357a8c1969fd 100644 --- a/toolchain/check/testdata/interop/cpp/class/field.carbon +++ b/toolchain/check/testdata/interop/cpp/class/field.carbon @@ -294,14 +294,14 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn.loc8_12: = specific_function %impl.elem0.loc8_12, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_12.2: = bound_method %.loc8_12.2, %specific_fn.loc8_12 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc8_12: init %i32 = call %bound_method.loc8_12.2(%.loc8_12.2) -// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc8_43.2: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc8_12 to %tuple.elem0 // CHECK:STDOUT: %impl.elem0.loc8_17: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] // CHECK:STDOUT: %bound_method.loc8_17.1: = bound_method %.loc8_17.2, %impl.elem0.loc8_17 // CHECK:STDOUT: %specific_fn.loc8_17: = specific_function %impl.elem0.loc8_17, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_17.2: = bound_method %.loc8_17.2, %specific_fn.loc8_17 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc8_17: init %i32 = call %bound_method.loc8_17.2(%.loc8_17.2) -// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc8_43.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc8_17 to %tuple.elem1 // CHECK:STDOUT: %.loc8_21.2: %i32 = acquire_value %.loc8_21.1 // CHECK:STDOUT: %impl.elem0.loc8_21: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] @@ -309,7 +309,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn.loc8_21: = specific_function %impl.elem0.loc8_21, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_21.2: = bound_method %.loc8_21.2, %specific_fn.loc8_21 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc8_21: init %i32 = call %bound_method.loc8_21.2(%.loc8_21.2) -// CHECK:STDOUT: %tuple.elem2: ref %i32 = tuple_access %return, element2 +// CHECK:STDOUT: %tuple.elem2: ref %i32 = tuple_access %return.param, element2 // CHECK:STDOUT: %.loc8_43.4: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc8_21 to %tuple.elem2 // CHECK:STDOUT: %.loc8_27.2: %i32 = acquire_value %.loc8_27.1 // CHECK:STDOUT: %impl.elem0.loc8_27: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] @@ -317,7 +317,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn.loc8_27: = specific_function %impl.elem0.loc8_27, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_27.2: = bound_method %.loc8_27.2, %specific_fn.loc8_27 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc8_27: init %i32 = call %bound_method.loc8_27.2(%.loc8_27.2) -// CHECK:STDOUT: %tuple.elem3: ref %i32 = tuple_access %return, element3 +// CHECK:STDOUT: %tuple.elem3: ref %i32 = tuple_access %return.param, element3 // CHECK:STDOUT: %.loc8_43.5: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc8_27 to %tuple.elem3 // CHECK:STDOUT: %.loc8_39.2: %i32 = acquire_value %.loc8_39.1 // CHECK:STDOUT: %impl.elem0.loc8_39: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] @@ -325,11 +325,11 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn.loc8_39: = specific_function %impl.elem0.loc8_39, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_39.2: = bound_method %.loc8_39.2, %specific_fn.loc8_39 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call.loc8_39: init %i32 = call %bound_method.loc8_39.2(%.loc8_39.2) -// CHECK:STDOUT: %tuple.elem4: ref %i32 = tuple_access %return, element4 +// CHECK:STDOUT: %tuple.elem4: ref %i32 = tuple_access %return.param, element4 // CHECK:STDOUT: %.loc8_43.6: init %i32 = initialize_from %Int.as.Copy.impl.Op.call.loc8_39 to %tuple.elem4 -// CHECK:STDOUT: %.loc8_43.7: init %tuple.type.a78 = tuple_init (%.loc8_43.2, %.loc8_43.3, %.loc8_43.4, %.loc8_43.5, %.loc8_43.6) to %return +// CHECK:STDOUT: %.loc8_43.7: init %tuple.type.a78 = tuple_init (%.loc8_43.2, %.loc8_43.3, %.loc8_43.4, %.loc8_43.5, %.loc8_43.6) to %return.param // CHECK:STDOUT: %.loc8_44: init %tuple.type.a78 = converted %.loc8_43.1, %.loc8_43.7 -// CHECK:STDOUT: return %.loc8_44 to %return +// CHECK:STDOUT: return %.loc8_44 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- use_union_fields.carbon @@ -370,7 +370,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_11.2: = bound_method %.loc8_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc8_11.2(%.loc8_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G(%u.param: %Union) -> %i32 { @@ -384,7 +384,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_11.2: = bound_method %.loc14_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc14_11.2(%.loc14_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @H(%u.param: %Union) -> %i32 { @@ -400,7 +400,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc20_10.2: = bound_method %.loc20_10.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc20_10.2(%.loc20_10.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- use_non_bitfields_in_type_with_bitfields.carbon @@ -441,7 +441,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc8_11.2: = bound_method %.loc8_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc8_11.2(%.loc8_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G(%s.param: %Union) -> %i32 { @@ -455,7 +455,7 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc14_11.2: = bound_method %.loc14_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc14_11.2(%.loc14_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_use_bitfields.carbon @@ -474,13 +474,13 @@ fn Test(m: Cpp.UnsupportedMembers*) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %s.ref: %Struct = name_ref s, %s // CHECK:STDOUT: %b.ref: = name_ref b, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G(%s.param: %Union) -> %i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %s.ref: %Union = name_ref s, %s // CHECK:STDOUT: %d.ref: = name_ref d, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/class/template.carbon b/toolchain/check/testdata/interop/cpp/class/template.carbon index 514095cf0875..956926efb816 100644 --- a/toolchain/check/testdata/interop/cpp/class/template.carbon +++ b/toolchain/check/testdata/interop/cpp/class/template.carbon @@ -146,7 +146,7 @@ var y: Cpp.Xint.r#type = 0; // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc10_11.2: = bound_method %.loc10_11.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc10_11.2(%.loc10_11.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G(%p.param: %ptr.270) -> %ptr.fb2 { @@ -161,7 +161,7 @@ var y: Cpp.Xint.r#type = 0; // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%Base) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc17_11.2: = bound_method %.loc17_11.3, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.fb2 = call %bound_method.loc17_11.2(%.loc17_11.3) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_use_instantiation_error.carbon diff --git a/toolchain/check/testdata/interop/cpp/function/extern_c.carbon b/toolchain/check/testdata/interop/cpp/function/extern_c.carbon index 6c171b568b28..443a8aa7d5c6 100644 --- a/toolchain/check/testdata/interop/cpp/function/extern_c.carbon +++ b/toolchain/check/testdata/interop/cpp/function/extern_c.carbon @@ -202,7 +202,7 @@ fn MyF(a: Cpp.X, b: Cpp.X) -> Cpp.X { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc10_13.2: = bound_method %.loc10, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc10_13.2(%.loc10) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- extern_c_with_special_name.carbon @@ -232,9 +232,9 @@ fn MyF(a: Cpp.X, b: Cpp.X) -> Cpp.X { // CHECK:STDOUT: %addr.loc11_12.1: %ptr.1f9 = addr_of %.loc11_10 // CHECK:STDOUT: %.loc11_14: ref %X = value_as_ref %b.ref // CHECK:STDOUT: %addr.loc11_12.2: %ptr.1f9 = addr_of %.loc11_14 -// CHECK:STDOUT: %addr.loc11_12.3: %ptr.1f9 = addr_of %.loc9_28 +// CHECK:STDOUT: %addr.loc11_12.3: %ptr.1f9 = addr_of %.loc9_34.1 // CHECK:STDOUT: %operator+__carbon_thunk.call: init %empty_tuple.type = call imports.%operator+__carbon_thunk.decl(%addr.loc11_12.1, %addr.loc11_12.2, %addr.loc11_12.3) -// CHECK:STDOUT: %.loc11_12: init %X = in_place_init %operator+__carbon_thunk.call, %.loc9_28 -// CHECK:STDOUT: return %.loc11_12 to %return +// CHECK:STDOUT: %.loc11_12: init %X = in_place_init %operator+__carbon_thunk.call, %.loc9_34.1 +// CHECK:STDOUT: return %.loc11_12 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/function/function.carbon b/toolchain/check/testdata/interop/cpp/function/function.carbon index 1e1b7d2117c2..5c78b8aadd37 100644 --- a/toolchain/check/testdata/interop/cpp/function/function.carbon +++ b/toolchain/check/testdata/interop/cpp/function/function.carbon @@ -400,6 +400,6 @@ fn G() -> i32 { // CHECK:STDOUT: %.loc14_20.1: %i32 = value_of_initializer %Core.IntLiteral.as.As.impl.Convert.call [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc14_20.2: %i32 = converted %int_1, %.loc14_20.1 [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %bar.call: init %i32 = call imports.%bar.decl(%.loc14_20.2) -// CHECK:STDOUT: return %bar.call to %return +// CHECK:STDOUT: return %bar.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/function/operators.carbon b/toolchain/check/testdata/interop/cpp/function/operators.carbon index 597b0ad2ff41..e98b664e1c2e 100644 --- a/toolchain/check/testdata/interop/cpp/function/operators.carbon +++ b/toolchain/check/testdata/interop/cpp/function/operators.carbon @@ -3070,7 +3070,7 @@ fn F() { // CHECK:STDOUT: %.loc14_14: ref %B = value_as_ref %x.ref.loc14_14 // CHECK:STDOUT: %addr.loc14_12.2: %ptr.a04 = addr_of %.loc14_14 // CHECK:STDOUT: %operator+__carbon_thunk.call: init %i32 = call imports.%operator+__carbon_thunk.decl(%addr.loc14_12.1, %addr.loc14_12.2) -// CHECK:STDOUT: return %operator+__carbon_thunk.call to %return +// CHECK:STDOUT: return %operator+__carbon_thunk.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_overloading.carbon diff --git a/toolchain/check/testdata/interop/cpp/impls/copy.carbon b/toolchain/check/testdata/interop/cpp/impls/copy.carbon index 39b27bd4ab1c..726b25d58795 100644 --- a/toolchain/check/testdata/interop/cpp/impls/copy.carbon +++ b/toolchain/check/testdata/interop/cpp/impls/copy.carbon @@ -256,10 +256,10 @@ fn EqualWitnesses(p: Wrap(Cpp.Copyable)*) -> Wrap(Cpp.Copyable)* { // CHECK:STDOUT: %addr.loc8_10.1: %ptr.e47 = addr_of %.loc8_10.2 // CHECK:STDOUT: %.loc8_10.3: %ptr.29d = as_compatible %addr.loc8_10.1 // CHECK:STDOUT: %.loc8_10.4: %ptr.29d = converted %addr.loc8_10.1, %.loc8_10.3 -// CHECK:STDOUT: %addr.loc8_10.2: %ptr.e47 = addr_of %.loc6_34 +// CHECK:STDOUT: %addr.loc8_10.2: %ptr.e47 = addr_of %.loc6_40.1 // CHECK:STDOUT: %Copyable__carbon_thunk.call: init %empty_tuple.type = call imports.%Copyable__carbon_thunk.decl(%.loc8_10.4, %addr.loc8_10.2) -// CHECK:STDOUT: %.loc8_10.5: init %Copyable = in_place_init %Copyable__carbon_thunk.call, %.loc6_34 -// CHECK:STDOUT: return %.loc8_10.5 to %return +// CHECK:STDOUT: %.loc8_10.5: init %Copyable = in_place_init %Copyable__carbon_thunk.call, %.loc6_40.1 +// CHECK:STDOUT: return %.loc8_10.5 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @CopyExplicitCopy(%c.param: %ExplicitCopy) -> %return.param: %ExplicitCopy { @@ -275,10 +275,10 @@ fn EqualWitnesses(p: Wrap(Cpp.Copyable)*) -> Wrap(Cpp.Copyable)* { // CHECK:STDOUT: %addr.loc14_10.1: %ptr.84c = addr_of %.loc14_10.2 // CHECK:STDOUT: %.loc14_10.3: %ptr.093 = as_compatible %addr.loc14_10.1 // CHECK:STDOUT: %.loc14_10.4: %ptr.093 = converted %addr.loc14_10.1, %.loc14_10.3 -// CHECK:STDOUT: %addr.loc14_10.2: %ptr.84c = addr_of %.loc12_42 +// CHECK:STDOUT: %addr.loc14_10.2: %ptr.84c = addr_of %.loc12_48.1 // CHECK:STDOUT: %ExplicitCopy__carbon_thunk.call: init %empty_tuple.type = call imports.%ExplicitCopy__carbon_thunk.decl(%.loc14_10.4, %addr.loc14_10.2) -// CHECK:STDOUT: %.loc14_10.5: init %ExplicitCopy = in_place_init %ExplicitCopy__carbon_thunk.call, %.loc12_42 -// CHECK:STDOUT: return %.loc14_10.5 to %return +// CHECK:STDOUT: %.loc14_10.5: init %ExplicitCopy = in_place_init %ExplicitCopy__carbon_thunk.call, %.loc12_48.1 +// CHECK:STDOUT: return %.loc14_10.5 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- copy_generically.carbon @@ -323,8 +323,8 @@ fn EqualWitnesses(p: Wrap(Cpp.Copyable)*) -> Wrap(Cpp.Copyable)* { // CHECK:STDOUT: %.loc12_16.2: %Copy.type.fb2 = converted constants.%Copyable, %Copy.facet.loc12_16.2 [concrete = constants.%Copy.facet.c39] // CHECK:STDOUT: %Copy.specific_fn: = specific_function %Copy.ref, @Copy.loc6(constants.%Copy.facet.c39) [concrete = constants.%Copy.specific_fn] // CHECK:STDOUT: -// CHECK:STDOUT: %Copy.call: init %Copyable = call %Copy.specific_fn(%c.ref) to %.loc10_28 -// CHECK:STDOUT: return %Copy.call to %return +// CHECK:STDOUT: %Copy.call: init %Copyable = call %Copy.specific_fn(%c.ref) to %.loc10_34.1 +// CHECK:STDOUT: return %Copy.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @EqualWitnesses(%p.param: %ptr.fba) -> %ptr.fba { @@ -335,6 +335,6 @@ fn EqualWitnesses(p: Wrap(Cpp.Copyable)*) -> Wrap(Cpp.Copyable)* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%Wrap.99f) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc20_10.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.fba = call %bound_method.loc20_10.2(%p.ref) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/stdlib/string_view.carbon b/toolchain/check/testdata/interop/cpp/stdlib/string_view.carbon index 9a3e27cc7c50..eeef6e6f65aa 100644 --- a/toolchain/check/testdata/interop/cpp/stdlib/string_view.carbon +++ b/toolchain/check/testdata/interop/cpp/stdlib/string_view.carbon @@ -110,7 +110,7 @@ fn G() -> str { // CHECK:STDOUT: %return.patt: %pattern_type.461 = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.461 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %.loc13_11: form = init_form constants.%str.ee0, call_param0 [concrete = constants.%.a70] +// CHECK:STDOUT: %.loc13_11.2: form = init_form constants.%str.ee0, call_param0 [concrete = constants.%.a70] // CHECK:STDOUT: %return.param: ref %str.ee0 = out_param call_param0 // CHECK:STDOUT: %return: ref %str.ee0 = return_slot %return.param // CHECK:STDOUT: } @@ -133,10 +133,10 @@ fn G() -> str { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %Produce.ref: %Produce.cpp_overload_set.type = name_ref Produce, imports.%Produce.cpp_overload_set.value [concrete = constants.%Produce.cpp_overload_set.value] -// CHECK:STDOUT: %.loc13_8: ref %str.ee0 = splice_block %return {} -// CHECK:STDOUT: %addr: %ptr.85f = addr_of %.loc13_8 +// CHECK:STDOUT: %.loc13_11.1: ref %str.ee0 = splice_block %return.param {} +// CHECK:STDOUT: %addr: %ptr.85f = addr_of %.loc13_11.1 // CHECK:STDOUT: %Produce__carbon_thunk.call: init %empty_tuple.type = call imports.%Produce__carbon_thunk.decl(%addr) -// CHECK:STDOUT: %.loc14: init %str.ee0 = in_place_init %Produce__carbon_thunk.call, %.loc13_8 -// CHECK:STDOUT: return %.loc14 to %return +// CHECK:STDOUT: %.loc14: init %str.ee0 = in_place_init %Produce__carbon_thunk.call, %.loc13_11.1 +// CHECK:STDOUT: return %.loc14 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/unsupported_decl_type.carbon b/toolchain/check/testdata/interop/cpp/unsupported_decl_type.carbon index 1639206406f0..f99cddba4887 100644 --- a/toolchain/check/testdata/interop/cpp/unsupported_decl_type.carbon +++ b/toolchain/check/testdata/interop/cpp/unsupported_decl_type.carbon @@ -53,6 +53,6 @@ fn F() -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %a.ref: = name_ref a, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/compile_time_bindings.carbon b/toolchain/check/testdata/let/compile_time_bindings.carbon index 3bd265c0e719..4e89dc62a70a 100644 --- a/toolchain/check/testdata/let/compile_time_bindings.carbon +++ b/toolchain/check/testdata/let/compile_time_bindings.carbon @@ -239,9 +239,9 @@ impl i32 as Empty { // CHECK:STDOUT: fn @C.F() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %x.ref: %empty_tuple.type = name_ref x, @C.%x -// CHECK:STDOUT: %.loc5_25: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc5_25: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc5_26: init %empty_tuple.type = converted %x.ref, %.loc5_25 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc5_26 to %return +// CHECK:STDOUT: return %.loc5_26 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_let_before.carbon @@ -311,9 +311,9 @@ impl i32 as Empty { // CHECK:STDOUT: fn @C.F() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %x.ref: %empty_tuple.type = name_ref x, @C.%x -// CHECK:STDOUT: %.loc10_25: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc10_25: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc10_26: init %empty_tuple.type = converted %x.ref, %.loc10_25 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc10_26 to %return +// CHECK:STDOUT: return %.loc10_26 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_multiple_lets.carbon @@ -466,9 +466,9 @@ impl i32 as Empty { // CHECK:STDOUT: fn @C.F() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %x.ref: %empty_tuple.type = name_ref x, .inst{{[0-9A-F]+}}.loc14_7 -// CHECK:STDOUT: %.loc5_25: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc5_25: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc5_26: init %empty_tuple.type = converted %x.ref, %.loc5_25 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc5_26 to %return +// CHECK:STDOUT: return %.loc5_26 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_use_in_function.carbon diff --git a/toolchain/check/testdata/let/global.carbon b/toolchain/check/testdata/let/global.carbon index 5e6f25d53947..ff68f59163ff 100644 --- a/toolchain/check/testdata/let/global.carbon +++ b/toolchain/check/testdata/let/global.carbon @@ -116,7 +116,7 @@ fn F() -> i32 { return n; } // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc17_24.2: = bound_method %n.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_24.2(%n.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/let/local.carbon b/toolchain/check/testdata/let/local.carbon index d7e414a43b73..4183727f49c5 100644 --- a/toolchain/check/testdata/let/local.carbon +++ b/toolchain/check/testdata/let/local.carbon @@ -79,7 +79,7 @@ fn CallF() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %b.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_10.2(%b.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_symbolic.carbon diff --git a/toolchain/check/testdata/let/shadowed_decl.carbon b/toolchain/check/testdata/let/shadowed_decl.carbon index 5efc553ef1fd..93271f59542c 100644 --- a/toolchain/check/testdata/let/shadowed_decl.carbon +++ b/toolchain/check/testdata/let/shadowed_decl.carbon @@ -126,6 +126,6 @@ fn F(a: i32) -> i32 { // CHECK:STDOUT: %specific_fn.loc18: = specific_function %impl.elem0.loc18, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc18_10.2: = bound_method %a.ref, %specific_fn.loc18 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc18_10.2(%a.ref) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/main_run/return_i32.carbon b/toolchain/check/testdata/main_run/return_i32.carbon index c4a136ae83d3..26bcf85339f8 100644 --- a/toolchain/check/testdata/main_run/return_i32.carbon +++ b/toolchain/check/testdata/main_run/return_i32.carbon @@ -85,6 +85,6 @@ fn Run() -> i32 { return 0; } // CHECK:STDOUT: %bound_method.loc14_27.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc14_27.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc14_27: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc14_27 to %return +// CHECK:STDOUT: return %.loc14_27 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/namespace/add_to_import.carbon b/toolchain/check/testdata/namespace/add_to_import.carbon index 8d556ef82a74..186254c67905 100644 --- a/toolchain/check/testdata/namespace/add_to_import.carbon +++ b/toolchain/check/testdata/namespace/add_to_import.carbon @@ -131,7 +131,7 @@ var a: i32 = NS.A(); // CHECK:STDOUT: %bound_method.loc4_28.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc4_28.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc4_28: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc4_28 to %return +// CHECK:STDOUT: return %.loc4_28 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/namespace/alias.carbon b/toolchain/check/testdata/namespace/alias.carbon index 5270251c4aab..70e8edc7b0f6 100644 --- a/toolchain/check/testdata/namespace/alias.carbon +++ b/toolchain/check/testdata/namespace/alias.carbon @@ -130,7 +130,7 @@ fn D() -> i32 { return C(); } // CHECK:STDOUT: %bound_method.loc19_28.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc19_28.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc19_28: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc19_28 to %return +// CHECK:STDOUT: return %.loc19_28 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @B() -> %i32 { @@ -138,13 +138,13 @@ fn D() -> i32 { return C(); } // CHECK:STDOUT: %ns.ref: = name_ref ns, file.%ns [concrete = file.%NS] // CHECK:STDOUT: %A.ref: %A.type = name_ref A, file.%A.decl [concrete = constants.%A] // CHECK:STDOUT: %A.call: init %i32 = call %A.ref() -// CHECK:STDOUT: return %A.call to %return +// CHECK:STDOUT: return %A.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @D() -> %i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %C.ref: %A.type = name_ref C, file.%C [concrete = constants.%A] // CHECK:STDOUT: %A.call: init %i32 = call %C.ref() -// CHECK:STDOUT: return %A.call to %return +// CHECK:STDOUT: return %A.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/namespace/fail_decl_in_alias.carbon b/toolchain/check/testdata/namespace/fail_decl_in_alias.carbon index 12e6516ec2b9..40ee3d119a20 100644 --- a/toolchain/check/testdata/namespace/fail_decl_in_alias.carbon +++ b/toolchain/check/testdata/namespace/fail_decl_in_alias.carbon @@ -100,6 +100,6 @@ fn ns.A() -> i32 { return 0; } // CHECK:STDOUT: %bound_method.loc27_28.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc27_28.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc27_28: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc27_28 to %return +// CHECK:STDOUT: return %.loc27_28 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/namespace/merging_with_indirections.carbon b/toolchain/check/testdata/namespace/merging_with_indirections.carbon index 8e0c787efaec..d973a48e9458 100644 --- a/toolchain/check/testdata/namespace/merging_with_indirections.carbon +++ b/toolchain/check/testdata/namespace/merging_with_indirections.carbon @@ -153,9 +153,9 @@ fn Run() { // CHECK:STDOUT: fn @F() -> %return.param: %A { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc8_27.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc8_27.2: init %A = class_init (), %return [concrete = constants.%A.val] +// CHECK:STDOUT: %.loc8_27.2: init %A = class_init (), %return.param [concrete = constants.%A.val] // CHECK:STDOUT: %.loc8_28: init %A = converted %.loc8_27.1, %.loc8_27.2 [concrete = constants.%A.val] -// CHECK:STDOUT: return %.loc8_28 to %return +// CHECK:STDOUT: return %.loc8_28 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- main.carbon diff --git a/toolchain/check/testdata/namespace/shadow.carbon b/toolchain/check/testdata/namespace/shadow.carbon index f1f6f8046d86..fc0446a2cdce 100644 --- a/toolchain/check/testdata/namespace/shadow.carbon +++ b/toolchain/check/testdata/namespace/shadow.carbon @@ -168,7 +168,7 @@ fn N.M.B() -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc29_12.2(%.loc29) // CHECK:STDOUT: %DestroyOp.bound.loc26_5.1: = bound_method %A.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc26_5.1: init %empty_tuple.type = call %DestroyOp.bound.loc26_5.1(%A.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else: // CHECK:STDOUT: %int_0.loc31: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] @@ -180,7 +180,7 @@ fn N.M.B() -> i32 { // CHECK:STDOUT: %.loc31: init %i32 = converted %int_0.loc31, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc31 [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %DestroyOp.bound.loc26_5.2: = bound_method %A.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc26_5.2: init %empty_tuple.type = call %DestroyOp.bound.loc26_5.2(%A.var) -// CHECK:STDOUT: return %.loc31 to %return +// CHECK:STDOUT: return %.loc31 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %i32) = "no_op"; diff --git a/toolchain/check/testdata/operators/builtin/and.carbon b/toolchain/check/testdata/operators/builtin/and.carbon index 7511941b6427..c07718df5029 100644 --- a/toolchain/check/testdata/operators/builtin/and.carbon +++ b/toolchain/check/testdata/operators/builtin/and.carbon @@ -146,7 +146,7 @@ fn PartialConstant(x: bool) { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %true, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true) [concrete = constants.%true] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G() -> bool { @@ -155,7 +155,7 @@ fn PartialConstant(x: bool) { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %true, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true) [concrete = constants.%true] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @And() -> bool { @@ -179,7 +179,7 @@ fn PartialConstant(x: bool) { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc19_14.5, %impl.elem0 // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%.loc19_14.5) -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Constant() { diff --git a/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon b/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon index c1d786c4f3a2..7b01d950a4b7 100644 --- a/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon +++ b/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon @@ -123,7 +123,7 @@ fn F() { // CHECK:STDOUT: %impl.elem0: %.436 = impl_witness_access constants.%Copy.impl_witness.b47, element0 [concrete = constants.%type.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc6, %impl.elem0 // CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method(%.loc6) -// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to .inst{{[0-9A-F]+}}.loc5_15 +// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_and_val.carbon @@ -167,7 +167,7 @@ fn F() { // CHECK:STDOUT: %impl.elem0: %.436 = impl_witness_access constants.%Copy.impl_witness.b47, element0 [concrete = constants.%type.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc6, %impl.elem0 // CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method(%.loc6) -// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to .inst{{[0-9A-F]+}}.loc5_15 +// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_or_val.carbon diff --git a/toolchain/check/testdata/operators/builtin/fail_redundant_compound_access.carbon b/toolchain/check/testdata/operators/builtin/fail_redundant_compound_access.carbon index 4afbd7db01cf..da4793abb62e 100644 --- a/toolchain/check/testdata/operators/builtin/fail_redundant_compound_access.carbon +++ b/toolchain/check/testdata/operators/builtin/fail_redundant_compound_access.carbon @@ -127,7 +127,7 @@ fn Main() { // CHECK:STDOUT: %bound_method.loc15_25.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.d2e] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc15_25.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc15_25: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc15_25 to %return +// CHECK:STDOUT: return %.loc15_25 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Main() { diff --git a/toolchain/check/testdata/operators/builtin/fail_type_mismatch_once.carbon b/toolchain/check/testdata/operators/builtin/fail_type_mismatch_once.carbon index 2faa47e40f39..30dccf488f31 100644 --- a/toolchain/check/testdata/operators/builtin/fail_type_mismatch_once.carbon +++ b/toolchain/check/testdata/operators/builtin/fail_type_mismatch_once.carbon @@ -75,6 +75,6 @@ fn Main() -> i32 { // CHECK:STDOUT: %.loc22: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] // CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 34e-1 [concrete = constants.%float] // CHECK:STDOUT: %int_12: Core.IntLiteral = int_value 12 [concrete = constants.%int_12] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/builtin/fail_unimplemented_op.carbon b/toolchain/check/testdata/operators/builtin/fail_unimplemented_op.carbon index 180d0fd5028c..4d2ba81a2008 100644 --- a/toolchain/check/testdata/operators/builtin/fail_unimplemented_op.carbon +++ b/toolchain/check/testdata/operators/builtin/fail_unimplemented_op.carbon @@ -71,6 +71,6 @@ fn Main() -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc20: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] // CHECK:STDOUT: %int_34: Core.IntLiteral = int_value 34 [concrete = constants.%int_34] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/builtin/or.carbon b/toolchain/check/testdata/operators/builtin/or.carbon index e893e76abf5f..bc3d75d4e6dc 100644 --- a/toolchain/check/testdata/operators/builtin/or.carbon +++ b/toolchain/check/testdata/operators/builtin/or.carbon @@ -146,7 +146,7 @@ fn PartialConstant(x: bool) { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %true, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true) [concrete = constants.%true] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G() -> bool { @@ -155,7 +155,7 @@ fn PartialConstant(x: bool) { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %true, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true) [concrete = constants.%true] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Or() -> bool { @@ -180,7 +180,7 @@ fn PartialConstant(x: bool) { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc19_14.6, %impl.elem0 // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%.loc19_14.6) -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Constant() { diff --git a/toolchain/check/testdata/operators/builtin/unary_op.carbon b/toolchain/check/testdata/operators/builtin/unary_op.carbon index 737bd00df71a..dd0734f08832 100644 --- a/toolchain/check/testdata/operators/builtin/unary_op.carbon +++ b/toolchain/check/testdata/operators/builtin/unary_op.carbon @@ -127,7 +127,7 @@ fn Constant() { // CHECK:STDOUT: %impl.elem0: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %.loc16, %impl.elem0 // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%.loc16) -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Constant() { diff --git a/toolchain/check/testdata/operators/overloaded/add.carbon b/toolchain/check/testdata/operators/overloaded/add.carbon index 9fc542a7825c..127d3f50327f 100644 --- a/toolchain/check/testdata/operators/overloaded/add.carbon +++ b/toolchain/check/testdata/operators/overloaded/add.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.042 = impl_witness_access constants.%AddWith.impl_witness, element1 [concrete = constants.%C.as.AddWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.AddWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.AddWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.AddWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.AddWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/bit_and.carbon b/toolchain/check/testdata/operators/overloaded/bit_and.carbon index e8c444567464..c39bbee3a86a 100644 --- a/toolchain/check/testdata/operators/overloaded/bit_and.carbon +++ b/toolchain/check/testdata/operators/overloaded/bit_and.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.952 = impl_witness_access constants.%BitAndWith.impl_witness, element1 [concrete = constants.%C.as.BitAndWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.BitAndWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.BitAndWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.BitAndWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.BitAndWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/bit_complement.carbon b/toolchain/check/testdata/operators/overloaded/bit_complement.carbon index 9ab781d40f2c..9e622739a2eb 100644 --- a/toolchain/check/testdata/operators/overloaded/bit_complement.carbon +++ b/toolchain/check/testdata/operators/overloaded/bit_complement.carbon @@ -52,7 +52,7 @@ fn TestOp(a: C) -> C { // CHECK:STDOUT: %impl.elem1: %.b59 = impl_witness_access constants.%BitComplement.impl_witness, element1 [concrete = constants.%C.as.BitComplement.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.BitComplement.impl.Op.call: init %C = call %bound_method(%a.ref) to %.loc27_17 -// CHECK:STDOUT: return %C.as.BitComplement.impl.Op.call to %return +// CHECK:STDOUT: %C.as.BitComplement.impl.Op.call: init %C = call %bound_method(%a.ref) to %.loc27_20.1 +// CHECK:STDOUT: return %C.as.BitComplement.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/overloaded/bit_or.carbon b/toolchain/check/testdata/operators/overloaded/bit_or.carbon index 85d8da798826..44811d0fb8bf 100644 --- a/toolchain/check/testdata/operators/overloaded/bit_or.carbon +++ b/toolchain/check/testdata/operators/overloaded/bit_or.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.288 = impl_witness_access constants.%BitOrWith.impl_witness, element1 [concrete = constants.%C.as.BitOrWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.BitOrWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.BitOrWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.BitOrWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.BitOrWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/bit_xor.carbon b/toolchain/check/testdata/operators/overloaded/bit_xor.carbon index fbed86460f52..1af4f3d118ae 100644 --- a/toolchain/check/testdata/operators/overloaded/bit_xor.carbon +++ b/toolchain/check/testdata/operators/overloaded/bit_xor.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.864 = impl_witness_access constants.%BitXorWith.impl_witness, element1 [concrete = constants.%C.as.BitXorWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.BitXorWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.BitXorWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.BitXorWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.BitXorWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/div.carbon b/toolchain/check/testdata/operators/overloaded/div.carbon index 5b27316b11b3..68a3cf1abd56 100644 --- a/toolchain/check/testdata/operators/overloaded/div.carbon +++ b/toolchain/check/testdata/operators/overloaded/div.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.96d = impl_witness_access constants.%DivWith.impl_witness, element1 [concrete = constants.%C.as.DivWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.DivWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.DivWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.DivWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.DivWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/eq.carbon b/toolchain/check/testdata/operators/overloaded/eq.carbon index 1e8e5abbfeb4..d15a1d267a42 100644 --- a/toolchain/check/testdata/operators/overloaded/eq.carbon +++ b/toolchain/check/testdata/operators/overloaded/eq.carbon @@ -254,7 +254,7 @@ fn TestLhsBad(a: D, b: C) -> bool { // CHECK:STDOUT: %impl.elem0: %.5c2 = impl_witness_access constants.%EqWith.impl_witness, element0 [concrete = constants.%C.as.EqWith.impl.Equal] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem0 // CHECK:STDOUT: %C.as.EqWith.impl.Equal.call: init bool = call %bound_method(%a.ref, %b.ref) -// CHECK:STDOUT: return %C.as.EqWith.impl.Equal.call to %return +// CHECK:STDOUT: return %C.as.EqWith.impl.Equal.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestNotEqual(%a.param: %C, %b.param: %C) -> bool { @@ -264,7 +264,7 @@ fn TestLhsBad(a: D, b: C) -> bool { // CHECK:STDOUT: %impl.elem1: %.371 = impl_witness_access constants.%EqWith.impl_witness, element1 [concrete = constants.%C.as.EqWith.impl.NotEqual] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: %C.as.EqWith.impl.NotEqual.call: init bool = call %bound_method(%a.ref, %b.ref) -// CHECK:STDOUT: return %C.as.EqWith.impl.NotEqual.call to %return +// CHECK:STDOUT: return %C.as.EqWith.impl.NotEqual.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_no_impl.carbon @@ -362,14 +362,14 @@ fn TestLhsBad(a: D, b: C) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestNotEqual(%a.param: %D, %b.param: %D) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_no_impl_for_args.carbon @@ -549,13 +549,13 @@ fn TestLhsBad(a: D, b: C) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %C = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestLhsBad(%a.param: %D, %b.param: %C) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %C = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/overloaded/fail_no_impl.carbon b/toolchain/check/testdata/operators/overloaded/fail_no_impl.carbon index 34582f83e78f..ea945889b0a0 100644 --- a/toolchain/check/testdata/operators/overloaded/fail_no_impl.carbon +++ b/toolchain/check/testdata/operators/overloaded/fail_no_impl.carbon @@ -156,14 +156,14 @@ fn TestRef(b: C) { // CHECK:STDOUT: fn @TestUnary(%a.param: %C) -> %return.param: %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %C = name_ref a, %a -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestBinary(%a.param: %C, %b.param: %C) -> %return.param: %C { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %C = name_ref a, %a // CHECK:STDOUT: %b.ref: %C = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestRef(%b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/implicit_as.carbon b/toolchain/check/testdata/operators/overloaded/implicit_as.carbon index fcedf2039f69..6d61f57f4517 100644 --- a/toolchain/check/testdata/operators/overloaded/implicit_as.carbon +++ b/toolchain/check/testdata/operators/overloaded/implicit_as.carbon @@ -174,7 +174,7 @@ fn Test() { // CHECK:STDOUT: %return.param_patt: @Source.%pattern_type (%pattern_type.51d1c4.2) = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %T.ref.loc31_24: type = name_ref T, %T.loc31_11.2 [symbolic = %T.loc31_11.1 (constants.%T.67d)] -// CHECK:STDOUT: %.loc31_24.2: form = init_form %T.ref.loc31_24, call_param0 [symbolic = %.loc31_24.1 (constants.%.c6c)] +// CHECK:STDOUT: %.loc31_24.3: form = init_form %T.ref.loc31_24, call_param0 [symbolic = %.loc31_24.2 (constants.%.c6c)] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %T.loc31_11.2: type = symbolic_binding T, 0 [symbolic = %T.loc31_11.1 (constants.%T.67d)] // CHECK:STDOUT: %return.param: ref @Source.%T.loc31_11.1 (%T.67d) = out_param call_param0 @@ -256,11 +256,11 @@ fn Test() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc20_47.2: = bound_method %self.ref, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc20_47.2(%self.ref) -// CHECK:STDOUT: %.loc20_51.2: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc20_51.2: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc20_51.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call to %.loc20_51.2 -// CHECK:STDOUT: %.loc20_51.4: init %X = class_init (%.loc20_51.3), %return +// CHECK:STDOUT: %.loc20_51.4: init %X = class_init (%.loc20_51.3), %return.param // CHECK:STDOUT: %.loc20_52: init %X = converted %.loc20_51.1, %.loc20_51.4 -// CHECK:STDOUT: return %.loc20_52 to %return +// CHECK:STDOUT: return %.loc20_52 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @X.as.ImplicitAs.impl.Convert(%self.param: %X) -> %i32 { @@ -274,7 +274,7 @@ fn Test() { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc24_45.2: = bound_method %.loc24_45.2, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc24_45.2(%.loc24_45.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Sink_i32(%n.param: %i32); @@ -283,7 +283,7 @@ fn Test() { // CHECK:STDOUT: // CHECK:STDOUT: generic fn @Source(%T.loc31_11.2: type) { // CHECK:STDOUT: %T.loc31_11.1: type = symbolic_binding T, 0 [symbolic = %T.loc31_11.1 (constants.%T.67d)] -// CHECK:STDOUT: %.loc31_24.1: form = init_form %T.loc31_11.1, call_param0 [symbolic = %.loc31_24.1 (constants.%.c6c)] +// CHECK:STDOUT: %.loc31_24.2: form = init_form %T.loc31_11.1, call_param0 [symbolic = %.loc31_24.2 (constants.%.c6c)] // CHECK:STDOUT: %pattern_type: type = pattern_type %T.loc31_11.1 [symbolic = %pattern_type (constants.%pattern_type.51d1c4.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -295,9 +295,9 @@ fn Test() { // CHECK:STDOUT: %Source.ref: %Source.type = name_ref Source, file.%Source.decl [concrete = constants.%Source] // CHECK:STDOUT: %T.ref.loc31_42: type = name_ref T, %T.loc31_11.2 [symbolic = %T.loc31_11.1 (constants.%T.67d)] // CHECK:STDOUT: %Source.specific_fn.loc31_35.1: = specific_function %Source.ref, @Source(constants.%T.67d) [symbolic = %Source.specific_fn.loc31_35.2 (constants.%Source.specific_fn.24a)] -// CHECK:STDOUT: %.loc31_21: ref @Source.%T.loc31_11.1 (%T.67d) = splice_block %return {} -// CHECK:STDOUT: %Source.call: init @Source.%T.loc31_11.1 (%T.67d) = call %Source.specific_fn.loc31_35.1() to %.loc31_21 -// CHECK:STDOUT: return %Source.call to %return +// CHECK:STDOUT: %.loc31_24.1: ref @Source.%T.loc31_11.1 (%T.67d) = splice_block %return.param {} +// CHECK:STDOUT: %Source.call: init @Source.%T.loc31_11.1 (%T.67d) = call %Source.specific_fn.loc31_35.1() to %.loc31_24.1 +// CHECK:STDOUT: return %Source.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -344,7 +344,7 @@ fn Test() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Source(constants.%T.67d) { // CHECK:STDOUT: %T.loc31_11.1 => constants.%T.67d -// CHECK:STDOUT: %.loc31_24.1 => constants.%.c6c +// CHECK:STDOUT: %.loc31_24.2 => constants.%.c6c // CHECK:STDOUT: %pattern_type => constants.%pattern_type.51d1c4.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -354,7 +354,7 @@ fn Test() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Source(constants.%X) { // CHECK:STDOUT: %T.loc31_11.1 => constants.%X -// CHECK:STDOUT: %.loc31_24.1 => constants.%.599 +// CHECK:STDOUT: %.loc31_24.2 => constants.%.599 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.05f // CHECK:STDOUT: // CHECK:STDOUT: !definition: @@ -364,7 +364,7 @@ fn Test() { // CHECK:STDOUT: // CHECK:STDOUT: specific @Source(constants.%i32) { // CHECK:STDOUT: %T.loc31_11.1 => constants.%i32 -// CHECK:STDOUT: %.loc31_24.1 => constants.%.941 +// CHECK:STDOUT: %.loc31_24.2 => constants.%.941 // CHECK:STDOUT: %pattern_type => constants.%pattern_type.7ce // CHECK:STDOUT: // CHECK:STDOUT: !definition: diff --git a/toolchain/check/testdata/operators/overloaded/index.carbon b/toolchain/check/testdata/operators/overloaded/index.carbon index e23352dc44c6..a80e2ccefeb1 100644 --- a/toolchain/check/testdata/operators/overloaded/index.carbon +++ b/toolchain/check/testdata/operators/overloaded/index.carbon @@ -464,9 +464,9 @@ fn F() { // CHECK:STDOUT: fn @C.as.IndexWith.impl.At(%self.param: %C, %subscript.param: %empty_tuple.type) -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc10_13.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc10_13.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc10_13.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc10_14: init %empty_tuple.type = converted %.loc10_13.1, %.loc10_13.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc10_14 to %return +// CHECK:STDOUT: return %.loc10_14 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { diff --git a/toolchain/check/testdata/operators/overloaded/index_with_prelude.carbon b/toolchain/check/testdata/operators/overloaded/index_with_prelude.carbon index 1d15678c3d62..fdc827252c8f 100644 --- a/toolchain/check/testdata/operators/overloaded/index_with_prelude.carbon +++ b/toolchain/check/testdata/operators/overloaded/index_with_prelude.carbon @@ -252,9 +252,9 @@ let x: i32 = c[0]; // CHECK:STDOUT: fn @C.as.IndexWith.impl.At(%self.param: %C, %subscript.param: %SubscriptType.9ec) -> %return.param: %ElementType { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc10_13.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc10_13.2: init %ElementType = class_init (), %return [concrete = constants.%ElementType.val] +// CHECK:STDOUT: %.loc10_13.2: init %ElementType = class_init (), %return.param [concrete = constants.%ElementType.val] // CHECK:STDOUT: %.loc10_14: init %ElementType = converted %.loc10_13.1, %.loc10_13.2 [concrete = constants.%ElementType.val] -// CHECK:STDOUT: return %.loc10_14 to %return +// CHECK:STDOUT: return %.loc10_14 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { @@ -438,11 +438,11 @@ let x: i32 = c[0]; // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] // CHECK:STDOUT: %tuple.elem0: %C = tuple_access %self.ref, element0 // CHECK:STDOUT: %.loc10_18.1: %empty_tuple.type = as_compatible %tuple.elem0 -// CHECK:STDOUT: %.loc10_18.2: ref %empty_tuple.type = as_compatible %return +// CHECK:STDOUT: %.loc10_18.2: ref %empty_tuple.type = as_compatible %return.param // CHECK:STDOUT: %.loc10_18.3: init %empty_tuple.type = tuple_init () to %.loc10_18.2 [concrete = constants.%empty_tuple.af4] // CHECK:STDOUT: %.loc10_18.4: init %C = as_compatible %.loc10_18.3 [concrete = constants.%empty_tuple.bfb] // CHECK:STDOUT: %.loc10_18.5: init %C = converted %tuple.elem0, %.loc10_18.4 [concrete = constants.%empty_tuple.bfb] -// CHECK:STDOUT: return %.loc10_18.5 to %return +// CHECK:STDOUT: return %.loc10_18.5 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { @@ -620,9 +620,9 @@ let x: i32 = c[0]; // CHECK:STDOUT: fn @C.as.IndexWith.impl.At(%self.param: %C, %subscript.param: %SubscriptType.9ec) -> %return.param: %ElementType { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc10_13.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc10_13.2: init %ElementType = class_init (), %return [concrete = constants.%ElementType.val] +// CHECK:STDOUT: %.loc10_13.2: init %ElementType = class_init (), %return.param [concrete = constants.%ElementType.val] // CHECK:STDOUT: %.loc10_14: init %ElementType = converted %.loc10_13.1, %.loc10_13.2 [concrete = constants.%ElementType.val] -// CHECK:STDOUT: return %.loc10_14 to %return +// CHECK:STDOUT: return %.loc10_14 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/operators/overloaded/left_shift.carbon b/toolchain/check/testdata/operators/overloaded/left_shift.carbon index d7f85a567aa2..341724bbd171 100644 --- a/toolchain/check/testdata/operators/overloaded/left_shift.carbon +++ b/toolchain/check/testdata/operators/overloaded/left_shift.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.ad2 = impl_witness_access constants.%LeftShiftWith.impl_witness, element1 [concrete = constants.%C.as.LeftShiftWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.LeftShiftWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.LeftShiftWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.LeftShiftWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.LeftShiftWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/mod.carbon b/toolchain/check/testdata/operators/overloaded/mod.carbon index 6ec0827250ad..21ac0a6510fc 100644 --- a/toolchain/check/testdata/operators/overloaded/mod.carbon +++ b/toolchain/check/testdata/operators/overloaded/mod.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.523 = impl_witness_access constants.%ModWith.impl_witness, element1 [concrete = constants.%C.as.ModWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.ModWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.ModWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.ModWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.ModWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/mul.carbon b/toolchain/check/testdata/operators/overloaded/mul.carbon index cfdcb9b95df0..9029c413b60d 100644 --- a/toolchain/check/testdata/operators/overloaded/mul.carbon +++ b/toolchain/check/testdata/operators/overloaded/mul.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.92e = impl_witness_access constants.%MulWith.impl_witness, element1 [concrete = constants.%C.as.MulWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.MulWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.MulWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.MulWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.MulWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/negate.carbon b/toolchain/check/testdata/operators/overloaded/negate.carbon index 3b593d26b14a..7bd777651ed4 100644 --- a/toolchain/check/testdata/operators/overloaded/negate.carbon +++ b/toolchain/check/testdata/operators/overloaded/negate.carbon @@ -52,7 +52,7 @@ fn TestOp(a: C) -> C { // CHECK:STDOUT: %impl.elem1: %.e21 = impl_witness_access constants.%Negate.impl_witness, element1 [concrete = constants.%C.as.Negate.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.Negate.impl.Op.call: init %C = call %bound_method(%a.ref) to %.loc27_17 -// CHECK:STDOUT: return %C.as.Negate.impl.Op.call to %return +// CHECK:STDOUT: %C.as.Negate.impl.Op.call: init %C = call %bound_method(%a.ref) to %.loc27_20.1 +// CHECK:STDOUT: return %C.as.Negate.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/overloaded/ordered.carbon b/toolchain/check/testdata/operators/overloaded/ordered.carbon index 136b5f5a579c..7271bc9c0179 100644 --- a/toolchain/check/testdata/operators/overloaded/ordered.carbon +++ b/toolchain/check/testdata/operators/overloaded/ordered.carbon @@ -356,7 +356,7 @@ fn TestGreaterEqual(a: D, b: D) -> bool { // CHECK:STDOUT: %impl.elem0: %.cde = impl_witness_access constants.%OrderedWith.impl_witness, element0 [concrete = constants.%C.as.OrderedWith.impl.Less] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem0 // CHECK:STDOUT: %C.as.OrderedWith.impl.Less.call: init bool = call %bound_method(%a.ref, %b.ref) -// CHECK:STDOUT: return %C.as.OrderedWith.impl.Less.call to %return +// CHECK:STDOUT: return %C.as.OrderedWith.impl.Less.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestLessEqual(%a.param: %C, %b.param: %C) -> bool { @@ -366,7 +366,7 @@ fn TestGreaterEqual(a: D, b: D) -> bool { // CHECK:STDOUT: %impl.elem1: %.481 = impl_witness_access constants.%OrderedWith.impl_witness, element1 [concrete = constants.%C.as.OrderedWith.impl.LessOrEquivalent] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: %C.as.OrderedWith.impl.LessOrEquivalent.call: init bool = call %bound_method(%a.ref, %b.ref) -// CHECK:STDOUT: return %C.as.OrderedWith.impl.LessOrEquivalent.call to %return +// CHECK:STDOUT: return %C.as.OrderedWith.impl.LessOrEquivalent.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestGreater(%a.param: %C, %b.param: %C) -> bool { @@ -376,7 +376,7 @@ fn TestGreaterEqual(a: D, b: D) -> bool { // CHECK:STDOUT: %impl.elem2: %.80a = impl_witness_access constants.%OrderedWith.impl_witness, element2 [concrete = constants.%C.as.OrderedWith.impl.Greater] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem2 // CHECK:STDOUT: %C.as.OrderedWith.impl.Greater.call: init bool = call %bound_method(%a.ref, %b.ref) -// CHECK:STDOUT: return %C.as.OrderedWith.impl.Greater.call to %return +// CHECK:STDOUT: return %C.as.OrderedWith.impl.Greater.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestGreaterEqual(%a.param: %C, %b.param: %C) -> bool { @@ -386,7 +386,7 @@ fn TestGreaterEqual(a: D, b: D) -> bool { // CHECK:STDOUT: %impl.elem3: %.972 = impl_witness_access constants.%OrderedWith.impl_witness, element3 [concrete = constants.%C.as.OrderedWith.impl.GreaterOrEquivalent] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem3 // CHECK:STDOUT: %C.as.OrderedWith.impl.GreaterOrEquivalent.call: init bool = call %bound_method(%a.ref, %b.ref) -// CHECK:STDOUT: return %C.as.OrderedWith.impl.GreaterOrEquivalent.call to %return +// CHECK:STDOUT: return %C.as.OrderedWith.impl.GreaterOrEquivalent.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_no_impl.carbon @@ -532,27 +532,27 @@ fn TestGreaterEqual(a: D, b: D) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestLessEqual(%a.param: %D, %b.param: %D) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestGreater(%a.param: %D, %b.param: %D) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestGreaterEqual(%a.param: %D, %b.param: %D) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %a.ref: %D = name_ref a, %a // CHECK:STDOUT: %b.ref: %D = name_ref b, %b -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/operators/overloaded/right_shift.carbon b/toolchain/check/testdata/operators/overloaded/right_shift.carbon index 62680334e338..cf8d198a4fa0 100644 --- a/toolchain/check/testdata/operators/overloaded/right_shift.carbon +++ b/toolchain/check/testdata/operators/overloaded/right_shift.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.6b7 = impl_witness_access constants.%RightShiftWith.impl_witness, element1 [concrete = constants.%C.as.RightShiftWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.RightShiftWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.RightShiftWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.RightShiftWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.RightShiftWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/operators/overloaded/sub.carbon b/toolchain/check/testdata/operators/overloaded/sub.carbon index dd2064c41926..1e056a3c847b 100644 --- a/toolchain/check/testdata/operators/overloaded/sub.carbon +++ b/toolchain/check/testdata/operators/overloaded/sub.carbon @@ -71,8 +71,8 @@ fn TestAssign(a: C*, b: C) { // CHECK:STDOUT: %impl.elem1: %.d15 = impl_witness_access constants.%SubWith.impl_witness, element1 [concrete = constants.%C.as.SubWith.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %a.ref, %impl.elem1 // CHECK:STDOUT: -// CHECK:STDOUT: %C.as.SubWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_23 -// CHECK:STDOUT: return %C.as.SubWith.impl.Op.call to %return +// CHECK:STDOUT: %C.as.SubWith.impl.Op.call: init %C = call %bound_method(%a.ref, %b.ref) to %.loc30_26.1 +// CHECK:STDOUT: return %C.as.SubWith.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @TestAssign(%a.param: %ptr.872, %b.param: %C) { diff --git a/toolchain/check/testdata/packages/missing_prelude.carbon b/toolchain/check/testdata/packages/missing_prelude.carbon index 9e454c20b5c9..7037891e38ff 100644 --- a/toolchain/check/testdata/packages/missing_prelude.carbon +++ b/toolchain/check/testdata/packages/missing_prelude.carbon @@ -209,9 +209,9 @@ var n: {} = i32; // CHECK:STDOUT: fn() -> %empty_struct_type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc4_41.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %.loc4_41.2: init %empty_struct_type = struct_init () to %return [concrete = constants.%empty_struct] +// CHECK:STDOUT: %.loc4_41.2: init %empty_struct_type = struct_init () to %return.param [concrete = constants.%empty_struct] // CHECK:STDOUT: %.loc4_42: init %empty_struct_type = converted %.loc4_41.1, %.loc4_41.2 [concrete = constants.%empty_struct] -// CHECK:STDOUT: return %.loc4_42 to %return +// CHECK:STDOUT: return %.loc4_42 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -364,9 +364,9 @@ var n: {} = i32; // CHECK:STDOUT: fn() -> %empty_tuple.type { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %.loc8_41.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc8_41.2: init %empty_tuple.type = tuple_init () to %return [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc8_41.2: init %empty_tuple.type = tuple_init () to %return.param [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc8_42: init %empty_tuple.type = converted %.loc8_41.1, %.loc8_41.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: return %.loc8_42 to %return +// CHECK:STDOUT: return %.loc8_42 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/pointer/address_of_deref.carbon b/toolchain/check/testdata/pointer/address_of_deref.carbon index d37fca7b44b6..ba41d04240a3 100644 --- a/toolchain/check/testdata/pointer/address_of_deref.carbon +++ b/toolchain/check/testdata/pointer/address_of_deref.carbon @@ -133,7 +133,7 @@ fn F() -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_10.2(%.loc17_10.2) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %n.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%n.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %i32) = "no_op"; diff --git a/toolchain/check/testdata/pointer/basic.carbon b/toolchain/check/testdata/pointer/basic.carbon index b219215743ea..6624b33cf4e5 100644 --- a/toolchain/check/testdata/pointer/basic.carbon +++ b/toolchain/check/testdata/pointer/basic.carbon @@ -168,7 +168,7 @@ fn F() -> i32 { // CHECK:STDOUT: %DestroyOp.call.loc17: init %empty_tuple.type = call %DestroyOp.bound.loc17(%p.var) // CHECK:STDOUT: %DestroyOp.bound.loc16: = bound_method %n.var, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call.loc16: init %empty_tuple.type = call %DestroyOp.bound.loc16(%n.var) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc17(%self.param: %ptr.235) = "no_op"; diff --git a/toolchain/check/testdata/pointer/fail_type_mismatch.carbon b/toolchain/check/testdata/pointer/fail_type_mismatch.carbon index 0abdc9002129..30f3d4b1b381 100644 --- a/toolchain/check/testdata/pointer/fail_type_mismatch.carbon +++ b/toolchain/check/testdata/pointer/fail_type_mismatch.carbon @@ -84,6 +84,6 @@ fn ConstMismatch(p: const {}*) -> const ({}*) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %p.ref: %ptr.bf9 = name_ref p, %p // CHECK:STDOUT: %.loc23: %const.987 = converted %p.ref, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/pointer/nested_const.carbon b/toolchain/check/testdata/pointer/nested_const.carbon index 0bbbede449d8..9579f495ca36 100644 --- a/toolchain/check/testdata/pointer/nested_const.carbon +++ b/toolchain/check/testdata/pointer/nested_const.carbon @@ -111,6 +111,6 @@ fn F(p: const (const (const i32*)*)) -> const i32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @const.as.Copy.impl.Op(constants.%Copy.facet.de4) [concrete = constants.%const.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc17_10.2: = bound_method %.loc17_10.2, %specific_fn // CHECK:STDOUT: %const.as.Copy.impl.Op.call: init %const.20a = call %bound_method.loc17_10.2(%.loc17_10.2) -// CHECK:STDOUT: return %const.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %const.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/pointer/types.carbon b/toolchain/check/testdata/pointer/types.carbon index 0dec26e3a652..27588c24b677 100644 --- a/toolchain/check/testdata/pointer/types.carbon +++ b/toolchain/check/testdata/pointer/types.carbon @@ -129,7 +129,7 @@ fn ConstPtr(p: const i32*) -> (const i32)* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%i32) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.101] // CHECK:STDOUT: %bound_method.loc16_10.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.235 = call %bound_method.loc16_10.2(%p.ref) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @ConstPtr(%p.param: %ptr.36b) -> %ptr.36b { @@ -140,6 +140,6 @@ fn ConstPtr(p: const i32*) -> (const i32)* { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @ptr.as.Copy.impl.Op(constants.%const.20a) [concrete = constants.%ptr.as.Copy.impl.Op.specific_fn.bcd] // CHECK:STDOUT: %bound_method.loc20_10.2: = bound_method %p.ref, %specific_fn // CHECK:STDOUT: %ptr.as.Copy.impl.Op.call: init %ptr.36b = call %bound_method.loc20_10.2(%p.ref) -// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %ptr.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/primitives/import_symbolic.carbon b/toolchain/check/testdata/primitives/import_symbolic.carbon index 448dfcb5d952..f1d4166d7871 100644 --- a/toolchain/check/testdata/primitives/import_symbolic.carbon +++ b/toolchain/check/testdata/primitives/import_symbolic.carbon @@ -239,7 +239,7 @@ fn F() -> u32 { // CHECK:STDOUT: %impl.elem0.loc7_18.2: %.56b = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %impl.elem0.loc7_18.1, %impl.elem0.loc7_18.2 [concrete = constants.%bool.as.Copy.impl.Op.bound] // CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%false] -// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %bool.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_char.carbon @@ -288,7 +288,7 @@ fn F() -> u32 { // CHECK:STDOUT: %impl.elem0.loc7_18.2: %.11f = impl_witness_access constants.%Copy.impl_witness.bd9, element0 [concrete = constants.%char.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %impl.elem0.loc7_18.1, %impl.elem0.loc7_18.2 [concrete = constants.%char.as.Copy.impl.Op.bound] // CHECK:STDOUT: %char.as.Copy.impl.Op.call: init %char = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%int_97] -// CHECK:STDOUT: return %char.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %char.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_char_literal.carbon @@ -336,7 +336,7 @@ fn F() -> u32 { // CHECK:STDOUT: %impl.elem0.loc7_18.2: %.0d7 = impl_witness_access constants.%Copy.impl_witness.100, element0 [concrete = constants.%Core.CharLiteral.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %impl.elem0.loc7_18.1, %impl.elem0.loc7_18.2 [concrete = constants.%Core.CharLiteral.as.Copy.impl.Op.bound] // CHECK:STDOUT: %Core.CharLiteral.as.Copy.impl.Op.call: init Core.CharLiteral = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%.54f] -// CHECK:STDOUT: return %Core.CharLiteral.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Core.CharLiteral.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_float.carbon @@ -393,7 +393,7 @@ fn F() -> u32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc7_18.2, @Float.as.Copy.impl.Op(constants.%int_64) [concrete = constants.%Float.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_18.2: = bound_method %impl.elem0.loc7_18.1, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Float.as.Copy.impl.Op.call: init %f64.d77 = call %bound_method.loc7_18.2(%impl.elem0.loc7_18.1) [concrete = constants.%float] -// CHECK:STDOUT: return %Float.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Float.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_float_literal.carbon @@ -441,7 +441,7 @@ fn F() -> u32 { // CHECK:STDOUT: %impl.elem0.loc7_18.2: %.f37 = impl_witness_access constants.%Copy.impl_witness.ba9, element0 [concrete = constants.%Core.FloatLiteral.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %impl.elem0.loc7_18.1, %impl.elem0.loc7_18.2 [concrete = constants.%Core.FloatLiteral.as.Copy.impl.Op.bound] // CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op.call: init Core.FloatLiteral = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%float.3fedf4.2] -// CHECK:STDOUT: return %Core.FloatLiteral.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Core.FloatLiteral.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_int.carbon @@ -498,7 +498,7 @@ fn F() -> u32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc7_18.2, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_18.2: = bound_method %impl.elem0.loc7_18.1, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_18.2(%impl.elem0.loc7_18.1) [concrete = constants.%int_8] -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_int_literal.carbon @@ -546,7 +546,7 @@ fn F() -> u32 { // CHECK:STDOUT: %impl.elem0.loc7_18.2: %.6b5 = impl_witness_access constants.%Copy.impl_witness.98e, element0 [concrete = constants.%Core.IntLiteral.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %impl.elem0.loc7_18.1, %impl.elem0.loc7_18.2 [concrete = constants.%Core.IntLiteral.as.Copy.impl.Op.bound] // CHECK:STDOUT: %Core.IntLiteral.as.Copy.impl.Op.call: init Core.IntLiteral = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%int_7] -// CHECK:STDOUT: return %Core.IntLiteral.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Core.IntLiteral.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- unsigned_uint.carbon @@ -603,6 +603,6 @@ fn F() -> u32 { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc7_18.2, @UInt.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%UInt.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_18.2: = bound_method %impl.elem0.loc7_18.1, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %UInt.as.Copy.impl.Op.call: init %u32 = call %bound_method.loc7_18.2(%impl.elem0.loc7_18.1) [concrete = constants.%int_8] -// CHECK:STDOUT: return %UInt.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %UInt.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/code_after_return_value.carbon b/toolchain/check/testdata/return/code_after_return_value.carbon index d170ccce4667..d4d0aaf878e3 100644 --- a/toolchain/check/testdata/return/code_after_return_value.carbon +++ b/toolchain/check/testdata/return/code_after_return_value.carbon @@ -111,6 +111,6 @@ fn F(b: bool) -> i32 { // CHECK:STDOUT: %bound_method.loc16_11.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.d2e] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc16_11.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc16: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc16 to %return +// CHECK:STDOUT: return %.loc16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/fail_call_in_type.carbon b/toolchain/check/testdata/return/fail_call_in_type.carbon index bc188c785aad..c8fd06076c17 100644 --- a/toolchain/check/testdata/return/fail_call_in_type.carbon +++ b/toolchain/check/testdata/return/fail_call_in_type.carbon @@ -88,7 +88,7 @@ fn Six() -> ReturnType() { return 6; } // CHECK:STDOUT: %impl.elem0: %.436 = impl_witness_access constants.%Copy.impl_witness.b47, element0 [concrete = constants.%type.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %i32, %impl.elem0 [concrete = constants.%type.as.Copy.impl.Op.bound] // CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method(%i32) [concrete = constants.%i32] -// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %type.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Six() { diff --git a/toolchain/check/testdata/return/fail_return_with_returned_var.carbon b/toolchain/check/testdata/return/fail_return_with_returned_var.carbon index 2d195acdc6e1..5e5160ef7dbb 100644 --- a/toolchain/check/testdata/return/fail_return_with_returned_var.carbon +++ b/toolchain/check/testdata/return/fail_return_with_returned_var.carbon @@ -194,7 +194,7 @@ fn G() -> C { // CHECK:STDOUT: %bound_method.loc29_38.2: = bound_method %int_1, %specific_fn.loc29_38.1 [concrete = constants.%bound_method.38b] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc29_38.1: init %i32 = call %bound_method.loc29_38.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc29_38.2: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc29_38.1 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc29_38.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc29_38.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc29_38.4: init %i32 = initialize_from %.loc29_38.2 to %.loc29_38.3 [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %impl.elem0.loc29_38.2: %.863 = impl_witness_access constants.%ImplicitAs.impl_witness.6bc, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.0b5] // CHECK:STDOUT: %bound_method.loc29_38.3: = bound_method %int_2, %impl.elem0.loc29_38.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.4e5] @@ -202,13 +202,13 @@ fn G() -> C { // CHECK:STDOUT: %bound_method.loc29_38.4: = bound_method %int_2, %specific_fn.loc29_38.2 [concrete = constants.%bound_method.646] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc29_38.2: init %i32 = call %bound_method.loc29_38.4(%int_2) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc29_38.5: init %i32 = converted %int_2, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc29_38.2 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc29_38.6: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc29_38.6: ref %i32 = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc29_38.7: init %i32 = initialize_from %.loc29_38.5 to %.loc29_38.6 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc29_38.8: init %C = class_init (%.loc29_38.4, %.loc29_38.7), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc29_38.8: init %C = class_init (%.loc29_38.4, %.loc29_38.7), %return.param [concrete = constants.%C.val] // CHECK:STDOUT: %.loc29_12: init %C = converted %.loc29_38.1, %.loc29_38.8 [concrete = constants.%C.val] -// CHECK:STDOUT: assign %return, %.loc29_12 +// CHECK:STDOUT: assign %return.param, %.loc29_12 // CHECK:STDOUT: %C.ref.loc29: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %c: ref %C = ref_binding c, %return +// CHECK:STDOUT: %c: ref %C = ref_binding c, %return.param // CHECK:STDOUT: %c.ref: ref %C = name_ref c, %c // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/return/fail_returned_var_shadow.carbon b/toolchain/check/testdata/return/fail_returned_var_shadow.carbon index 745c2a1e74c5..39a21b0e6ba1 100644 --- a/toolchain/check/testdata/return/fail_returned_var_shadow.carbon +++ b/toolchain/check/testdata/return/fail_returned_var_shadow.carbon @@ -185,7 +185,7 @@ fn DifferentScopes() -> i32 { // CHECK:STDOUT: %DestroyOp.call.loc25: init %empty_tuple.type = call %DestroyOp.bound.loc25(%w.var) // CHECK:STDOUT: %DestroyOp.bound.loc17: = bound_method %v.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc17: init %empty_tuple.type = call %DestroyOp.bound.loc17(%v.var) -// CHECK:STDOUT: return %.loc27 to %return +// CHECK:STDOUT: return %.loc27 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %i32) = "no_op"; @@ -253,6 +253,6 @@ fn DifferentScopes() -> i32 { // CHECK:STDOUT: %DestroyOp.call.loc41: init %empty_tuple.type = call %DestroyOp.bound.loc41(%w.var) // CHECK:STDOUT: %DestroyOp.bound.loc32: = bound_method %v.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc32: init %empty_tuple.type = call %DestroyOp.bound.loc32(%v.var) -// CHECK:STDOUT: return %.loc44 to %return +// CHECK:STDOUT: return %.loc44 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/fail_type_mismatch.carbon b/toolchain/check/testdata/return/fail_type_mismatch.carbon index d29f9fe693b2..ced7edaef792 100644 --- a/toolchain/check/testdata/return/fail_type_mismatch.carbon +++ b/toolchain/check/testdata/return/fail_type_mismatch.carbon @@ -72,6 +72,6 @@ fn Main() -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float] // CHECK:STDOUT: %.loc23: %i32 = converted %float, [concrete = ] -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: return to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/import_convert_function.carbon b/toolchain/check/testdata/return/import_convert_function.carbon index aaae6e3ff5eb..f8dd85641030 100644 --- a/toolchain/check/testdata/return/import_convert_function.carbon +++ b/toolchain/check/testdata/return/import_convert_function.carbon @@ -342,7 +342,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc8_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc8_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.4f5 = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.c43.%C [concrete = constants.%C.4f5] // CHECK:STDOUT: %self: %C.4f5 = value_binding self, %self.param @@ -367,7 +367,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc9_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc9_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.95b = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.7c3.%C [concrete = constants.%C.95b] // CHECK:STDOUT: %self: %C.95b = value_binding self, %self.param @@ -392,7 +392,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc10_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc10_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.a93 = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.fa3.%C [concrete = constants.%C.a93] // CHECK:STDOUT: %self: %C.a93 = value_binding self, %self.param @@ -417,7 +417,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc11_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc11_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.1d7 = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.158.%C [concrete = constants.%C.1d7] // CHECK:STDOUT: %self: %C.1d7 = value_binding self, %self.param @@ -442,7 +442,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc12_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc12_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.e40 = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.f64.%C [concrete = constants.%C.e40] // CHECK:STDOUT: %self: %C.e40 = value_binding self, %self.param @@ -467,7 +467,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc13_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc13_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.3f1 = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.d86.%C [concrete = constants.%C.3f1] // CHECK:STDOUT: %self: %C.3f1 = value_binding self, %self.param @@ -492,7 +492,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc14_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc14_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.0fa = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.f13.%C [concrete = constants.%C.0fa] // CHECK:STDOUT: %self: %C.0fa = value_binding self, %self.param @@ -517,7 +517,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %return.param_patt: %pattern_type.c49 = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %D.ref: type = name_ref D, file.%D.decl [concrete = constants.%D] -// CHECK:STDOUT: %.loc15_63: form = init_form %D.ref, call_param1 [concrete = constants.%.382] +// CHECK:STDOUT: %.loc15_63.2: form = init_form %D.ref, call_param1 [concrete = constants.%.382] // CHECK:STDOUT: %self.param: %C.2b7 = value_param call_param0 // CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.ImplicitAs.impl.83b.%C [concrete = constants.%C.2b7] // CHECK:STDOUT: %self: %C.2b7 = value_binding self, %self.param @@ -575,7 +575,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %bound_method.loc6_40.2: = bound_method %int_0.loc6_31, %specific_fn.loc6_40.1 [concrete = constants.%bound_method.d2e] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_40.1: init %i32 = call %bound_method.loc6_40.2(%int_0.loc6_31) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc6_40.2: init %i32 = converted %int_0.loc6_31, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_40.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc6_40.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc6_40.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc6_40.4: init %i32 = initialize_from %.loc6_40.2 to %.loc6_40.3 [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %impl.elem0.loc6_40.2: %.863 = impl_witness_access constants.%ImplicitAs.impl_witness.6bc, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.0b5] // CHECK:STDOUT: %bound_method.loc6_40.3: = bound_method %int_0.loc6_39, %impl.elem0.loc6_40.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.897] @@ -583,75 +583,75 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %bound_method.loc6_40.4: = bound_method %int_0.loc6_39, %specific_fn.loc6_40.2 [concrete = constants.%bound_method.d2e] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_40.2: init %i32 = call %bound_method.loc6_40.4(%int_0.loc6_39) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc6_40.5: init %i32 = converted %int_0.loc6_39, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6_40.2 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc6_40.6: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc6_40.6: ref %i32 = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc6_40.7: init %i32 = initialize_from %.loc6_40.5 to %.loc6_40.6 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc6_40.8: init %D = class_init (%.loc6_40.4, %.loc6_40.7), %return [concrete = constants.%D.val] +// CHECK:STDOUT: %.loc6_40.8: init %D = class_init (%.loc6_40.4, %.loc6_40.7), %return.param [concrete = constants.%D.val] // CHECK:STDOUT: %.loc6_41: init %D = converted %.loc6_40.1, %.loc6_40.8 [concrete = constants.%D.val] -// CHECK:STDOUT: return %.loc6_41 to %return +// CHECK:STDOUT: return %.loc6_41 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc8(%self.param: %C.4f5) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc8_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc8_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc8_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc8_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc9(%self.param: %C.95b) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc9_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc9_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc9_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc9_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc10(%self.param: %C.a93) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc10_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc10_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc10_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc10_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc11(%self.param: %C.1d7) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc11_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc11_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc11_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc11_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc12(%self.param: %C.e40) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc12_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc12_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc12_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc12_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc13(%self.param: %C.3f1) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc13_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc13_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc13_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc13_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc14(%self.param: %C.0fa) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc14_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc14_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc14_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc14_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.loc15(%self.param: %C.2b7) -> %return.param: %D { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, file.%Make.decl [concrete = constants.%Make] -// CHECK:STDOUT: %.loc15_60: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc15_60 -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: %.loc15_63.1: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc15_63.1 +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C(constants.%N.5de) { @@ -940,7 +940,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: } { // CHECK:STDOUT: %P.ref.loc6: = name_ref P, imports.%P [concrete = imports.%P] // CHECK:STDOUT: %D.ref: type = name_ref D, imports.%P.D [concrete = constants.%D] -// CHECK:STDOUT: %.loc6_19: form = init_form %D.ref, call_param1 [concrete = constants.%.6c0] +// CHECK:STDOUT: %.loc6_19.10: form = init_form %D.ref, call_param1 [concrete = constants.%.6c0] // CHECK:STDOUT: %n.param: %i32 = value_param call_param0 // CHECK:STDOUT: %.loc6_10: type = splice_block %i32 [concrete = constants.%i32] { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] @@ -1038,13 +1038,13 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc7_26.1: ref %C.b00 = converted %.loc7_24.1, %.loc7_24.4 // CHECK:STDOUT: %impl.elem0.loc7_35: %.094 = impl_witness_access constants.%ImplicitAs.impl_witness.01b, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.78d] // CHECK:STDOUT: %bound_method.loc7_35: = bound_method %.loc7_26.1, %impl.elem0.loc7_35 -// CHECK:STDOUT: %.loc6_15.1: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.1: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc7_26.2: %C.b00 = acquire_value %.loc7_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc7: init %D = call %bound_method.loc7_35(%.loc7_26.2) to %.loc6_15.1 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc7: init %D = call %bound_method.loc7_35(%.loc7_26.2) to %.loc6_19.1 // CHECK:STDOUT: %.loc7_35: init %D = converted %.loc7_26.1, %C.as.ImplicitAs.impl.Convert.call.loc7 // CHECK:STDOUT: %DestroyOp.bound.loc7_24.1: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.1(%.loc7_24.4) -// CHECK:STDOUT: return %.loc7_35 to %return +// CHECK:STDOUT: return %.loc7_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc7: // CHECK:STDOUT: %false.loc8: bool = bool_literal false [concrete = constants.%false] @@ -1069,15 +1069,15 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc8_26.1: ref %C.674 = converted %.loc8_24.1, %.loc8_24.4 // CHECK:STDOUT: %impl.elem0.loc8_35: %.deb = impl_witness_access constants.%ImplicitAs.impl_witness.638, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.b44] // CHECK:STDOUT: %bound_method.loc8_35: = bound_method %.loc8_26.1, %impl.elem0.loc8_35 -// CHECK:STDOUT: %.loc6_15.2: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.2: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc8_26.2: %C.674 = acquire_value %.loc8_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc8: init %D = call %bound_method.loc8_35(%.loc8_26.2) to %.loc6_15.2 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc8: init %D = call %bound_method.loc8_35(%.loc8_26.2) to %.loc6_19.2 // CHECK:STDOUT: %.loc8_35: init %D = converted %.loc8_26.1, %C.as.ImplicitAs.impl.Convert.call.loc8 // CHECK:STDOUT: %DestroyOp.bound.loc8_24.1: = bound_method %.loc8_24.4, constants.%DestroyOp.b0ebf8.2 // CHECK:STDOUT: %DestroyOp.call.loc8_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.1(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.2: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.2: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.2(%.loc7_24.4) -// CHECK:STDOUT: return %.loc8_35 to %return +// CHECK:STDOUT: return %.loc8_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc8: // CHECK:STDOUT: %false.loc9: bool = bool_literal false [concrete = constants.%false] @@ -1102,9 +1102,9 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc9_26.1: ref %C.681 = converted %.loc9_24.1, %.loc9_24.4 // CHECK:STDOUT: %impl.elem0.loc9_35: %.8f9 = impl_witness_access constants.%ImplicitAs.impl_witness.a8d, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.dd6] // CHECK:STDOUT: %bound_method.loc9_35: = bound_method %.loc9_26.1, %impl.elem0.loc9_35 -// CHECK:STDOUT: %.loc6_15.3: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.3: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc9_26.2: %C.681 = acquire_value %.loc9_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc9: init %D = call %bound_method.loc9_35(%.loc9_26.2) to %.loc6_15.3 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc9: init %D = call %bound_method.loc9_35(%.loc9_26.2) to %.loc6_19.3 // CHECK:STDOUT: %.loc9_35: init %D = converted %.loc9_26.1, %C.as.ImplicitAs.impl.Convert.call.loc9 // CHECK:STDOUT: %DestroyOp.bound.loc9_24.1: = bound_method %.loc9_24.4, constants.%DestroyOp.b0ebf8.3 // CHECK:STDOUT: %DestroyOp.call.loc9_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc9_24.1(%.loc9_24.4) @@ -1112,7 +1112,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.2: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.2(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.3: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.3: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.3(%.loc7_24.4) -// CHECK:STDOUT: return %.loc9_35 to %return +// CHECK:STDOUT: return %.loc9_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc9: // CHECK:STDOUT: %false.loc10: bool = bool_literal false [concrete = constants.%false] @@ -1137,9 +1137,9 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc10_26.1: ref %C.7ac = converted %.loc10_24.1, %.loc10_24.4 // CHECK:STDOUT: %impl.elem0.loc10_35: %.286 = impl_witness_access constants.%ImplicitAs.impl_witness.56b, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.d1c] // CHECK:STDOUT: %bound_method.loc10_35: = bound_method %.loc10_26.1, %impl.elem0.loc10_35 -// CHECK:STDOUT: %.loc6_15.4: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.4: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc10_26.2: %C.7ac = acquire_value %.loc10_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc10: init %D = call %bound_method.loc10_35(%.loc10_26.2) to %.loc6_15.4 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc10: init %D = call %bound_method.loc10_35(%.loc10_26.2) to %.loc6_19.4 // CHECK:STDOUT: %.loc10_35: init %D = converted %.loc10_26.1, %C.as.ImplicitAs.impl.Convert.call.loc10 // CHECK:STDOUT: %DestroyOp.bound.loc10_24.1: = bound_method %.loc10_24.4, constants.%DestroyOp.b0ebf8.4 // CHECK:STDOUT: %DestroyOp.call.loc10_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc10_24.1(%.loc10_24.4) @@ -1149,7 +1149,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.3: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.3(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.4: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.4: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.4(%.loc7_24.4) -// CHECK:STDOUT: return %.loc10_35 to %return +// CHECK:STDOUT: return %.loc10_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc10: // CHECK:STDOUT: %false.loc11: bool = bool_literal false [concrete = constants.%false] @@ -1174,9 +1174,9 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc11_26.1: ref %C.89d = converted %.loc11_24.1, %.loc11_24.4 // CHECK:STDOUT: %impl.elem0.loc11_35: %.3c4 = impl_witness_access constants.%ImplicitAs.impl_witness.e05, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.db5] // CHECK:STDOUT: %bound_method.loc11_35: = bound_method %.loc11_26.1, %impl.elem0.loc11_35 -// CHECK:STDOUT: %.loc6_15.5: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.5: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc11_26.2: %C.89d = acquire_value %.loc11_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc11: init %D = call %bound_method.loc11_35(%.loc11_26.2) to %.loc6_15.5 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc11: init %D = call %bound_method.loc11_35(%.loc11_26.2) to %.loc6_19.5 // CHECK:STDOUT: %.loc11_35: init %D = converted %.loc11_26.1, %C.as.ImplicitAs.impl.Convert.call.loc11 // CHECK:STDOUT: %DestroyOp.bound.loc11_24.1: = bound_method %.loc11_24.4, constants.%DestroyOp.b0ebf8.5 // CHECK:STDOUT: %DestroyOp.call.loc11_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc11_24.1(%.loc11_24.4) @@ -1188,7 +1188,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.4: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.4(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.5: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.5: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.5(%.loc7_24.4) -// CHECK:STDOUT: return %.loc11_35 to %return +// CHECK:STDOUT: return %.loc11_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc11: // CHECK:STDOUT: %false.loc12: bool = bool_literal false [concrete = constants.%false] @@ -1213,9 +1213,9 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc12_26.1: ref %C.f0a = converted %.loc12_24.1, %.loc12_24.4 // CHECK:STDOUT: %impl.elem0.loc12_35: %.4d7 = impl_witness_access constants.%ImplicitAs.impl_witness.262, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.a63] // CHECK:STDOUT: %bound_method.loc12_35: = bound_method %.loc12_26.1, %impl.elem0.loc12_35 -// CHECK:STDOUT: %.loc6_15.6: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.6: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc12_26.2: %C.f0a = acquire_value %.loc12_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc12: init %D = call %bound_method.loc12_35(%.loc12_26.2) to %.loc6_15.6 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc12: init %D = call %bound_method.loc12_35(%.loc12_26.2) to %.loc6_19.6 // CHECK:STDOUT: %.loc12_35: init %D = converted %.loc12_26.1, %C.as.ImplicitAs.impl.Convert.call.loc12 // CHECK:STDOUT: %DestroyOp.bound.loc12_24.1: = bound_method %.loc12_24.4, constants.%DestroyOp.b0ebf8.6 // CHECK:STDOUT: %DestroyOp.call.loc12_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc12_24.1(%.loc12_24.4) @@ -1229,7 +1229,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.5: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.5(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.6: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.6: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.6(%.loc7_24.4) -// CHECK:STDOUT: return %.loc12_35 to %return +// CHECK:STDOUT: return %.loc12_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc12: // CHECK:STDOUT: %false.loc13: bool = bool_literal false [concrete = constants.%false] @@ -1254,9 +1254,9 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc13_26.1: ref %C.c60 = converted %.loc13_24.1, %.loc13_24.4 // CHECK:STDOUT: %impl.elem0.loc13_35: %.3aa = impl_witness_access constants.%ImplicitAs.impl_witness.7d1, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.e2f] // CHECK:STDOUT: %bound_method.loc13_35: = bound_method %.loc13_26.1, %impl.elem0.loc13_35 -// CHECK:STDOUT: %.loc6_15.7: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.7: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc13_26.2: %C.c60 = acquire_value %.loc13_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc13: init %D = call %bound_method.loc13_35(%.loc13_26.2) to %.loc6_15.7 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc13: init %D = call %bound_method.loc13_35(%.loc13_26.2) to %.loc6_19.7 // CHECK:STDOUT: %.loc13_35: init %D = converted %.loc13_26.1, %C.as.ImplicitAs.impl.Convert.call.loc13 // CHECK:STDOUT: %DestroyOp.bound.loc13_24.1: = bound_method %.loc13_24.4, constants.%DestroyOp.b0ebf8.7 // CHECK:STDOUT: %DestroyOp.call.loc13_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc13_24.1(%.loc13_24.4) @@ -1272,7 +1272,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.6: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.6(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.7: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.7: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.7(%.loc7_24.4) -// CHECK:STDOUT: return %.loc13_35 to %return +// CHECK:STDOUT: return %.loc13_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc13: // CHECK:STDOUT: %false.loc14: bool = bool_literal false [concrete = constants.%false] @@ -1297,9 +1297,9 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %.loc14_26.1: ref %C.304 = converted %.loc14_24.1, %.loc14_24.4 // CHECK:STDOUT: %impl.elem0.loc14_35: %.dad = impl_witness_access constants.%ImplicitAs.impl_witness.356, element0 [concrete = constants.%C.as.ImplicitAs.impl.Convert.5ea] // CHECK:STDOUT: %bound_method.loc14_35: = bound_method %.loc14_26.1, %impl.elem0.loc14_35 -// CHECK:STDOUT: %.loc6_15.8: ref %D = splice_block %return {} +// CHECK:STDOUT: %.loc6_19.8: ref %D = splice_block %return.param {} // CHECK:STDOUT: %.loc14_26.2: %C.304 = acquire_value %.loc14_26.1 -// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc14: init %D = call %bound_method.loc14_35(%.loc14_26.2) to %.loc6_15.8 +// CHECK:STDOUT: %C.as.ImplicitAs.impl.Convert.call.loc14: init %D = call %bound_method.loc14_35(%.loc14_26.2) to %.loc6_19.8 // CHECK:STDOUT: %.loc14_35: init %D = converted %.loc14_26.1, %C.as.ImplicitAs.impl.Convert.call.loc14 // CHECK:STDOUT: %DestroyOp.bound.loc14_24.1: = bound_method %.loc14_24.4, constants.%DestroyOp.b0ebf8.8 // CHECK:STDOUT: %DestroyOp.call.loc14_24.1: init %empty_tuple.type = call %DestroyOp.bound.loc14_24.1(%.loc14_24.4) @@ -1317,13 +1317,13 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.7: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.7(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.8: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.8: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.8(%.loc7_24.4) -// CHECK:STDOUT: return %.loc14_35 to %return +// CHECK:STDOUT: return %.loc14_35 to %return.param // CHECK:STDOUT: // CHECK:STDOUT: !if.else.loc14: // CHECK:STDOUT: %P.ref.loc15: = name_ref P, imports.%P [concrete = imports.%P] // CHECK:STDOUT: %Make.ref: %Make.type = name_ref Make, imports.%P.Make [concrete = constants.%Make] -// CHECK:STDOUT: %.loc6_15.9: ref %D = splice_block %return {} -// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc6_15.9 +// CHECK:STDOUT: %.loc6_19.9: ref %D = splice_block %return.param {} +// CHECK:STDOUT: %Make.call: init %D = call %Make.ref() to %.loc6_19.9 // CHECK:STDOUT: %DestroyOp.bound.loc14_24.2: = bound_method %.loc14_24.4, constants.%DestroyOp.b0ebf8.8 // CHECK:STDOUT: %DestroyOp.call.loc14_24.2: init %empty_tuple.type = call %DestroyOp.bound.loc14_24.2(%.loc14_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc13_24.3: = bound_method %.loc13_24.4, constants.%DestroyOp.b0ebf8.7 @@ -1340,7 +1340,7 @@ fn F0(n: i32) -> P.D { // CHECK:STDOUT: %DestroyOp.call.loc8_24.8: init %empty_tuple.type = call %DestroyOp.bound.loc8_24.8(%.loc8_24.4) // CHECK:STDOUT: %DestroyOp.bound.loc7_24.9: = bound_method %.loc7_24.4, constants.%DestroyOp.b0ebf8.1 // CHECK:STDOUT: %DestroyOp.call.loc7_24.9: init %empty_tuple.type = call %DestroyOp.bound.loc7_24.9(%.loc7_24.4) -// CHECK:STDOUT: return %Make.call to %return +// CHECK:STDOUT: return %Make.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @C.as.ImplicitAs.impl.Convert.1 [from "library.carbon"]; diff --git a/toolchain/check/testdata/return/returned_var.carbon b/toolchain/check/testdata/return/returned_var.carbon index 4c0c2e48d536..0cb7ea0c98db 100644 --- a/toolchain/check/testdata/return/returned_var.carbon +++ b/toolchain/check/testdata/return/returned_var.carbon @@ -156,7 +156,7 @@ fn G() -> i32 { // CHECK:STDOUT: %bound_method.loc21_43.2: = bound_method %int_1, %specific_fn.loc21_43.1 [concrete = constants.%bound_method.38b] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc21_43.1: init %i32 = call %bound_method.loc21_43.2(%int_1) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc21_43.2: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc21_43.1 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc21_43.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc21_43.3: ref %i32 = class_element_access %return.param, element0 // CHECK:STDOUT: %.loc21_43.4: init %i32 = initialize_from %.loc21_43.2 to %.loc21_43.3 [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %impl.elem0.loc21_43.2: %.863 = impl_witness_access constants.%ImplicitAs.impl_witness.6bc, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.0b5] // CHECK:STDOUT: %bound_method.loc21_43.3: = bound_method %int_2, %impl.elem0.loc21_43.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.4e5] @@ -164,14 +164,14 @@ fn G() -> i32 { // CHECK:STDOUT: %bound_method.loc21_43.4: = bound_method %int_2, %specific_fn.loc21_43.2 [concrete = constants.%bound_method.646] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc21_43.2: init %i32 = call %bound_method.loc21_43.4(%int_2) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc21_43.5: init %i32 = converted %int_2, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc21_43.2 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc21_43.6: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc21_43.6: ref %i32 = class_element_access %return.param, element1 // CHECK:STDOUT: %.loc21_43.7: init %i32 = initialize_from %.loc21_43.5 to %.loc21_43.6 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc21_43.8: init %C = class_init (%.loc21_43.4, %.loc21_43.7), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc21_43.8: init %C = class_init (%.loc21_43.4, %.loc21_43.7), %return.param [concrete = constants.%C.val] // CHECK:STDOUT: %.loc21_12: init %C = converted %.loc21_43.1, %.loc21_43.8 [concrete = constants.%C.val] -// CHECK:STDOUT: assign %return, %.loc21_12 +// CHECK:STDOUT: assign %return.param, %.loc21_12 // CHECK:STDOUT: %C.ref.loc21: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %result: ref %C = ref_binding result, %return -// CHECK:STDOUT: return %result to %return +// CHECK:STDOUT: %result: ref %C = ref_binding result, %return.param +// CHECK:STDOUT: return %result to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @G() -> %i32 { diff --git a/toolchain/check/testdata/return/returned_var_scope.carbon b/toolchain/check/testdata/return/returned_var_scope.carbon index fb7c4ef19529..a444e0d16305 100644 --- a/toolchain/check/testdata/return/returned_var_scope.carbon +++ b/toolchain/check/testdata/return/returned_var_scope.carbon @@ -194,7 +194,7 @@ fn EnclosingButAfter(b: bool) -> i32 { // CHECK:STDOUT: %DestroyOp.call.loc20: init %empty_tuple.type = call %DestroyOp.bound.loc20(%w.var) // CHECK:STDOUT: %DestroyOp.bound.loc17: = bound_method %v.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call.loc17: init %empty_tuple.type = call %DestroyOp.bound.loc17(%v.var) -// CHECK:STDOUT: return %.loc22 to %return +// CHECK:STDOUT: return %.loc22 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %i32) = "no_op"; diff --git a/toolchain/check/testdata/return/struct.carbon b/toolchain/check/testdata/return/struct.carbon index ea439bc3de00..205a04b19780 100644 --- a/toolchain/check/testdata/return/struct.carbon +++ b/toolchain/check/testdata/return/struct.carbon @@ -92,8 +92,8 @@ fn Main() -> {.a: i32} { // CHECK:STDOUT: %bound_method.loc16_17.2: = bound_method %int_3, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc16_17.2(%int_3) [concrete = constants.%int_3.822] // CHECK:STDOUT: %.loc16_17.2: init %i32 = converted %int_3, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_3.822] -// CHECK:STDOUT: %.loc16_17.3: init %struct_type.a.ba9 = struct_init (%.loc16_17.2) to %return [concrete = constants.%struct.384] +// CHECK:STDOUT: %.loc16_17.3: init %struct_type.a.ba9 = struct_init (%.loc16_17.2) to %return.param [concrete = constants.%struct.384] // CHECK:STDOUT: %.loc16_18: init %struct_type.a.ba9 = converted %.loc16_17.1, %.loc16_17.3 [concrete = constants.%struct.384] -// CHECK:STDOUT: return %.loc16_18 to %return +// CHECK:STDOUT: return %.loc16_18 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/tuple.carbon b/toolchain/check/testdata/return/tuple.carbon index d01641f5bbe6..364523c0c655 100644 --- a/toolchain/check/testdata/return/tuple.carbon +++ b/toolchain/check/testdata/return/tuple.carbon @@ -103,7 +103,7 @@ fn Main() -> (i32, i32) { // CHECK:STDOUT: %bound_method.loc17_17.2: = bound_method %int_15, %specific_fn.loc17_17.1 [concrete = constants.%bound_method.9f9] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc17_17.1: init %i32 = call %bound_method.loc17_17.2(%int_15) [concrete = constants.%int_15.7f7] // CHECK:STDOUT: %.loc17_17.2: init %i32 = converted %int_15, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc17_17.1 [concrete = constants.%int_15.7f7] -// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return, element0 +// CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return.param, element0 // CHECK:STDOUT: %.loc17_17.3: init %i32 = initialize_from %.loc17_17.2 to %tuple.elem0 [concrete = constants.%int_15.7f7] // CHECK:STDOUT: %impl.elem0.loc17_17.2: %.863 = impl_witness_access constants.%ImplicitAs.impl_witness.6bc, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.0b5] // CHECK:STDOUT: %bound_method.loc17_17.3: = bound_method %int_35, %impl.elem0.loc17_17.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.4c2] @@ -111,10 +111,10 @@ fn Main() -> (i32, i32) { // CHECK:STDOUT: %bound_method.loc17_17.4: = bound_method %int_35, %specific_fn.loc17_17.2 [concrete = constants.%bound_method.d89] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc17_17.2: init %i32 = call %bound_method.loc17_17.4(%int_35) [concrete = constants.%int_35.c78] // CHECK:STDOUT: %.loc17_17.4: init %i32 = converted %int_35, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc17_17.2 [concrete = constants.%int_35.c78] -// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return, element1 +// CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return.param, element1 // CHECK:STDOUT: %.loc17_17.5: init %i32 = initialize_from %.loc17_17.4 to %tuple.elem1 [concrete = constants.%int_35.c78] -// CHECK:STDOUT: %.loc17_17.6: init %tuple.type.d07 = tuple_init (%.loc17_17.3, %.loc17_17.5) to %return [concrete = constants.%tuple.851] +// CHECK:STDOUT: %.loc17_17.6: init %tuple.type.d07 = tuple_init (%.loc17_17.3, %.loc17_17.5) to %return.param [concrete = constants.%tuple.851] // CHECK:STDOUT: %.loc17_18: init %tuple.type.d07 = converted %.loc17_17.1, %.loc17_17.6 [concrete = constants.%tuple.851] -// CHECK:STDOUT: return %.loc17_18 to %return +// CHECK:STDOUT: return %.loc17_18 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/value.carbon b/toolchain/check/testdata/return/value.carbon index ca4860ba26a9..deeb2df7bd02 100644 --- a/toolchain/check/testdata/return/value.carbon +++ b/toolchain/check/testdata/return/value.carbon @@ -86,6 +86,6 @@ fn Main() -> i32 { // CHECK:STDOUT: %bound_method.loc16_11.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc16_11.2(%int_0) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc16: init %i32 = converted %int_0, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc16 to %return +// CHECK:STDOUT: return %.loc16 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/struct/import.carbon b/toolchain/check/testdata/struct/import.carbon index a982b3cf43ff..9c4eadf3daa7 100644 --- a/toolchain/check/testdata/struct/import.carbon +++ b/toolchain/check/testdata/struct/import.carbon @@ -337,8 +337,8 @@ fn F() -> {.x: i32} { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc7_18.2, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_18.2: = bound_method %.loc7_18.2, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_18.2(%.loc7_18.2) [concrete = constants.%int_1] -// CHECK:STDOUT: %.loc7_18.3: init %struct_type.x = struct_init (%Int.as.Copy.impl.Op.call) to %return [concrete = constants.%struct] +// CHECK:STDOUT: %.loc7_18.3: init %struct_type.x = struct_init (%Int.as.Copy.impl.Op.call) to %return.param [concrete = constants.%struct] // CHECK:STDOUT: %.loc7_22: init %struct_type.x = converted %impl.elem0.loc7_18.1, %.loc7_18.3 [concrete = constants.%struct] -// CHECK:STDOUT: return %.loc7_22 to %return +// CHECK:STDOUT: return %.loc7_22 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/struct/literal_member_access.carbon b/toolchain/check/testdata/struct/literal_member_access.carbon index 77a2551bfecc..790d22dd3a53 100644 --- a/toolchain/check/testdata/struct/literal_member_access.carbon +++ b/toolchain/check/testdata/struct/literal_member_access.carbon @@ -133,7 +133,7 @@ fn F() -> i32 { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc18_38.2(%.loc18_38) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc18_26.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc18_26.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %struct_type.x.y.z) = "no_op"; diff --git a/toolchain/check/testdata/struct/partially_const.carbon b/toolchain/check/testdata/struct/partially_const.carbon index 90c1cb330d1a..fe9536afdc04 100644 --- a/toolchain/check/testdata/struct/partially_const.carbon +++ b/toolchain/check/testdata/struct/partially_const.carbon @@ -120,14 +120,14 @@ fn Make(n: i32) -> {.a: i32, .b: i32, .c: i32} { // CHECK:STDOUT: %bound_method.loc16_33.2: = bound_method %int_0.loc16_16, %specific_fn.loc16_33.1 [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc16_33.1: init %i32 = call %bound_method.loc16_33.2(%int_0.loc16_16) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc16_33.2: init %i32 = converted %int_0.loc16_16, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc16_33.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc16_33.3: ref %i32 = struct_access %return, element0 +// CHECK:STDOUT: %.loc16_33.3: ref %i32 = struct_access %return.param, element0 // CHECK:STDOUT: %.loc16_33.4: init %i32 = initialize_from %.loc16_33.2 to %.loc16_33.3 [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %impl.elem0.loc16_24: %.f79 = impl_witness_access constants.%Copy.impl_witness.f17, element0 [concrete = constants.%Int.as.Copy.impl.Op.664] // CHECK:STDOUT: %bound_method.loc16_24.1: = bound_method %n.ref, %impl.elem0.loc16_24 // CHECK:STDOUT: %specific_fn.loc16_24: = specific_function %impl.elem0.loc16_24, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc16_24.2: = bound_method %n.ref, %specific_fn.loc16_24 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc16_24.2(%n.ref) -// CHECK:STDOUT: %.loc16_33.5: ref %i32 = struct_access %return, element1 +// CHECK:STDOUT: %.loc16_33.5: ref %i32 = struct_access %return.param, element1 // CHECK:STDOUT: %.loc16_33.6: init %i32 = initialize_from %Int.as.Copy.impl.Op.call to %.loc16_33.5 // CHECK:STDOUT: %impl.elem0.loc16_33.2: %.863 = impl_witness_access constants.%ImplicitAs.impl_witness.6bc, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.0b5] // CHECK:STDOUT: %bound_method.loc16_33.3: = bound_method %int_0.loc16_32, %impl.elem0.loc16_33.2 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound] @@ -135,10 +135,10 @@ fn Make(n: i32) -> {.a: i32, .b: i32, .c: i32} { // CHECK:STDOUT: %bound_method.loc16_33.4: = bound_method %int_0.loc16_32, %specific_fn.loc16_33.2 [concrete = constants.%bound_method] // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc16_33.2: init %i32 = call %bound_method.loc16_33.4(%int_0.loc16_32) [concrete = constants.%int_0.6a9] // CHECK:STDOUT: %.loc16_33.7: init %i32 = converted %int_0.loc16_32, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc16_33.2 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc16_33.8: ref %i32 = struct_access %return, element2 +// CHECK:STDOUT: %.loc16_33.8: ref %i32 = struct_access %return.param, element2 // CHECK:STDOUT: %.loc16_33.9: init %i32 = initialize_from %.loc16_33.7 to %.loc16_33.8 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc16_33.10: init %struct_type.a.b.c.0b6 = struct_init (%.loc16_33.4, %.loc16_33.6, %.loc16_33.9) to %return +// CHECK:STDOUT: %.loc16_33.10: init %struct_type.a.b.c.0b6 = struct_init (%.loc16_33.4, %.loc16_33.6, %.loc16_33.9) to %return.param // CHECK:STDOUT: %.loc16_34: init %struct_type.a.b.c.0b6 = converted %.loc16_33.1, %.loc16_33.10 -// CHECK:STDOUT: return %.loc16_34 to %return +// CHECK:STDOUT: return %.loc16_34 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/struct/reorder_fields.carbon b/toolchain/check/testdata/struct/reorder_fields.carbon index a0e1a30c5572..aef074d692c1 100644 --- a/toolchain/check/testdata/struct/reorder_fields.carbon +++ b/toolchain/check/testdata/struct/reorder_fields.carbon @@ -179,7 +179,7 @@ fn F() -> {.a: i32, .b: f64} { // CHECK:STDOUT: %specific_fn.loc21_10.1: = specific_function %impl.elem0.loc21_10.1, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc21_10.2: = bound_method %.loc21_10.1, %specific_fn.loc21_10.1 // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc21_10.2(%.loc21_10.1) -// CHECK:STDOUT: %.loc21_10.2: ref %i32 = struct_access %return, element1 +// CHECK:STDOUT: %.loc21_10.2: ref %i32 = struct_access %return.param, element1 // CHECK:STDOUT: %.loc21_10.3: init %i32 = initialize_from %Int.as.Copy.impl.Op.call to %.loc21_10.2 // CHECK:STDOUT: %.loc21_10.4: %f64.d77 = struct_access %y.ref, element0 // CHECK:STDOUT: %impl.elem0.loc21_10.2: %.c41 = impl_witness_access constants.%Copy.impl_witness.1e3, element0 [concrete = constants.%Float.as.Copy.impl.Op.f05] @@ -187,10 +187,10 @@ fn F() -> {.a: i32, .b: f64} { // CHECK:STDOUT: %specific_fn.loc21_10.2: = specific_function %impl.elem0.loc21_10.2, @Float.as.Copy.impl.Op(constants.%int_64) [concrete = constants.%Float.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc21_10.4: = bound_method %.loc21_10.4, %specific_fn.loc21_10.2 // CHECK:STDOUT: %Float.as.Copy.impl.Op.call: init %f64.d77 = call %bound_method.loc21_10.4(%.loc21_10.4) -// CHECK:STDOUT: %.loc21_10.5: ref %f64.d77 = struct_access %return, element0 +// CHECK:STDOUT: %.loc21_10.5: ref %f64.d77 = struct_access %return.param, element0 // CHECK:STDOUT: %.loc21_10.6: init %f64.d77 = initialize_from %Float.as.Copy.impl.Op.call to %.loc21_10.5 -// CHECK:STDOUT: %.loc21_10.7: init %struct_type.a.b = struct_init (%.loc21_10.3, %.loc21_10.6) to %return +// CHECK:STDOUT: %.loc21_10.7: init %struct_type.a.b = struct_init (%.loc21_10.3, %.loc21_10.6) to %return.param // CHECK:STDOUT: %.loc21_11: init %struct_type.a.b = converted %y.ref, %.loc21_10.7 -// CHECK:STDOUT: return %.loc21_11 to %return +// CHECK:STDOUT: return %.loc21_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/tuple/element_access.carbon b/toolchain/check/testdata/tuple/element_access.carbon index e9309d2cfc40..95839c63c575 100644 --- a/toolchain/check/testdata/tuple/element_access.carbon +++ b/toolchain/check/testdata/tuple/element_access.carbon @@ -474,6 +474,6 @@ var b: i32 = a.({.index = 2}.index); // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_13.2: = bound_method %tuple.elem0, %specific_fn // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_13.2(%tuple.elem0) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/tuple/import.carbon b/toolchain/check/testdata/tuple/import.carbon index 058a40e02e78..a72095dd8063 100644 --- a/toolchain/check/testdata/tuple/import.carbon +++ b/toolchain/check/testdata/tuple/import.carbon @@ -368,8 +368,8 @@ fn F() -> (i32,) { // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc7_18.2, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc7_18.2: = bound_method %tuple.elem0, %specific_fn [concrete = constants.%bound_method] // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_18.2(%tuple.elem0) [concrete = constants.%int_1] -// CHECK:STDOUT: %.loc7_18.2: init %tuple.type.a1c = tuple_init (%Int.as.Copy.impl.Op.call) to %return [concrete = constants.%tuple.246] +// CHECK:STDOUT: %.loc7_18.2: init %tuple.type.a1c = tuple_init (%Int.as.Copy.impl.Op.call) to %return.param [concrete = constants.%tuple.246] // CHECK:STDOUT: %.loc7_22: init %tuple.type.a1c = converted %impl.elem0.loc7_18.1, %.loc7_18.2 [concrete = constants.%tuple.246] -// CHECK:STDOUT: return %.loc7_22 to %return +// CHECK:STDOUT: return %.loc7_22 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/tuple/in_place_tuple_init.carbon b/toolchain/check/testdata/tuple/in_place_tuple_init.carbon index 91e3d24ba41c..190b58c3eea3 100644 --- a/toolchain/check/testdata/tuple/in_place_tuple_init.carbon +++ b/toolchain/check/testdata/tuple/in_place_tuple_init.carbon @@ -108,10 +108,10 @@ fn H() { // CHECK:STDOUT: assign %v.ref, %F.call.loc8 // CHECK:STDOUT: %F.ref.loc9: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] // CHECK:STDOUT: -// CHECK:STDOUT: %F.call.loc9: init %tuple.type.d07 = call %F.ref.loc9() to %.loc5_8 +// CHECK:STDOUT: %F.call.loc9: init %tuple.type.d07 = call %F.ref.loc9() to %.loc5_20.1 // CHECK:STDOUT: %DestroyOp.bound: = bound_method %v.var, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%v.var) -// CHECK:STDOUT: return %F.call.loc9 to %return +// CHECK:STDOUT: return %F.call.loc9 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %tuple.type.d07) = "no_op"; @@ -132,7 +132,7 @@ fn H() { // CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc15_13.2(%.loc15_13) // CHECK:STDOUT: %DestroyOp.bound: = bound_method %.loc15_12.2, constants.%DestroyOp // CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%.loc15_12.2) -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- nested_tuple_in_place.carbon diff --git a/toolchain/check/testdata/var/global_decl_import.carbon b/toolchain/check/testdata/var/global_decl_import.carbon index cb36ea511d69..1fd8752a1bb2 100644 --- a/toolchain/check/testdata/var/global_decl_import.carbon +++ b/toolchain/check/testdata/var/global_decl_import.carbon @@ -98,11 +98,11 @@ fn G() -> {.v: ()} { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %x.ref: ref %struct_type.v = name_ref x, imports.%Main.x [concrete = imports.%x.var] // CHECK:STDOUT: %.loc7_10.1: ref %empty_tuple.type = struct_access %x.ref, element0 [concrete = constants.%.c0c] -// CHECK:STDOUT: %.loc7_10.2: ref %empty_tuple.type = struct_access %return, element0 +// CHECK:STDOUT: %.loc7_10.2: ref %empty_tuple.type = struct_access %return.param, element0 // CHECK:STDOUT: %.loc7_10.3: init %empty_tuple.type = tuple_init () to %.loc7_10.2 [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc7_10.4: init %empty_tuple.type = converted %.loc7_10.1, %.loc7_10.3 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc7_10.5: init %struct_type.v = struct_init (%.loc7_10.4) to %return [concrete = constants.%struct] +// CHECK:STDOUT: %.loc7_10.5: init %struct_type.v = struct_init (%.loc7_10.4) to %return.param [concrete = constants.%struct] // CHECK:STDOUT: %.loc7_11: init %struct_type.v = converted %x.ref, %.loc7_10.5 [concrete = constants.%struct] -// CHECK:STDOUT: return %.loc7_11 to %return +// CHECK:STDOUT: return %.loc7_11 to %return.param // CHECK:STDOUT: } // CHECK:STDOUT: