From 720c77f6e773d9d787f244bf0d202df85b49fe03 Mon Sep 17 00:00:00 2001 From: Boaz Brickner Date: Tue, 5 Aug 2025 20:57:03 +0200 Subject: [PATCH] Don't use struct literals in tests (#5906) The first version of C++ overload resolution would not support struct literals, so we prepare the tests for that. --- .../interop/cpp/function/class.carbon | 180 ++++++++++------- .../interop/cpp/function/struct.carbon | 168 +++++++++------- .../interop/cpp/function/union.carbon | 189 +++++++++++------- 3 files changed, 321 insertions(+), 216 deletions(-) diff --git a/toolchain/check/testdata/interop/cpp/function/class.carbon b/toolchain/check/testdata/interop/cpp/function/class.carbon index ae83d9bb48c6..295cc9914166 100644 --- a/toolchain/check/testdata/interop/cpp/function/class.carbon +++ b/toolchain/check/testdata/interop/cpp/function/class.carbon @@ -27,16 +27,15 @@ library "[[@TEST_NAME]]"; import Cpp library "decl_value_param_type.h"; fn F() { - // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE+9]]:11: error: forming value of incomplete type `Cpp.C` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ + // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE+8]]:11: error: invalid use of incomplete type `Cpp.C` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class C; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.C); } // --- fail_todo_import_decl_value_param_type_previously_imported.carbon @@ -80,26 +79,24 @@ library "[[@TEST_NAME]]"; import Cpp library "double_decl_value_param_type.h"; fn F() { - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+9]]:12: error: forming value of incomplete type `Cpp.C` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo1({}); - // CHECK:STDERR: ^~ + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+8]]:12: error: invalid use of incomplete type `Cpp.C` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo1({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./double_decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class C; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo1({}); - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+9]]:12: error: forming value of incomplete type `Cpp.C` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo2({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-16]]:10: in file included here [InCppInclude] + Cpp.foo1({} as Cpp.C); + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+8]]:12: error: invalid use of incomplete type `Cpp.C` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo2({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-15]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./double_decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class C; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo2({}); + Cpp.foo2({} as Cpp.C); } // ============================================================================ @@ -120,7 +117,7 @@ import Cpp library "definition_no_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.C); //@dump-sem-ir-end } @@ -146,15 +143,14 @@ import Cpp library "definition_single_data_member_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+8]]:11: error: cannot implicitly convert expression of type `{}` to `Cpp.C` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+5]]:11: note: type `{}` does not implement interface `Core.ImplicitAs(Cpp.C)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.C` with `as` [ConversionFailure] + // CHECK:STDERR: Cpp.foo({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.C)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: Cpp.foo({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.C); //@dump-sem-ir-end } @@ -182,15 +178,14 @@ import Cpp library "definition_multiple_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+8]]:11: error: cannot implicitly convert expression of type `{}` to `Cpp.C` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+5]]:11: note: type `{}` does not implement interface `Core.ImplicitAs(Cpp.C)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.C` with `as` [ConversionFailure] + // CHECK:STDERR: Cpp.foo({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.C)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: Cpp.foo({} as Cpp.C); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.C); //@dump-sem-ir-end } @@ -212,7 +207,7 @@ import Cpp library "definition_in_namespace_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.N.C); // Check that the parameter type was imported correctly. var x: Cpp.N.C; //@dump-sem-ir-end @@ -237,7 +232,7 @@ import Cpp library "definition_in_relative_namespace_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.N1.foo({}); + Cpp.N1.foo({} as Cpp.N1.N2.C); //@dump-sem-ir-end } @@ -262,7 +257,7 @@ import Cpp library "definition_in_outer_definition.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.O.C); var x: Cpp.O; //@dump-sem-ir-end } @@ -289,7 +284,7 @@ import Cpp library "definition_with_static_method.h"; fn F() { //@dump-sem-ir-begin Cpp.C.bar(); - Cpp.foo({}); + Cpp.foo({} as Cpp.C); //@dump-sem-ir-end } @@ -301,7 +296,7 @@ import Cpp library "definition_with_static_method.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.C); Cpp.C.bar(); //@dump-sem-ir-end } @@ -462,8 +457,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -473,15 +470,17 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %.loc8_12.2: ref %C = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %C = class_init (), %.loc8_12.2 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc8_12.4: ref %C = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %C = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %C = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %C = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %C = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_12.2, constants.%T.as.Destroy.impl.Op.21b // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc8_12.2, %T.as.Destroy.impl.Op.specific_fn @@ -503,8 +502,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -514,10 +515,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc16_12.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc16_12.2: %C = converted %.loc16_12.1, [concrete = ] +// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %.loc15_14: %C = converted %.loc15_12, [concrete = ] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() // CHECK:STDOUT: // CHECK:STDOUT: } @@ -535,8 +538,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -546,10 +551,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc16_12.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc16_12.2: %C = converted %.loc16_12.1, [concrete = ] +// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %.loc15_14: %C = converted %.loc15_12, [concrete = ] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() // CHECK:STDOUT: // CHECK:STDOUT: } @@ -589,24 +596,27 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N.ref.loc8: = name_ref N, imports.%N [concrete = imports.%N] +// CHECK:STDOUT: %C.ref.loc8: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %.loc8_12.2: ref %C = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %C = class_init (), %.loc8_12.2 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc8_12.4: ref %C = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %C = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %C = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %C = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %C = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.69f = binding_pattern x [concrete] // CHECK:STDOUT: %x.var_patt: %pattern_type.69f = var_pattern %x.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %x.var: ref %C = var %x.var_patt -// CHECK:STDOUT: %.loc10: type = splice_block %C.ref [concrete = constants.%C] { +// CHECK:STDOUT: %.loc10: type = splice_block %C.ref.loc10 [concrete = constants.%C] { // CHECK:STDOUT: %Cpp.ref.loc10: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %N.ref: = name_ref N, imports.%N [concrete = imports.%N] -// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %N.ref.loc10: = name_ref N, imports.%N [concrete = imports.%N] +// CHECK:STDOUT: %C.ref.loc10: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: } // CHECK:STDOUT: %x: ref %C = bind_name x, %x.var // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc10: = bound_method %x.var, constants.%T.as.Destroy.impl.Op.dbb @@ -643,8 +653,14 @@ fn F() { // CHECK:STDOUT: } // CHECK:STDOUT: %N1: = namespace [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .N2 = %N2 // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %N2: = namespace [concrete] { +// CHECK:STDOUT: .C = %C.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -654,16 +670,20 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %N1.ref: = name_ref N1, imports.%N1 [concrete = imports.%N1] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N1.ref.loc8_6: = name_ref N1, imports.%N1 [concrete = imports.%N1] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_15.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N1.ref.loc8_23: = name_ref N1, imports.%N1 [concrete = imports.%N1] +// CHECK:STDOUT: %N2.ref: = name_ref N2, imports.%N2 [concrete = imports.%N2] +// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %.loc8_15.2: ref %C = temporary_storage // CHECK:STDOUT: %.loc8_15.3: init %C = class_init (), %.loc8_15.2 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc8_15.4: ref %C = temporary %.loc8_15.2, %.loc8_15.3 -// CHECK:STDOUT: %.loc8_15.5: ref %C = converted %.loc8_15.1, %.loc8_15.4 -// CHECK:STDOUT: %.loc8_15.6: %C = bind_value %.loc8_15.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_15.6) +// CHECK:STDOUT: %.loc8_17.1: ref %C = converted %.loc8_15.1, %.loc8_15.4 +// CHECK:STDOUT: %.loc8_17.2: %C = bind_value %.loc8_17.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_17.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_15.2, constants.%T.as.Destroy.impl.Op.f48 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc8_15.2, %T.as.Destroy.impl.Op.specific_fn @@ -698,6 +718,7 @@ fn F() { // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } // CHECK:STDOUT: %O.decl: type = class_decl @O [concrete = constants.%O] {} {} +// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -707,23 +728,26 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %O.ref.loc8: type = name_ref O, imports.%O.decl [concrete = constants.%O] +// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %.loc8_12.2: ref %C = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %C = class_init (), %.loc8_12.2 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc8_12.4: ref %C = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %C = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %C = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %C = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %C = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.cff = binding_pattern x [concrete] // CHECK:STDOUT: %x.var_patt: %pattern_type.cff = var_pattern %x.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %x.var: ref %O = var %x.var_patt -// CHECK:STDOUT: %.loc9: type = splice_block %O.ref [concrete = constants.%O] { +// CHECK:STDOUT: %.loc9: type = splice_block %O.ref.loc9 [concrete = constants.%O] { // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %O.ref: type = name_ref O, imports.%O.decl [concrete = constants.%O] +// CHECK:STDOUT: %O.ref.loc9: type = name_ref O, imports.%O.decl [concrete = constants.%O] // CHECK:STDOUT: } // CHECK:STDOUT: %x: ref %O = bind_name x, %x.var // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc9: = bound_method %x.var, constants.%T.as.Destroy.impl.Op.2df @@ -773,18 +797,20 @@ fn F() { // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %C.ref.loc8: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %bar.ref: %C.bar.type = name_ref bar, imports.%C.bar.decl [concrete = constants.%C.bar] // CHECK:STDOUT: %C.bar.call: init %empty_tuple.type = call %bar.ref() -// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc9_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc9_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc9_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %C.ref.loc9: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %.loc9_12.2: ref %C = temporary_storage // CHECK:STDOUT: %.loc9_12.3: init %C = class_init (), %.loc9_12.2 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc9_12.4: ref %C = temporary %.loc9_12.2, %.loc9_12.3 -// CHECK:STDOUT: %.loc9_12.5: ref %C = converted %.loc9_12.1, %.loc9_12.4 -// CHECK:STDOUT: %.loc9_12.6: %C = bind_value %.loc9_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc9_12.6) +// CHECK:STDOUT: %.loc9_14.1: ref %C = converted %.loc9_12.1, %.loc9_12.4 +// CHECK:STDOUT: %.loc9_14.2: %C = bind_value %.loc9_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc9_14.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc9_12.2, constants.%T.as.Destroy.impl.Op.21b // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc9_12.2, %T.as.Destroy.impl.Op.specific_fn @@ -826,17 +852,19 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %C.ref.loc8: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %.loc8_12.2: ref %C = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %C = class_init (), %.loc8_12.2 [concrete = constants.%C.val] // CHECK:STDOUT: %.loc8_12.4: ref %C = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %C = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %C = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %C = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %C = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %C.ref.loc9: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %bar.ref: %C.bar.type = name_ref bar, imports.%C.bar.decl [concrete = constants.%C.bar] // CHECK:STDOUT: %C.bar.call: init %empty_tuple.type = call %bar.ref() // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_12.2, constants.%T.as.Destroy.impl.Op.21b diff --git a/toolchain/check/testdata/interop/cpp/function/struct.carbon b/toolchain/check/testdata/interop/cpp/function/struct.carbon index e7892e12cf76..6221c89415bb 100644 --- a/toolchain/check/testdata/interop/cpp/function/struct.carbon +++ b/toolchain/check/testdata/interop/cpp/function/struct.carbon @@ -27,16 +27,15 @@ library "[[@TEST_NAME]]"; import Cpp library "decl_value_param_type.h"; fn F() { - // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE+9]]:11: error: forming value of incomplete type `Cpp.S` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ + // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE+8]]:11: error: invalid use of incomplete type `Cpp.S` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo({} as Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./decl_value_param_type.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: struct S; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.S); } // --- fail_todo_import_decl_value_param_type_previously_imported.carbon @@ -80,26 +79,24 @@ library "[[@TEST_NAME]]"; import Cpp library "double_decl_value_param_type.h"; fn F() { - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+9]]:12: error: forming value of incomplete type `Cpp.S` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo1({}); - // CHECK:STDERR: ^~ + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+8]]:12: error: invalid use of incomplete type `Cpp.S` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo1({} as Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./double_decl_value_param_type.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: struct S; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo1({}); - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+9]]:12: error: forming value of incomplete type `Cpp.S` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo2({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-16]]:10: in file included here [InCppInclude] + Cpp.foo1({} as Cpp.S); + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+8]]:12: error: invalid use of incomplete type `Cpp.S` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo2({} as Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-15]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./double_decl_value_param_type.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: struct S; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo2({}); + Cpp.foo2({} as Cpp.S); } // ============================================================================ @@ -120,7 +117,7 @@ import Cpp library "definition_no_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.S); //@dump-sem-ir-end } @@ -146,12 +143,11 @@ import Cpp library "definition_single_data_member_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+5]]:11: error: name `Core.ImplicitAs` implicitly referenced here, but not found [CoreNameNotFound] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+4]]:11: error: name `Core.As` implicitly referenced here, but not found [CoreNameNotFound] + // CHECK:STDERR: Cpp.foo({} as Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.S); //@dump-sem-ir-end } @@ -179,12 +175,11 @@ import Cpp library "definition_multiple_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+5]]:11: error: name `Core.ImplicitAs` implicitly referenced here, but not found [CoreNameNotFound] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+4]]:11: error: name `Core.As` implicitly referenced here, but not found [CoreNameNotFound] + // CHECK:STDERR: Cpp.foo({} as Cpp.S); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.S); //@dump-sem-ir-end } @@ -206,7 +201,7 @@ import Cpp library "definition_in_namespace_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.N.S); // Check that the parameter type was imported correctly. var x: Cpp.N.S; //@dump-sem-ir-end @@ -231,7 +226,7 @@ import Cpp library "definition_in_relative_namespace_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.N1.foo({}); + Cpp.N1.foo({} as Cpp.N1.N2.S); //@dump-sem-ir-end } @@ -255,7 +250,7 @@ import Cpp library "definition_in_outer_definition.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.O.S); var x: Cpp.O; //@dump-sem-ir-end } @@ -281,7 +276,7 @@ import Cpp library "definition_with_static_method.h"; fn F() { //@dump-sem-ir-begin Cpp.S.bar(); - Cpp.foo({}); + Cpp.foo({} as Cpp.S); //@dump-sem-ir-end } @@ -293,7 +288,7 @@ import Cpp library "definition_with_static_method.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.S); Cpp.S.bar(); //@dump-sem-ir-end } @@ -454,8 +449,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .S = %S.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -465,15 +462,17 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %.loc8_12.2: ref %S = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %S = class_init (), %.loc8_12.2 [concrete = constants.%S.val] // CHECK:STDOUT: %.loc8_12.4: ref %S = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %S = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %S = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %S = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %S = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_12.2, constants.%T.as.Destroy.impl.Op.ab5 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc8_12.2, %T.as.Destroy.impl.Op.specific_fn @@ -495,8 +494,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .S = %S.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -506,10 +507,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc12_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc13_12.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_12.2: %S = converted %.loc13_12.1, [concrete = ] +// CHECK:STDOUT: %.loc12_12: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc12_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %.loc12_14: %S = converted %.loc12_12, [concrete = ] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() // CHECK:STDOUT: // CHECK:STDOUT: } @@ -527,8 +530,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .S = %S.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -538,10 +543,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc12_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc13_12.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_12.2: %S = converted %.loc13_12.1, [concrete = ] +// CHECK:STDOUT: %.loc12_12: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc12_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %.loc12_14: %S = converted %.loc12_12, [concrete = ] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() // CHECK:STDOUT: // CHECK:STDOUT: } @@ -581,24 +588,27 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N.ref.loc8: = name_ref N, imports.%N [concrete = imports.%N] +// CHECK:STDOUT: %S.ref.loc8: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %.loc8_12.2: ref %S = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %S = class_init (), %.loc8_12.2 [concrete = constants.%S.val] // CHECK:STDOUT: %.loc8_12.4: ref %S = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %S = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %S = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %S = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %S = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.cd8 = binding_pattern x [concrete] // CHECK:STDOUT: %x.var_patt: %pattern_type.cd8 = var_pattern %x.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %x.var: ref %S = var %x.var_patt -// CHECK:STDOUT: %.loc10: type = splice_block %S.ref [concrete = constants.%S] { +// CHECK:STDOUT: %.loc10: type = splice_block %S.ref.loc10 [concrete = constants.%S] { // CHECK:STDOUT: %Cpp.ref.loc10: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %N.ref: = name_ref N, imports.%N [concrete = imports.%N] -// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %N.ref.loc10: = name_ref N, imports.%N [concrete = imports.%N] +// CHECK:STDOUT: %S.ref.loc10: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: } // CHECK:STDOUT: %x: ref %S = bind_name x, %x.var // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc10: = bound_method %x.var, constants.%T.as.Destroy.impl.Op.9b3 @@ -635,8 +645,14 @@ fn F() { // CHECK:STDOUT: } // CHECK:STDOUT: %N1: = namespace [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .N2 = %N2 // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %N2: = namespace [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -646,16 +662,20 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %N1.ref: = name_ref N1, imports.%N1 [concrete = imports.%N1] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N1.ref.loc8_6: = name_ref N1, imports.%N1 [concrete = imports.%N1] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_15.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N1.ref.loc8_23: = name_ref N1, imports.%N1 [concrete = imports.%N1] +// CHECK:STDOUT: %N2.ref: = name_ref N2, imports.%N2 [concrete = imports.%N2] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %.loc8_15.2: ref %S = temporary_storage // CHECK:STDOUT: %.loc8_15.3: init %S = class_init (), %.loc8_15.2 [concrete = constants.%S.val] // CHECK:STDOUT: %.loc8_15.4: ref %S = temporary %.loc8_15.2, %.loc8_15.3 -// CHECK:STDOUT: %.loc8_15.5: ref %S = converted %.loc8_15.1, %.loc8_15.4 -// CHECK:STDOUT: %.loc8_15.6: %S = bind_value %.loc8_15.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_15.6) +// CHECK:STDOUT: %.loc8_17.1: ref %S = converted %.loc8_15.1, %.loc8_15.4 +// CHECK:STDOUT: %.loc8_17.2: %S = bind_value %.loc8_17.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_17.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_15.2, constants.%T.as.Destroy.impl.Op.463 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc8_15.2, %T.as.Destroy.impl.Op.specific_fn @@ -690,6 +710,7 @@ fn F() { // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } // CHECK:STDOUT: %O.decl: type = class_decl @O [concrete = constants.%O] {} {} +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -699,23 +720,26 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %O.ref.loc8: type = name_ref O, imports.%O.decl [concrete = constants.%O] +// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %.loc8_12.2: ref %S = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %S = class_init (), %.loc8_12.2 [concrete = constants.%S.val] // CHECK:STDOUT: %.loc8_12.4: ref %S = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %S = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %S = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %S = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %S = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.cff = binding_pattern x [concrete] // CHECK:STDOUT: %x.var_patt: %pattern_type.cff = var_pattern %x.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %x.var: ref %O = var %x.var_patt -// CHECK:STDOUT: %.loc9: type = splice_block %O.ref [concrete = constants.%O] { +// CHECK:STDOUT: %.loc9: type = splice_block %O.ref.loc9 [concrete = constants.%O] { // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %O.ref: type = name_ref O, imports.%O.decl [concrete = constants.%O] +// CHECK:STDOUT: %O.ref.loc9: type = name_ref O, imports.%O.decl [concrete = constants.%O] // CHECK:STDOUT: } // CHECK:STDOUT: %x: ref %O = bind_name x, %x.var // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc9: = bound_method %x.var, constants.%T.as.Destroy.impl.Op.2df @@ -765,18 +789,20 @@ fn F() { // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %S.ref.loc8: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %bar.ref: %S.bar.type = name_ref bar, imports.%S.bar.decl [concrete = constants.%S.bar] // CHECK:STDOUT: %S.bar.call: init %empty_tuple.type = call %bar.ref() -// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc9_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc9_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc9_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %.loc9_12.2: ref %S = temporary_storage // CHECK:STDOUT: %.loc9_12.3: init %S = class_init (), %.loc9_12.2 [concrete = constants.%S.val] // CHECK:STDOUT: %.loc9_12.4: ref %S = temporary %.loc9_12.2, %.loc9_12.3 -// CHECK:STDOUT: %.loc9_12.5: ref %S = converted %.loc9_12.1, %.loc9_12.4 -// CHECK:STDOUT: %.loc9_12.6: %S = bind_value %.loc9_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc9_12.6) +// CHECK:STDOUT: %.loc9_14.1: ref %S = converted %.loc9_12.1, %.loc9_12.4 +// CHECK:STDOUT: %.loc9_14.2: %S = bind_value %.loc9_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc9_14.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc9_12.2, constants.%T.as.Destroy.impl.Op.ab5 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc9_12.2, %T.as.Destroy.impl.Op.specific_fn @@ -818,17 +844,19 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc8: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %.loc8_12.2: ref %S = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %S = class_init (), %.loc8_12.2 [concrete = constants.%S.val] // CHECK:STDOUT: %.loc8_12.4: ref %S = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %S = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %S = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %S = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %S = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %bar.ref: %S.bar.type = name_ref bar, imports.%S.bar.decl [concrete = constants.%S.bar] // CHECK:STDOUT: %S.bar.call: init %empty_tuple.type = call %bar.ref() // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_12.2, constants.%T.as.Destroy.impl.Op.ab5 diff --git a/toolchain/check/testdata/interop/cpp/function/union.carbon b/toolchain/check/testdata/interop/cpp/function/union.carbon index 2a7fac76c980..0e2c472bac60 100644 --- a/toolchain/check/testdata/interop/cpp/function/union.carbon +++ b/toolchain/check/testdata/interop/cpp/function/union.carbon @@ -28,16 +28,15 @@ import Cpp library "decl_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE+9]]:11: error: forming value of incomplete type `Cpp.U` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ + // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE+8]]:11: error: invalid use of incomplete type `Cpp.U` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo({} as Cpp.U); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon:[[@LINE-7]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: union U; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.U); //@dump-sem-ir-end } @@ -82,26 +81,24 @@ library "[[@TEST_NAME]]"; import Cpp library "double_decl_value_param_type.h"; fn F() { - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+9]]:12: error: forming value of incomplete type `Cpp.U` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo1({}); - // CHECK:STDERR: ^~ + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+8]]:12: error: invalid use of incomplete type `Cpp.U` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo1({} as Cpp.U); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./double_decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: union U; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo1({}); - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+9]]:12: error: forming value of incomplete type `Cpp.U` [IncompleteTypeInValueConversion] - // CHECK:STDERR: Cpp.foo2({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-16]]:10: in file included here [InCppInclude] + Cpp.foo1({} as Cpp.U); + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE+8]]:12: error: invalid use of incomplete type `Cpp.U` [IncompleteTypeInConversion] + // CHECK:STDERR: Cpp.foo2({} as Cpp.U); + // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon:[[@LINE-15]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./double_decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: union U; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_import_double_decl_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo2({}); + Cpp.foo2({} as Cpp.U); } // ============================================================================ @@ -122,7 +119,7 @@ import Cpp library "definition_no_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.U); //@dump-sem-ir-end } @@ -148,12 +145,16 @@ import Cpp library "definition_single_data_member_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon:[[@LINE+5]]:11: error: name `Core.ImplicitAs` implicitly referenced here, but not found [CoreNameNotFound] - // CHECK:STDERR: Cpp.foo({}); + // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon:[[@LINE+9]]:11: error: name `Core.ImplicitAs` implicitly referenced here, but not found [CoreNameNotFound] + // CHECK:STDERR: Cpp.foo({}) as Cpp.U; // CHECK:STDERR: ^~ // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: - Cpp.foo({}); + // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon:[[@LINE+4]]:3: error: name `Core.As` implicitly referenced here, but not found [CoreNameNotFound] + // CHECK:STDERR: Cpp.foo({}) as Cpp.U; + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + Cpp.foo({}) as Cpp.U; //@dump-sem-ir-end } @@ -181,12 +182,11 @@ import Cpp library "definition_multiple_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+5]]:11: error: name `Core.ImplicitAs` implicitly referenced here, but not found [CoreNameNotFound] - // CHECK:STDERR: Cpp.foo({}); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_import_definition_multiple_data_members_value_param_type.carbon: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: fail_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+4]]:11: error: name `Core.As` implicitly referenced here, but not found [CoreNameNotFound] + // CHECK:STDERR: Cpp.foo({} as Cpp.U); + // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: - Cpp.foo({}); + Cpp.foo({} as Cpp.U); //@dump-sem-ir-end } @@ -208,7 +208,7 @@ import Cpp library "definition_in_namespace_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.N.U); // Check that the parameter type was imported correctly. var x: Cpp.N.U; //@dump-sem-ir-end @@ -233,7 +233,7 @@ import Cpp library "definition_in_relative_namespace_value_param_type.h"; fn F() { //@dump-sem-ir-begin - Cpp.N1.foo({}); + Cpp.N1.foo({} as Cpp.N1.N2.U); //@dump-sem-ir-end } @@ -258,7 +258,7 @@ import Cpp library "definition_in_outer_definition.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.O.U); var x: Cpp.O; //@dump-sem-ir-end } @@ -284,7 +284,7 @@ import Cpp library "definition_with_static_method.h"; fn F() { //@dump-sem-ir-begin Cpp.U.bar(); - Cpp.foo({}); + Cpp.foo({} as Cpp.U); //@dump-sem-ir-end } @@ -296,7 +296,7 @@ import Cpp library "definition_with_static_method.h"; fn F() { //@dump-sem-ir-begin - Cpp.foo({}); + Cpp.foo({} as Cpp.U); Cpp.U.bar(); //@dump-sem-ir-end } @@ -444,6 +444,7 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %U: type = class_type @U [concrete] // CHECK:STDOUT: %foo.type: type = fn_type @foo [concrete] // CHECK:STDOUT: %foo: %foo.type = struct_value () [concrete] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] @@ -452,8 +453,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .U = %U.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %U.decl: type = class_decl @U [concrete = constants.%U] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -463,9 +466,11 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc16_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc17: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc16: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc16_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() // CHECK:STDOUT: // CHECK:STDOUT: } @@ -487,8 +492,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .U = %U.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %U.decl: type = class_decl @U [concrete = constants.%U] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -498,15 +505,17 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %.loc8_12.2: ref %U = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %U = class_init (), %.loc8_12.2 [concrete = constants.%U.val] // CHECK:STDOUT: %.loc8_12.4: ref %U = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %U = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %U = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %U = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %U = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_12.2, constants.%T.as.Destroy.impl.Op.2fa // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc8_12.2, %T.as.Destroy.impl.Op.specific_fn @@ -523,13 +532,18 @@ fn F() { // CHECK:STDOUT: %foo.type: type = fn_type @foo [concrete] // CHECK:STDOUT: %foo: %foo.type = struct_value () [concrete] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.type.a63: type = fn_type @T.as.Destroy.impl.Op, @T.as.Destroy.impl(%empty_tuple.type) [concrete] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.ea3: %T.as.Destroy.impl.Op.type.a63 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.843: type = ptr_type %empty_tuple.type [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .U = %U.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %U.decl: type = class_decl @U [concrete = constants.%U] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -539,11 +553,21 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc17_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc13_12.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_12.2: %U = converted %.loc13_12.1, [concrete = ] +// CHECK:STDOUT: %.loc17_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc17_12.2: %U = converted %.loc17_12.1, [concrete = ] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() +// CHECK:STDOUT: %Cpp.ref.loc17_18: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] +// CHECK:STDOUT: %.loc17_13.1: ref %empty_tuple.type = temporary_storage +// CHECK:STDOUT: %.loc17_13.2: ref %empty_tuple.type = temporary %.loc17_13.1, %foo.call +// CHECK:STDOUT: %.loc17_15: %U = converted %foo.call, [concrete = ] +// CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc17_13.1, constants.%T.as.Destroy.impl.Op.ea3 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc17_13.1, %T.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr: %ptr.843 = addr_of %.loc17_13.1 +// CHECK:STDOUT: %T.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -560,8 +584,10 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .U = %U.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %U.decl: type = class_decl @U [concrete = constants.%U] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -571,10 +597,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc12_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] -// CHECK:STDOUT: %.loc13_12.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_12.2: %U = converted %.loc13_12.1, [concrete = ] +// CHECK:STDOUT: %.loc12_12: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc12_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] +// CHECK:STDOUT: %.loc12_14: %U = converted %.loc12_12, [concrete = ] // CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref() // CHECK:STDOUT: // CHECK:STDOUT: } @@ -614,24 +642,27 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N.ref.loc8: = name_ref N, imports.%N [concrete = imports.%N] +// CHECK:STDOUT: %U.ref.loc8: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %.loc8_12.2: ref %U = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %U = class_init (), %.loc8_12.2 [concrete = constants.%U.val] // CHECK:STDOUT: %.loc8_12.4: ref %U = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %U = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %U = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %U = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %U = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.eb9 = binding_pattern x [concrete] // CHECK:STDOUT: %x.var_patt: %pattern_type.eb9 = var_pattern %x.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %x.var: ref %U = var %x.var_patt -// CHECK:STDOUT: %.loc10: type = splice_block %U.ref [concrete = constants.%U] { +// CHECK:STDOUT: %.loc10: type = splice_block %U.ref.loc10 [concrete = constants.%U] { // CHECK:STDOUT: %Cpp.ref.loc10: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %N.ref: = name_ref N, imports.%N [concrete = imports.%N] -// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] +// CHECK:STDOUT: %N.ref.loc10: = name_ref N, imports.%N [concrete = imports.%N] +// CHECK:STDOUT: %U.ref.loc10: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: } // CHECK:STDOUT: %x: ref %U = bind_name x, %x.var // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc10: = bound_method %x.var, constants.%T.as.Destroy.impl.Op.d5d @@ -668,8 +699,14 @@ fn F() { // CHECK:STDOUT: } // CHECK:STDOUT: %N1: = namespace [concrete] { // CHECK:STDOUT: .foo = %foo.decl +// CHECK:STDOUT: .N2 = %N2 // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } +// CHECK:STDOUT: %N2: = namespace [concrete] { +// CHECK:STDOUT: .U = %U.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.decl: type = class_decl @U [concrete = constants.%U] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -679,16 +716,20 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %N1.ref: = name_ref N1, imports.%N1 [concrete = imports.%N1] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N1.ref.loc8_6: = name_ref N1, imports.%N1 [concrete = imports.%N1] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_15.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %N1.ref.loc8_23: = name_ref N1, imports.%N1 [concrete = imports.%N1] +// CHECK:STDOUT: %N2.ref: = name_ref N2, imports.%N2 [concrete = imports.%N2] +// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %.loc8_15.2: ref %U = temporary_storage // CHECK:STDOUT: %.loc8_15.3: init %U = class_init (), %.loc8_15.2 [concrete = constants.%U.val] // CHECK:STDOUT: %.loc8_15.4: ref %U = temporary %.loc8_15.2, %.loc8_15.3 -// CHECK:STDOUT: %.loc8_15.5: ref %U = converted %.loc8_15.1, %.loc8_15.4 -// CHECK:STDOUT: %.loc8_15.6: %U = bind_value %.loc8_15.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_15.6) +// CHECK:STDOUT: %.loc8_17.1: ref %U = converted %.loc8_15.1, %.loc8_15.4 +// CHECK:STDOUT: %.loc8_17.2: %U = bind_value %.loc8_17.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_17.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_15.2, constants.%T.as.Destroy.impl.Op.28c // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc8_15.2, %T.as.Destroy.impl.Op.specific_fn @@ -723,6 +764,7 @@ fn F() { // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } // CHECK:STDOUT: %O.decl: type = class_decl @O [concrete = constants.%O] {} {} +// CHECK:STDOUT: %U.decl: type = class_decl @U [concrete = constants.%U] {} {} // CHECK:STDOUT: %foo.decl: %foo.type = fn_decl @foo [concrete = constants.%foo] { // CHECK:STDOUT: // CHECK:STDOUT: } { @@ -732,23 +774,26 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %O.ref.loc8: type = name_ref O, imports.%O.decl [concrete = constants.%O] +// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %.loc8_12.2: ref %U = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %U = class_init (), %.loc8_12.2 [concrete = constants.%U.val] // CHECK:STDOUT: %.loc8_12.4: ref %U = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %U = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %U = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %U = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %U = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.cff = binding_pattern x [concrete] // CHECK:STDOUT: %x.var_patt: %pattern_type.cff = var_pattern %x.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %x.var: ref %O = var %x.var_patt -// CHECK:STDOUT: %.loc9: type = splice_block %O.ref [concrete = constants.%O] { +// CHECK:STDOUT: %.loc9: type = splice_block %O.ref.loc9 [concrete = constants.%O] { // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %O.ref: type = name_ref O, imports.%O.decl [concrete = constants.%O] +// CHECK:STDOUT: %O.ref.loc9: type = name_ref O, imports.%O.decl [concrete = constants.%O] // CHECK:STDOUT: } // CHECK:STDOUT: %x: ref %O = bind_name x, %x.var // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound.loc9: = bound_method %x.var, constants.%T.as.Destroy.impl.Op.2df @@ -798,18 +843,20 @@ fn F() { // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] +// CHECK:STDOUT: %U.ref.loc8: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %bar.ref: %U.bar.type = name_ref bar, imports.%U.bar.decl [concrete = constants.%U.bar] // CHECK:STDOUT: %U.bar.call: init %empty_tuple.type = call %bar.ref() -// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc9_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc9_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc9_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %U.ref.loc9: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %.loc9_12.2: ref %U = temporary_storage // CHECK:STDOUT: %.loc9_12.3: init %U = class_init (), %.loc9_12.2 [concrete = constants.%U.val] // CHECK:STDOUT: %.loc9_12.4: ref %U = temporary %.loc9_12.2, %.loc9_12.3 -// CHECK:STDOUT: %.loc9_12.5: ref %U = converted %.loc9_12.1, %.loc9_12.4 -// CHECK:STDOUT: %.loc9_12.6: %U = bind_value %.loc9_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc9_12.6) +// CHECK:STDOUT: %.loc9_14.1: ref %U = converted %.loc9_12.1, %.loc9_12.4 +// CHECK:STDOUT: %.loc9_14.2: %U = bind_value %.loc9_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc9_14.2) // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc9_12.2, constants.%T.as.Destroy.impl.Op.2fa // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %.loc9_12.2, %T.as.Destroy.impl.Op.specific_fn @@ -851,17 +898,19 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.type = name_ref foo, imports.%foo.decl [concrete = constants.%foo] // CHECK:STDOUT: %.loc8_12.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %Cpp.ref.loc8_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %U.ref.loc8: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %.loc8_12.2: ref %U = temporary_storage // CHECK:STDOUT: %.loc8_12.3: init %U = class_init (), %.loc8_12.2 [concrete = constants.%U.val] // CHECK:STDOUT: %.loc8_12.4: ref %U = temporary %.loc8_12.2, %.loc8_12.3 -// CHECK:STDOUT: %.loc8_12.5: ref %U = converted %.loc8_12.1, %.loc8_12.4 -// CHECK:STDOUT: %.loc8_12.6: %U = bind_value %.loc8_12.5 -// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_12.6) +// CHECK:STDOUT: %.loc8_14.1: ref %U = converted %.loc8_12.1, %.loc8_12.4 +// CHECK:STDOUT: %.loc8_14.2: %U = bind_value %.loc8_14.1 +// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call %foo.ref(%.loc8_14.2) // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] +// CHECK:STDOUT: %U.ref.loc9: type = name_ref U, imports.%U.decl [concrete = constants.%U] // CHECK:STDOUT: %bar.ref: %U.bar.type = name_ref bar, imports.%U.bar.decl [concrete = constants.%U.bar] // CHECK:STDOUT: %U.bar.call: init %empty_tuple.type = call %bar.ref() // CHECK:STDOUT: %T.as.Destroy.impl.Op.bound: = bound_method %.loc8_12.2, constants.%T.as.Destroy.impl.Op.2fa