From f91d23b110587ccc24049efbc0cea3d2beb8a7b4 Mon Sep 17 00:00:00 2001 From: Jon Ross-Perkins Date: Thu, 29 May 2025 13:54:49 -0700 Subject: [PATCH] Add range flag settings to return files (#5572) Where `--no-dump-sem-ir` is used, change to `--dump-sem-ir-ranges=only`. Otherwise, add `--dump-sem-ir-ranges=if-present` with a TODO to change to `only`. Note, SemIR is affected just because the extra comments change line numbers in files where splits aren't in use. --- .../testdata/return/code_after_return.carbon | 3 + .../return/code_after_return_value.carbon | 21 +-- .../testdata/return/fail_call_in_type.carbon | 7 +- .../testdata/return/fail_error_in_type.carbon | 3 + .../testdata/return/fail_let_in_type.carbon | 21 +-- .../return/fail_missing_return.carbon | 3 + .../fail_missing_return_empty_tuple.carbon | 7 +- .../fail_return_var_no_returned_var.carbon | 3 + .../fail_return_with_returned_var.carbon | 83 +++++----- .../fail_returned_var_no_return_type.carbon | 3 + .../return/fail_returned_var_shadow.carbon | 151 +++++++++--------- .../return/fail_returned_var_type.carbon | 13 +- .../testdata/return/fail_type_mismatch.carbon | 5 +- .../return/fail_value_disallowed.carbon | 3 + .../testdata/return/fail_value_missing.carbon | 3 + .../testdata/return/fail_var_in_type.carbon | 5 +- .../import_convert_function.carbon | 2 + .../missing_return_no_return_type.carbon | 3 + .../check/testdata/return/no_value.carbon | 3 + .../check/testdata/return/returned_var.carbon | 87 +++++----- .../testdata/return/returned_var_scope.carbon | 145 +++++++++-------- toolchain/check/testdata/return/struct.carbon | 21 +-- toolchain/check/testdata/return/tuple.carbon | 51 +++--- toolchain/check/testdata/return/value.carbon | 15 +- 24 files changed, 366 insertions(+), 295 deletions(-) diff --git a/toolchain/check/testdata/return/code_after_return.carbon b/toolchain/check/testdata/return/code_after_return.carbon index 2f4b99c01ab1..257b9767c19f 100644 --- a/toolchain/check/testdata/return/code_after_return.carbon +++ b/toolchain/check/testdata/return/code_after_return.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/code_after_return.carbon diff --git a/toolchain/check/testdata/return/code_after_return_value.carbon b/toolchain/check/testdata/return/code_after_return_value.carbon index 32731206fc9c..b32662e2bbda 100644 --- a/toolchain/check/testdata/return/code_after_return_value.carbon +++ b/toolchain/check/testdata/return/code_after_return_value.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/code_after_return_value.carbon @@ -82,10 +85,10 @@ fn F(b: bool) -> i32 { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %b.param: bool = value_param call_param0 -// CHECK:STDOUT: %.loc11_9.1: type = splice_block %.loc11_9.3 [concrete = bool] { +// CHECK:STDOUT: %.loc14_9.1: type = splice_block %.loc14_9.3 [concrete = bool] { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [concrete = bool] -// CHECK:STDOUT: %.loc11_9.2: type = value_of_initializer %bool.make_type [concrete = bool] -// CHECK:STDOUT: %.loc11_9.3: type = converted %bool.make_type, %.loc11_9.2 [concrete = bool] +// CHECK:STDOUT: %.loc14_9.2: type = value_of_initializer %bool.make_type [concrete = bool] +// CHECK:STDOUT: %.loc14_9.3: type = converted %bool.make_type, %.loc14_9.2 [concrete = bool] // CHECK:STDOUT: } // CHECK:STDOUT: %b: bool = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param1 @@ -97,12 +100,12 @@ fn F(b: bool) -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] // CHECK:STDOUT: %impl.elem0: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc12_11.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %bound_method.loc15_11.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound.d04] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc12_11.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc12_11.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc12_11.1: %i32 = value_of_initializer %int.convert_checked [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc12_11.2: %i32 = converted %int_0, %.loc12_11.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc12_11.2 +// CHECK:STDOUT: %bound_method.loc15_11.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc15_11.2(%int_0) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc15_11.1: %i32 = value_of_initializer %int.convert_checked [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc15_11.2: %i32 = converted %int_0, %.loc15_11.1 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: return %.loc15_11.2 // 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 33df92d04e1c..a6944e4ccc6b 100644 --- a/toolchain/check/testdata/return/fail_call_in_type.carbon +++ b/toolchain/check/testdata/return/fail_call_in_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_call_in_type.carbon @@ -61,8 +64,8 @@ fn Six() -> ReturnType() { return 6; } // CHECK:STDOUT: } { // CHECK:STDOUT: %ReturnType.ref: %ReturnType.type = name_ref ReturnType, file.%ReturnType.decl [concrete = constants.%ReturnType] // CHECK:STDOUT: %ReturnType.call: init type = call %ReturnType.ref() -// CHECK:STDOUT: %.loc18_24.1: type = value_of_initializer %ReturnType.call -// CHECK:STDOUT: %.loc18_24.2: type = converted %ReturnType.call, %.loc18_24.1 +// CHECK:STDOUT: %.loc21_24.1: type = value_of_initializer %ReturnType.call +// CHECK:STDOUT: %.loc21_24.2: type = converted %ReturnType.call, %.loc21_24.1 // CHECK:STDOUT: %return.param: ref = out_param call_param0 // CHECK:STDOUT: %return: ref = return_slot %return.param // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/return/fail_error_in_type.carbon b/toolchain/check/testdata/return/fail_error_in_type.carbon index cd0dfe0aa091..797ae2b09e82 100644 --- a/toolchain/check/testdata/return/fail_error_in_type.carbon +++ b/toolchain/check/testdata/return/fail_error_in_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_error_in_type.carbon diff --git a/toolchain/check/testdata/return/fail_let_in_type.carbon b/toolchain/check/testdata/return/fail_let_in_type.carbon index bc7050feeaec..7db3e821aa31 100644 --- a/toolchain/check/testdata/return/fail_let_in_type.carbon +++ b/toolchain/check/testdata/return/fail_let_in_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_let_in_type.carbon @@ -79,7 +82,7 @@ fn FirstPerfectNumber() -> z { return 6; } // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %x.patt: %pattern_type.98f = binding_pattern x [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %x: type = bind_name x, @__global_init.%i32.loc11 +// CHECK:STDOUT: %x: type = bind_name x, @__global_init.%i32.loc14 // CHECK:STDOUT: %Six.decl: %Six.type = fn_decl @Six [concrete = constants.%Six] { // CHECK:STDOUT: %return.patt: = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: = out_param_pattern %return.patt, call_param0 [concrete] @@ -91,7 +94,7 @@ fn FirstPerfectNumber() -> z { return 6; } // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %y.patt: %pattern_type.98f = binding_pattern y [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %y: type = bind_name y, @__global_init.%i32.loc23 +// CHECK:STDOUT: %y: type = bind_name y, @__global_init.%i32.loc26 // CHECK:STDOUT: %HalfDozen.decl: %HalfDozen.type = fn_decl @HalfDozen [concrete = constants.%HalfDozen] { // CHECK:STDOUT: %return.patt: = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: = out_param_pattern %return.patt, call_param0 [concrete] @@ -103,7 +106,7 @@ fn FirstPerfectNumber() -> z { return 6; } // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %z.patt: %pattern_type.98f = binding_pattern z [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %z: type = bind_name z, @__global_init.%i32.loc35 +// CHECK:STDOUT: %z: type = bind_name z, @__global_init.%i32.loc38 // CHECK:STDOUT: %FirstPerfectNumber.decl: %FirstPerfectNumber.type = fn_decl @FirstPerfectNumber [concrete = constants.%FirstPerfectNumber] { // CHECK:STDOUT: %return.patt: = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: = out_param_pattern %return.patt, call_param0 [concrete] @@ -134,12 +137,12 @@ fn FirstPerfectNumber() -> z { return 6; } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %int_32.loc11: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc11: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc23: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc23: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc35: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc35: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc14: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc14: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc26: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc26: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc38: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc38: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/fail_missing_return.carbon b/toolchain/check/testdata/return/fail_missing_return.carbon index adaffd9c1b76..0136b48b272a 100644 --- a/toolchain/check/testdata/return/fail_missing_return.carbon +++ b/toolchain/check/testdata/return/fail_missing_return.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_missing_return.carbon diff --git a/toolchain/check/testdata/return/fail_missing_return_empty_tuple.carbon b/toolchain/check/testdata/return/fail_missing_return_empty_tuple.carbon index cd4561519500..bee2f558704a 100644 --- a/toolchain/check/testdata/return/fail_missing_return_empty_tuple.carbon +++ b/toolchain/check/testdata/return/fail_missing_return_empty_tuple.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_missing_return_empty_tuple.carbon @@ -41,8 +44,8 @@ fn F() -> () { // CHECK:STDOUT: %return.patt: %pattern_type = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %.loc11_12.1: %empty_tuple.type = tuple_literal () -// CHECK:STDOUT: %.loc11_12.2: type = converted %.loc11_12.1, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] +// CHECK:STDOUT: %.loc14_12.1: %empty_tuple.type = tuple_literal () +// CHECK:STDOUT: %.loc14_12.2: type = converted %.loc14_12.1, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] // CHECK:STDOUT: %return.param: ref %empty_tuple.type = out_param call_param0 // CHECK:STDOUT: %return: ref %empty_tuple.type = return_slot %return.param // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/return/fail_return_var_no_returned_var.carbon b/toolchain/check/testdata/return/fail_return_var_no_returned_var.carbon index bcd777180846..a3c577fe0e15 100644 --- a/toolchain/check/testdata/return/fail_return_var_no_returned_var.carbon +++ b/toolchain/check/testdata/return/fail_return_var_no_returned_var.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_return_var_no_returned_var.carbon 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 6bd3e7a506aa..b7d4ba7e3789 100644 --- a/toolchain/check/testdata/return/fail_return_with_returned_var.carbon +++ b/toolchain/check/testdata/return/fail_return_with_returned_var.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_return_with_returned_var.carbon @@ -104,8 +107,8 @@ fn G() -> C { // CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc11: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc11: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc14: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc14: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } @@ -114,27 +117,27 @@ fn G() -> C { // CHECK:STDOUT: %return.patt: %pattern_type.c48 = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.c48 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %C.ref.loc24: type = name_ref C, file.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %C.ref.loc27: type = name_ref C, file.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %return.param: ref %C = out_param call_param0 // CHECK:STDOUT: %return: ref %C = return_slot %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %int_32.loc23_18: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc23_18: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc23_16: %C.elem = field_decl a, element0 [concrete] -// CHECK:STDOUT: %int_32.loc23_30: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc23_30: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc23_28: %C.elem = field_decl b, element1 [concrete] +// CHECK:STDOUT: %int_32.loc26_18: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc26_18: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc26_16: %C.elem = field_decl a, element0 [concrete] +// CHECK:STDOUT: %int_32.loc26_30: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc26_30: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc26_28: %C.elem = field_decl b, element1 [concrete] // CHECK:STDOUT: %struct_type.a.b: type = struct_type {.a: %i32, .b: %i32} [concrete = constants.%struct_type.a.b.501] // CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b [concrete = constants.%complete_type.705] // CHECK:STDOUT: complete_type_witness = %complete_type // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C -// CHECK:STDOUT: .a = %.loc23_16 -// CHECK:STDOUT: .b = %.loc23_28 +// CHECK:STDOUT: .a = %.loc26_16 +// CHECK:STDOUT: .b = %.loc26_28 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() -> %i32 { @@ -146,15 +149,15 @@ fn G() -> C { // CHECK:STDOUT: %v.var: ref %i32 = var %v.var_patt // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] // CHECK:STDOUT: %impl.elem0: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc12_12.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %bound_method.loc15_12.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound.d04] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc12_12.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc12_12.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc12_12: init %i32 = converted %int_0, %int.convert_checked [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: assign %v.var, %.loc12_12 -// CHECK:STDOUT: %.loc12_19: type = splice_block %i32.loc12 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc12: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc12: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %bound_method.loc15_12.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc15_12.2(%int_0) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc15_12: init %i32 = converted %int_0, %int.convert_checked [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: assign %v.var, %.loc15_12 +// CHECK:STDOUT: %.loc15_19: type = splice_block %i32.loc15 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc15: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc15: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %v: ref %i32 = bind_name v, %v.var // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] @@ -169,27 +172,27 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc] -// CHECK:STDOUT: %.loc25_38.1: %struct_type.a.b.cfd = struct_literal (%int_1, %int_2) -// CHECK:STDOUT: %impl.elem0.loc25_38.1: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc25_38.1: = bound_method %int_1, %impl.elem0.loc25_38.1 [concrete = constants.%Convert.bound.ab5] -// CHECK:STDOUT: %specific_fn.loc25_38.1: = specific_function %impl.elem0.loc25_38.1, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc25_38.2: = bound_method %int_1, %specific_fn.loc25_38.1 [concrete = constants.%bound_method.9a1] -// CHECK:STDOUT: %int.convert_checked.loc25_38.1: init %i32 = call %bound_method.loc25_38.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc25_38.2: init %i32 = converted %int_1, %int.convert_checked.loc25_38.1 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc25_38.3: ref %i32 = class_element_access %return, element0 -// CHECK:STDOUT: %.loc25_38.4: init %i32 = initialize_from %.loc25_38.2 to %.loc25_38.3 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %impl.elem0.loc25_38.2: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc25_38.3: = bound_method %int_2, %impl.elem0.loc25_38.2 [concrete = constants.%Convert.bound.ef9] -// CHECK:STDOUT: %specific_fn.loc25_38.2: = specific_function %impl.elem0.loc25_38.2, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc25_38.4: = bound_method %int_2, %specific_fn.loc25_38.2 [concrete = constants.%bound_method.b92] -// CHECK:STDOUT: %int.convert_checked.loc25_38.2: init %i32 = call %bound_method.loc25_38.4(%int_2) [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc25_38.5: init %i32 = converted %int_2, %int.convert_checked.loc25_38.2 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc25_38.6: ref %i32 = class_element_access %return, element1 -// CHECK:STDOUT: %.loc25_38.7: init %i32 = initialize_from %.loc25_38.5 to %.loc25_38.6 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc25_38.8: init %C = class_init (%.loc25_38.4, %.loc25_38.7), %return [concrete = constants.%C.val] -// CHECK:STDOUT: %.loc25_12: init %C = converted %.loc25_38.1, %.loc25_38.8 [concrete = constants.%C.val] -// CHECK:STDOUT: assign %return, %.loc25_12 -// CHECK:STDOUT: %C.ref.loc25: type = name_ref C, file.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %.loc28_38.1: %struct_type.a.b.cfd = struct_literal (%int_1, %int_2) +// CHECK:STDOUT: %impl.elem0.loc28_38.1: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc28_38.1: = bound_method %int_1, %impl.elem0.loc28_38.1 [concrete = constants.%Convert.bound.ab5] +// CHECK:STDOUT: %specific_fn.loc28_38.1: = specific_function %impl.elem0.loc28_38.1, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc28_38.2: = bound_method %int_1, %specific_fn.loc28_38.1 [concrete = constants.%bound_method.9a1] +// CHECK:STDOUT: %int.convert_checked.loc28_38.1: init %i32 = call %bound_method.loc28_38.2(%int_1) [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc28_38.2: init %i32 = converted %int_1, %int.convert_checked.loc28_38.1 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc28_38.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc28_38.4: init %i32 = initialize_from %.loc28_38.2 to %.loc28_38.3 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %impl.elem0.loc28_38.2: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc28_38.3: = bound_method %int_2, %impl.elem0.loc28_38.2 [concrete = constants.%Convert.bound.ef9] +// CHECK:STDOUT: %specific_fn.loc28_38.2: = specific_function %impl.elem0.loc28_38.2, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc28_38.4: = bound_method %int_2, %specific_fn.loc28_38.2 [concrete = constants.%bound_method.b92] +// CHECK:STDOUT: %int.convert_checked.loc28_38.2: init %i32 = call %bound_method.loc28_38.4(%int_2) [concrete = constants.%int_2.ef8] +// CHECK:STDOUT: %.loc28_38.5: init %i32 = converted %int_2, %int.convert_checked.loc28_38.2 [concrete = constants.%int_2.ef8] +// CHECK:STDOUT: %.loc28_38.6: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc28_38.7: init %i32 = initialize_from %.loc28_38.5 to %.loc28_38.6 [concrete = constants.%int_2.ef8] +// CHECK:STDOUT: %.loc28_38.8: init %C = class_init (%.loc28_38.4, %.loc28_38.7), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc28_12: init %C = converted %.loc28_38.1, %.loc28_38.8 [concrete = constants.%C.val] +// CHECK:STDOUT: assign %return, %.loc28_12 +// CHECK:STDOUT: %C.ref.loc28: type = name_ref C, file.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %c: ref %C = bind_name c, %return // CHECK:STDOUT: %c.ref: ref %C = name_ref c, %c // CHECK:STDOUT: return diff --git a/toolchain/check/testdata/return/fail_returned_var_no_return_type.carbon b/toolchain/check/testdata/return/fail_returned_var_no_return_type.carbon index 7064a1eb55d7..3574a777c911 100644 --- a/toolchain/check/testdata/return/fail_returned_var_no_return_type.carbon +++ b/toolchain/check/testdata/return/fail_returned_var_no_return_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_returned_var_no_return_type.carbon diff --git a/toolchain/check/testdata/return/fail_returned_var_shadow.carbon b/toolchain/check/testdata/return/fail_returned_var_shadow.carbon index 9673aa0b3b16..e88dd3186f02 100644 --- a/toolchain/check/testdata/return/fail_returned_var_shadow.carbon +++ b/toolchain/check/testdata/return/fail_returned_var_shadow.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_returned_var_shadow.carbon @@ -100,8 +103,8 @@ fn DifferentScopes() -> i32 { // CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc11: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc11: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc14: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc14: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } @@ -109,8 +112,8 @@ fn DifferentScopes() -> i32 { // CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc26: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc26: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc29: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc29: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } @@ -127,17 +130,17 @@ fn DifferentScopes() -> i32 { // CHECK:STDOUT: %v.var_patt: %pattern_type.7ce = var_pattern %v.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %v.var: ref %i32 = var %v.var_patt -// CHECK:STDOUT: %int_0.loc13: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc13: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc13_14.1: = bound_method %int_0.loc13, %impl.elem0.loc13 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc13: = specific_function %impl.elem0.loc13, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc13_14.2: = bound_method %int_0.loc13, %specific_fn.loc13 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc13: init %i32 = call %bound_method.loc13_14.2(%int_0.loc13) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc13_14: init %i32 = converted %int_0.loc13, %int.convert_checked.loc13 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: assign %v.var, %.loc13_14 -// CHECK:STDOUT: %.loc13_21: type = splice_block %i32.loc13 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc13: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc13: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_0.loc16: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] +// CHECK:STDOUT: %impl.elem0.loc16: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc16_14.1: = bound_method %int_0.loc16, %impl.elem0.loc16 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc16: = specific_function %impl.elem0.loc16, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc16_14.2: = bound_method %int_0.loc16, %specific_fn.loc16 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc16: init %i32 = call %bound_method.loc16_14.2(%int_0.loc16) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc16_14: init %i32 = converted %int_0.loc16, %int.convert_checked.loc16 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: assign %v.var, %.loc16_14 +// CHECK:STDOUT: %.loc16_21: type = splice_block %i32.loc16 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc16: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc16: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %v: ref %i32 = bind_name v, %v.var // CHECK:STDOUT: name_binding_decl { @@ -146,92 +149,92 @@ fn DifferentScopes() -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: %w.var: ref %i32 = var %w.var_patt // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] -// CHECK:STDOUT: %impl.elem0.loc21: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc21_14.1: = bound_method %int_1, %impl.elem0.loc21 [concrete = constants.%Convert.bound.ab5] -// CHECK:STDOUT: %specific_fn.loc21: = specific_function %impl.elem0.loc21, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc21_14.2: = bound_method %int_1, %specific_fn.loc21 [concrete = constants.%bound_method.9a1] -// CHECK:STDOUT: %int.convert_checked.loc21: init %i32 = call %bound_method.loc21_14.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc21_14: init %i32 = converted %int_1, %int.convert_checked.loc21 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: assign %w.var, %.loc21_14 -// CHECK:STDOUT: %.loc21_21: type = splice_block %i32.loc21 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc21: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc21: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %impl.elem0.loc24: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc24_14.1: = bound_method %int_1, %impl.elem0.loc24 [concrete = constants.%Convert.bound.ab5] +// CHECK:STDOUT: %specific_fn.loc24: = specific_function %impl.elem0.loc24, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc24_14.2: = bound_method %int_1, %specific_fn.loc24 [concrete = constants.%bound_method.9a1] +// CHECK:STDOUT: %int.convert_checked.loc24: init %i32 = call %bound_method.loc24_14.2(%int_1) [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc24_14: init %i32 = converted %int_1, %int.convert_checked.loc24 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: assign %w.var, %.loc24_14 +// CHECK:STDOUT: %.loc24_21: type = splice_block %i32.loc24 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc24: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc24: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %w: ref %i32 = bind_name w, %w.var // CHECK:STDOUT: br !if.else // CHECK:STDOUT: // CHECK:STDOUT: !if.else: -// CHECK:STDOUT: %int_0.loc23: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc23: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc23_11.1: = bound_method %int_0.loc23, %impl.elem0.loc23 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc23: = specific_function %impl.elem0.loc23, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc23_11.2: = bound_method %int_0.loc23, %specific_fn.loc23 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc23: init %i32 = call %bound_method.loc23_11.2(%int_0.loc23) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc23_11.1: %i32 = value_of_initializer %int.convert_checked.loc23 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc23_11.2: %i32 = converted %int_0.loc23, %.loc23_11.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc23_11.2 +// CHECK:STDOUT: %int_0.loc26: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] +// CHECK:STDOUT: %impl.elem0.loc26: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc26_11.1: = bound_method %int_0.loc26, %impl.elem0.loc26 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc26: = specific_function %impl.elem0.loc26, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc26_11.2: = bound_method %int_0.loc26, %specific_fn.loc26 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc26: init %i32 = call %bound_method.loc26_11.2(%int_0.loc26) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc26_11.1: %i32 = value_of_initializer %int.convert_checked.loc26 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc26_11.2: %i32 = converted %int_0.loc26, %.loc26_11.1 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: return %.loc26_11.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DifferentScopes() -> %i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %true.loc27: bool = bool_literal true [concrete = constants.%true] -// CHECK:STDOUT: if %true.loc27 br !if.then.loc27 else br !if.else.loc27 +// CHECK:STDOUT: %true.loc30: bool = bool_literal true [concrete = constants.%true] +// CHECK:STDOUT: if %true.loc30 br !if.then.loc30 else br !if.else.loc30 // CHECK:STDOUT: -// CHECK:STDOUT: !if.then.loc27: +// CHECK:STDOUT: !if.then.loc30: // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %v.patt: %pattern_type.7ce = binding_pattern v [concrete] // CHECK:STDOUT: %v.var_patt: %pattern_type.7ce = var_pattern %v.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %v.var: ref %i32 = var %v.var_patt -// CHECK:STDOUT: %int_0.loc28: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc28: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc28_14.1: = bound_method %int_0.loc28, %impl.elem0.loc28 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc28: = specific_function %impl.elem0.loc28, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc28_14.2: = bound_method %int_0.loc28, %specific_fn.loc28 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc28: init %i32 = call %bound_method.loc28_14.2(%int_0.loc28) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc28_14: init %i32 = converted %int_0.loc28, %int.convert_checked.loc28 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: assign %v.var, %.loc28_14 -// CHECK:STDOUT: %.loc28_21: type = splice_block %i32.loc28 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc28: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc28: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_0.loc31: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] +// CHECK:STDOUT: %impl.elem0.loc31: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc31_14.1: = bound_method %int_0.loc31, %impl.elem0.loc31 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc31: = specific_function %impl.elem0.loc31, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc31_14.2: = bound_method %int_0.loc31, %specific_fn.loc31 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc31: init %i32 = call %bound_method.loc31_14.2(%int_0.loc31) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc31_14: init %i32 = converted %int_0.loc31, %int.convert_checked.loc31 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: assign %v.var, %.loc31_14 +// CHECK:STDOUT: %.loc31_21: type = splice_block %i32.loc31 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc31: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc31: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %v: ref %i32 = bind_name v, %v.var -// CHECK:STDOUT: %true.loc29: bool = bool_literal true [concrete = constants.%true] -// CHECK:STDOUT: if %true.loc29 br !if.then.loc29 else br !if.else.loc29 +// CHECK:STDOUT: %true.loc32: bool = bool_literal true [concrete = constants.%true] +// CHECK:STDOUT: if %true.loc32 br !if.then.loc32 else br !if.else.loc32 // CHECK:STDOUT: -// CHECK:STDOUT: !if.then.loc29: +// CHECK:STDOUT: !if.then.loc32: // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %w.patt: %pattern_type.7ce = binding_pattern w [concrete] // CHECK:STDOUT: %w.var_patt: %pattern_type.7ce = var_pattern %w.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %w.var: ref %i32 = var %w.var_patt // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] -// CHECK:STDOUT: %impl.elem0.loc37: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc37_16.1: = bound_method %int_1, %impl.elem0.loc37 [concrete = constants.%Convert.bound.ab5] -// CHECK:STDOUT: %specific_fn.loc37: = specific_function %impl.elem0.loc37, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc37_16.2: = bound_method %int_1, %specific_fn.loc37 [concrete = constants.%bound_method.9a1] -// CHECK:STDOUT: %int.convert_checked.loc37: init %i32 = call %bound_method.loc37_16.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc37_16: init %i32 = converted %int_1, %int.convert_checked.loc37 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: assign %w.var, %.loc37_16 -// CHECK:STDOUT: %.loc37_23: type = splice_block %i32.loc37 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc37: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc37: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %impl.elem0.loc40: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc40_16.1: = bound_method %int_1, %impl.elem0.loc40 [concrete = constants.%Convert.bound.ab5] +// CHECK:STDOUT: %specific_fn.loc40: = specific_function %impl.elem0.loc40, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc40_16.2: = bound_method %int_1, %specific_fn.loc40 [concrete = constants.%bound_method.9a1] +// CHECK:STDOUT: %int.convert_checked.loc40: init %i32 = call %bound_method.loc40_16.2(%int_1) [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc40_16: init %i32 = converted %int_1, %int.convert_checked.loc40 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: assign %w.var, %.loc40_16 +// CHECK:STDOUT: %.loc40_23: type = splice_block %i32.loc40 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc40: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc40: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %w: ref %i32 = bind_name w, %w.var -// CHECK:STDOUT: br !if.else.loc29 +// CHECK:STDOUT: br !if.else.loc32 // CHECK:STDOUT: -// CHECK:STDOUT: !if.else.loc29: -// CHECK:STDOUT: br !if.else.loc27 +// CHECK:STDOUT: !if.else.loc32: +// CHECK:STDOUT: br !if.else.loc30 // CHECK:STDOUT: -// CHECK:STDOUT: !if.else.loc27: -// CHECK:STDOUT: %int_0.loc40: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc40: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc40_11.1: = bound_method %int_0.loc40, %impl.elem0.loc40 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc40: = specific_function %impl.elem0.loc40, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc40_11.2: = bound_method %int_0.loc40, %specific_fn.loc40 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc40: init %i32 = call %bound_method.loc40_11.2(%int_0.loc40) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc40_11.1: %i32 = value_of_initializer %int.convert_checked.loc40 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc40_11.2: %i32 = converted %int_0.loc40, %.loc40_11.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc40_11.2 +// CHECK:STDOUT: !if.else.loc30: +// CHECK:STDOUT: %int_0.loc43: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] +// CHECK:STDOUT: %impl.elem0.loc43: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc43_11.1: = bound_method %int_0.loc43, %impl.elem0.loc43 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc43: = specific_function %impl.elem0.loc43, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc43_11.2: = bound_method %int_0.loc43, %specific_fn.loc43 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc43: init %i32 = call %bound_method.loc43_11.2(%int_0.loc43) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc43_11.1: %i32 = value_of_initializer %int.convert_checked.loc43 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc43_11.2: %i32 = converted %int_0.loc43, %.loc43_11.1 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: return %.loc43_11.2 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/fail_returned_var_type.carbon b/toolchain/check/testdata/return/fail_returned_var_type.carbon index c32b3dacd578..b687aaa25ec9 100644 --- a/toolchain/check/testdata/return/fail_returned_var_type.carbon +++ b/toolchain/check/testdata/return/fail_returned_var_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_returned_var_type.carbon @@ -74,14 +77,14 @@ fn Mismatch() -> i32 { // CHECK:STDOUT: %v.var: ref f64 = var %v.var_patt // CHECK:STDOUT: %float: f64 = float_literal 0 [concrete = constants.%float] // CHECK:STDOUT: assign %v.var, %float -// CHECK:STDOUT: %.loc19_19.1: type = splice_block %.loc19_19.3 [concrete = f64] { +// CHECK:STDOUT: %.loc22_19.1: type = splice_block %.loc22_19.3 [concrete = f64] { // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [concrete = constants.%int_64] // CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%int_64) [concrete = f64] -// CHECK:STDOUT: %.loc19_19.2: type = value_of_initializer %float.make_type [concrete = f64] -// CHECK:STDOUT: %.loc19_19.3: type = converted %float.make_type, %.loc19_19.2 [concrete = f64] +// CHECK:STDOUT: %.loc22_19.2: type = value_of_initializer %float.make_type [concrete = f64] +// CHECK:STDOUT: %.loc22_19.3: type = converted %float.make_type, %.loc22_19.2 [concrete = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %v: ref f64 = bind_name v, %v.var -// CHECK:STDOUT: %.loc19_16: f64 = bind_value %v -// CHECK:STDOUT: return %.loc19_16 +// CHECK:STDOUT: %.loc22_16: f64 = bind_value %v +// CHECK:STDOUT: return %.loc22_16 // 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 6460058ba7ba..c18bf352121a 100644 --- a/toolchain/check/testdata/return/fail_type_mismatch.carbon +++ b/toolchain/check/testdata/return/fail_type_mismatch.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_type_mismatch.carbon @@ -65,7 +68,7 @@ fn Main() -> i32 { // CHECK:STDOUT: fn @Main() -> %i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %float: f64 = float_literal 1 [concrete = constants.%float] -// CHECK:STDOUT: %.loc19: %i32 = converted %float, [concrete = ] +// CHECK:STDOUT: %.loc22: %i32 = converted %float, [concrete = ] // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/fail_value_disallowed.carbon b/toolchain/check/testdata/return/fail_value_disallowed.carbon index ec41791defc9..83bf6e74c65a 100644 --- a/toolchain/check/testdata/return/fail_value_disallowed.carbon +++ b/toolchain/check/testdata/return/fail_value_disallowed.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_value_disallowed.carbon diff --git a/toolchain/check/testdata/return/fail_value_missing.carbon b/toolchain/check/testdata/return/fail_value_missing.carbon index 8dd00b88fa9d..74b8d434c4e8 100644 --- a/toolchain/check/testdata/return/fail_value_missing.carbon +++ b/toolchain/check/testdata/return/fail_value_missing.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_value_missing.carbon diff --git a/toolchain/check/testdata/return/fail_var_in_type.carbon b/toolchain/check/testdata/return/fail_var_in_type.carbon index d1e389c5f18c..acd927743b85 100644 --- a/toolchain/check/testdata/return/fail_var_in_type.carbon +++ b/toolchain/check/testdata/return/fail_var_in_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/fail_var_in_type.carbon @@ -55,7 +58,7 @@ fn Six() -> x { return 6; } // CHECK:STDOUT: %return.param_patt: = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %x.ref: ref type = name_ref x, file.%x [concrete = file.%x.var] -// CHECK:STDOUT: %.loc16: type = bind_value %x.ref +// CHECK:STDOUT: %.loc19: type = bind_value %x.ref // CHECK:STDOUT: %return.param: ref = out_param call_param0 // CHECK:STDOUT: %return: ref = return_slot %return.param // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/return/min_prelude/import_convert_function.carbon b/toolchain/check/testdata/return/min_prelude/import_convert_function.carbon index 1729c71c1cad..dacdc5c0f061 100644 --- a/toolchain/check/testdata/return/min_prelude/import_convert_function.carbon +++ b/toolchain/check/testdata/return/min_prelude/import_convert_function.carbon @@ -2,6 +2,8 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present // INCLUDE-FILE: toolchain/testing/min_prelude/destroy.carbon // // AUTOUPDATE diff --git a/toolchain/check/testdata/return/missing_return_no_return_type.carbon b/toolchain/check/testdata/return/missing_return_no_return_type.carbon index b87cc57d0dfe..3e79e7c90edf 100644 --- a/toolchain/check/testdata/return/missing_return_no_return_type.carbon +++ b/toolchain/check/testdata/return/missing_return_no_return_type.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/missing_return_no_return_type.carbon diff --git a/toolchain/check/testdata/return/no_value.carbon b/toolchain/check/testdata/return/no_value.carbon index ef193d62d182..230b6319c536 100644 --- a/toolchain/check/testdata/return/no_value.carbon +++ b/toolchain/check/testdata/return/no_value.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/no_value.carbon diff --git a/toolchain/check/testdata/return/returned_var.carbon b/toolchain/check/testdata/return/returned_var.carbon index 52d71802db1f..d3f6fefc98ec 100644 --- a/toolchain/check/testdata/return/returned_var.carbon +++ b/toolchain/check/testdata/return/returned_var.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/returned_var.carbon @@ -95,7 +98,7 @@ fn G() -> i32 { // CHECK:STDOUT: %return.patt: %pattern_type.c48 = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.c48 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %C.ref.loc16: type = name_ref C, file.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %C.ref.loc19: type = name_ref C, file.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %return.param: ref %C = out_param call_param0 // CHECK:STDOUT: %return: ref %C = return_slot %return.param // CHECK:STDOUT: } @@ -103,28 +106,28 @@ fn G() -> i32 { // CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc21: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc21: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc24: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc24: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %int_32.loc12: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc12: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc12: %C.elem = field_decl a, element0 [concrete] -// CHECK:STDOUT: %int_32.loc13: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc13: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc13: %C.elem = field_decl b, element1 [concrete] +// CHECK:STDOUT: %int_32.loc15: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc15: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc15: %C.elem = field_decl a, element0 [concrete] +// CHECK:STDOUT: %int_32.loc16: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc16: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc16: %C.elem = field_decl b, element1 [concrete] // CHECK:STDOUT: %struct_type.a.b: type = struct_type {.a: %i32, .b: %i32} [concrete = constants.%struct_type.a.b.501] // CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b [concrete = constants.%complete_type.705] // CHECK:STDOUT: complete_type_witness = %complete_type // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C -// CHECK:STDOUT: .a = %.loc12 -// CHECK:STDOUT: .b = %.loc13 +// CHECK:STDOUT: .a = %.loc15 +// CHECK:STDOUT: .b = %.loc16 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() -> %return.param: %C { @@ -135,27 +138,27 @@ fn G() -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc] -// CHECK:STDOUT: %.loc17_43.1: %struct_type.a.b.cfd = struct_literal (%int_1, %int_2) -// CHECK:STDOUT: %impl.elem0.loc17_43.1: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc17_43.1: = bound_method %int_1, %impl.elem0.loc17_43.1 [concrete = constants.%Convert.bound.ab5] -// CHECK:STDOUT: %specific_fn.loc17_43.1: = specific_function %impl.elem0.loc17_43.1, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc17_43.2: = bound_method %int_1, %specific_fn.loc17_43.1 [concrete = constants.%bound_method.9a1] -// CHECK:STDOUT: %int.convert_checked.loc17_43.1: init %i32 = call %bound_method.loc17_43.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc17_43.2: init %i32 = converted %int_1, %int.convert_checked.loc17_43.1 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc17_43.3: ref %i32 = class_element_access %return, element0 -// CHECK:STDOUT: %.loc17_43.4: init %i32 = initialize_from %.loc17_43.2 to %.loc17_43.3 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %impl.elem0.loc17_43.2: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc17_43.3: = bound_method %int_2, %impl.elem0.loc17_43.2 [concrete = constants.%Convert.bound.ef9] -// CHECK:STDOUT: %specific_fn.loc17_43.2: = specific_function %impl.elem0.loc17_43.2, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc17_43.4: = bound_method %int_2, %specific_fn.loc17_43.2 [concrete = constants.%bound_method.b92] -// CHECK:STDOUT: %int.convert_checked.loc17_43.2: init %i32 = call %bound_method.loc17_43.4(%int_2) [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc17_43.5: init %i32 = converted %int_2, %int.convert_checked.loc17_43.2 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc17_43.6: ref %i32 = class_element_access %return, element1 -// CHECK:STDOUT: %.loc17_43.7: init %i32 = initialize_from %.loc17_43.5 to %.loc17_43.6 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %.loc17_43.8: init %C = class_init (%.loc17_43.4, %.loc17_43.7), %return [concrete = constants.%C.val] -// CHECK:STDOUT: %.loc17_12: init %C = converted %.loc17_43.1, %.loc17_43.8 [concrete = constants.%C.val] -// CHECK:STDOUT: assign %return, %.loc17_12 -// CHECK:STDOUT: %C.ref.loc17: type = name_ref C, file.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %.loc20_43.1: %struct_type.a.b.cfd = struct_literal (%int_1, %int_2) +// CHECK:STDOUT: %impl.elem0.loc20_43.1: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc20_43.1: = bound_method %int_1, %impl.elem0.loc20_43.1 [concrete = constants.%Convert.bound.ab5] +// CHECK:STDOUT: %specific_fn.loc20_43.1: = specific_function %impl.elem0.loc20_43.1, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc20_43.2: = bound_method %int_1, %specific_fn.loc20_43.1 [concrete = constants.%bound_method.9a1] +// CHECK:STDOUT: %int.convert_checked.loc20_43.1: init %i32 = call %bound_method.loc20_43.2(%int_1) [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc20_43.2: init %i32 = converted %int_1, %int.convert_checked.loc20_43.1 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc20_43.3: ref %i32 = class_element_access %return, element0 +// CHECK:STDOUT: %.loc20_43.4: init %i32 = initialize_from %.loc20_43.2 to %.loc20_43.3 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %impl.elem0.loc20_43.2: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc20_43.3: = bound_method %int_2, %impl.elem0.loc20_43.2 [concrete = constants.%Convert.bound.ef9] +// CHECK:STDOUT: %specific_fn.loc20_43.2: = specific_function %impl.elem0.loc20_43.2, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc20_43.4: = bound_method %int_2, %specific_fn.loc20_43.2 [concrete = constants.%bound_method.b92] +// CHECK:STDOUT: %int.convert_checked.loc20_43.2: init %i32 = call %bound_method.loc20_43.4(%int_2) [concrete = constants.%int_2.ef8] +// CHECK:STDOUT: %.loc20_43.5: init %i32 = converted %int_2, %int.convert_checked.loc20_43.2 [concrete = constants.%int_2.ef8] +// CHECK:STDOUT: %.loc20_43.6: ref %i32 = class_element_access %return, element1 +// CHECK:STDOUT: %.loc20_43.7: init %i32 = initialize_from %.loc20_43.5 to %.loc20_43.6 [concrete = constants.%int_2.ef8] +// CHECK:STDOUT: %.loc20_43.8: init %C = class_init (%.loc20_43.4, %.loc20_43.7), %return [concrete = constants.%C.val] +// CHECK:STDOUT: %.loc20_12: init %C = converted %.loc20_43.1, %.loc20_43.8 [concrete = constants.%C.val] +// CHECK:STDOUT: assign %return, %.loc20_12 +// CHECK:STDOUT: %C.ref.loc20: type = name_ref C, file.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %result: ref %C = bind_name result, %return // CHECK:STDOUT: return %result to %return // CHECK:STDOUT: } @@ -169,18 +172,18 @@ fn G() -> i32 { // CHECK:STDOUT: %result.var: ref %i32 = var %result.var_patt // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] // CHECK:STDOUT: %impl.elem0: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc22_12.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %bound_method.loc25_12.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound.d04] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc22_12.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc22_12.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc22_12: init %i32 = converted %int_0, %int.convert_checked [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: assign %result.var, %.loc22_12 -// CHECK:STDOUT: %.loc22_24: type = splice_block %i32.loc22 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc22: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc22: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %bound_method.loc25_12.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc25_12.2(%int_0) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc25_12: init %i32 = converted %int_0, %int.convert_checked [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: assign %result.var, %.loc25_12 +// CHECK:STDOUT: %.loc25_24: type = splice_block %i32.loc25 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc25: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc25: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %result: ref %i32 = bind_name result, %result.var -// CHECK:STDOUT: %.loc22_16: %i32 = bind_value %result -// CHECK:STDOUT: return %.loc22_16 +// CHECK:STDOUT: %.loc25_16: %i32 = bind_value %result +// CHECK:STDOUT: return %.loc25_16 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/returned_var_scope.carbon b/toolchain/check/testdata/return/returned_var_scope.carbon index de0b84ecc721..3c89901e5a15 100644 --- a/toolchain/check/testdata/return/returned_var_scope.carbon +++ b/toolchain/check/testdata/return/returned_var_scope.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/returned_var_scope.carbon @@ -92,8 +95,8 @@ fn EnclosingButAfter(b: bool) -> i32 { // CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc11: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc11: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc14: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc14: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } @@ -103,13 +106,13 @@ fn EnclosingButAfter(b: bool) -> i32 { // CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param1 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc21: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc21: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc24: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc24: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: %b.param: bool = value_param call_param0 -// CHECK:STDOUT: %.loc21_25.1: type = splice_block %.loc21_25.3 [concrete = bool] { +// CHECK:STDOUT: %.loc24_25.1: type = splice_block %.loc24_25.3 [concrete = bool] { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [concrete = bool] -// CHECK:STDOUT: %.loc21_25.2: type = value_of_initializer %bool.make_type [concrete = bool] -// CHECK:STDOUT: %.loc21_25.3: type = converted %bool.make_type, %.loc21_25.2 [concrete = bool] +// CHECK:STDOUT: %.loc24_25.2: type = value_of_initializer %bool.make_type [concrete = bool] +// CHECK:STDOUT: %.loc24_25.3: type = converted %bool.make_type, %.loc24_25.2 [concrete = bool] // CHECK:STDOUT: } // CHECK:STDOUT: %b: bool = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref %i32 = out_param call_param1 @@ -119,65 +122,65 @@ fn EnclosingButAfter(b: bool) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: fn @UnrelatedScopes() -> %i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %true.loc12: bool = bool_literal true [concrete = constants.%true] -// CHECK:STDOUT: if %true.loc12 br !if.then.loc12 else br !if.else.loc12 +// CHECK:STDOUT: %true.loc15: bool = bool_literal true [concrete = constants.%true] +// CHECK:STDOUT: if %true.loc15 br !if.then.loc15 else br !if.else.loc15 // CHECK:STDOUT: -// CHECK:STDOUT: !if.then.loc12: +// CHECK:STDOUT: !if.then.loc15: // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %v.patt: %pattern_type.7ce = binding_pattern v [concrete] // CHECK:STDOUT: %v.var_patt: %pattern_type.7ce = var_pattern %v.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %v.var: ref %i32 = var %v.var_patt -// CHECK:STDOUT: %int_0.loc13: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc13: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc13_14.1: = bound_method %int_0.loc13, %impl.elem0.loc13 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc13: = specific_function %impl.elem0.loc13, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc13_14.2: = bound_method %int_0.loc13, %specific_fn.loc13 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc13: init %i32 = call %bound_method.loc13_14.2(%int_0.loc13) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc13_14: init %i32 = converted %int_0.loc13, %int.convert_checked.loc13 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: assign %v.var, %.loc13_14 -// CHECK:STDOUT: %.loc13_21: type = splice_block %i32.loc13 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc13: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc13: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_0.loc16: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] +// CHECK:STDOUT: %impl.elem0.loc16: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc16_14.1: = bound_method %int_0.loc16, %impl.elem0.loc16 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc16: = specific_function %impl.elem0.loc16, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc16_14.2: = bound_method %int_0.loc16, %specific_fn.loc16 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc16: init %i32 = call %bound_method.loc16_14.2(%int_0.loc16) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc16_14: init %i32 = converted %int_0.loc16, %int.convert_checked.loc16 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: assign %v.var, %.loc16_14 +// CHECK:STDOUT: %.loc16_21: type = splice_block %i32.loc16 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc16: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc16: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %v: ref %i32 = bind_name v, %v.var -// CHECK:STDOUT: br !if.else.loc12 +// CHECK:STDOUT: br !if.else.loc15 // CHECK:STDOUT: -// CHECK:STDOUT: !if.else.loc12: -// CHECK:STDOUT: %true.loc15: bool = bool_literal true [concrete = constants.%true] -// CHECK:STDOUT: if %true.loc15 br !if.then.loc15 else br !if.else.loc15 +// CHECK:STDOUT: !if.else.loc15: +// CHECK:STDOUT: %true.loc18: bool = bool_literal true [concrete = constants.%true] +// CHECK:STDOUT: if %true.loc18 br !if.then.loc18 else br !if.else.loc18 // CHECK:STDOUT: -// CHECK:STDOUT: !if.then.loc15: +// CHECK:STDOUT: !if.then.loc18: // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %w.patt: %pattern_type.7ce = binding_pattern w [concrete] // CHECK:STDOUT: %w.var_patt: %pattern_type.7ce = var_pattern %w.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %w.var: ref %i32 = var %w.var_patt // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] -// CHECK:STDOUT: %impl.elem0.loc16: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc16_14.1: = bound_method %int_1, %impl.elem0.loc16 [concrete = constants.%Convert.bound.ab5] -// CHECK:STDOUT: %specific_fn.loc16: = specific_function %impl.elem0.loc16, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc16_14.2: = bound_method %int_1, %specific_fn.loc16 [concrete = constants.%bound_method.9a1] -// CHECK:STDOUT: %int.convert_checked.loc16: init %i32 = call %bound_method.loc16_14.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc16_14: init %i32 = converted %int_1, %int.convert_checked.loc16 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: assign %w.var, %.loc16_14 -// CHECK:STDOUT: %.loc16_21: type = splice_block %i32.loc16 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc16: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc16: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %impl.elem0.loc19: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc19_14.1: = bound_method %int_1, %impl.elem0.loc19 [concrete = constants.%Convert.bound.ab5] +// CHECK:STDOUT: %specific_fn.loc19: = specific_function %impl.elem0.loc19, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc19_14.2: = bound_method %int_1, %specific_fn.loc19 [concrete = constants.%bound_method.9a1] +// CHECK:STDOUT: %int.convert_checked.loc19: init %i32 = call %bound_method.loc19_14.2(%int_1) [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc19_14: init %i32 = converted %int_1, %int.convert_checked.loc19 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: assign %w.var, %.loc19_14 +// CHECK:STDOUT: %.loc19_21: type = splice_block %i32.loc19 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc19: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc19: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %w: ref %i32 = bind_name w, %w.var -// CHECK:STDOUT: br !if.else.loc15 +// CHECK:STDOUT: br !if.else.loc18 // CHECK:STDOUT: -// CHECK:STDOUT: !if.else.loc15: -// CHECK:STDOUT: %int_0.loc18: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc18: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc18_11.1: = bound_method %int_0.loc18, %impl.elem0.loc18 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc18: = specific_function %impl.elem0.loc18, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc18_11.2: = bound_method %int_0.loc18, %specific_fn.loc18 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc18: init %i32 = call %bound_method.loc18_11.2(%int_0.loc18) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc18_11.1: %i32 = value_of_initializer %int.convert_checked.loc18 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc18_11.2: %i32 = converted %int_0.loc18, %.loc18_11.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc18_11.2 +// CHECK:STDOUT: !if.else.loc18: +// CHECK:STDOUT: %int_0.loc21: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] +// CHECK:STDOUT: %impl.elem0.loc21: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc21_11.1: = bound_method %int_0.loc21, %impl.elem0.loc21 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc21: = specific_function %impl.elem0.loc21, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc21_11.2: = bound_method %int_0.loc21, %specific_fn.loc21 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc21: init %i32 = call %bound_method.loc21_11.2(%int_0.loc21) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc21_11.1: %i32 = value_of_initializer %int.convert_checked.loc21 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc21_11.2: %i32 = converted %int_0.loc21, %.loc21_11.1 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: return %.loc21_11.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @EnclosingButAfter(%b.param: bool) -> %i32 { @@ -192,20 +195,20 @@ fn EnclosingButAfter(b: bool) -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: %v.var: ref %i32 = var %v.var_patt // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %impl.elem0.loc23: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc23_14.1: = bound_method %int_0, %impl.elem0.loc23 [concrete = constants.%Convert.bound.d04] -// CHECK:STDOUT: %specific_fn.loc23: = specific_function %impl.elem0.loc23, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc23_14.2: = bound_method %int_0, %specific_fn.loc23 [concrete = constants.%bound_method.b6e] -// CHECK:STDOUT: %int.convert_checked.loc23: init %i32 = call %bound_method.loc23_14.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc23_14: init %i32 = converted %int_0, %int.convert_checked.loc23 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: assign %v.var, %.loc23_14 -// CHECK:STDOUT: %.loc23_21: type = splice_block %i32.loc23 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc23: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc23: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %impl.elem0.loc26: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc26_14.1: = bound_method %int_0, %impl.elem0.loc26 [concrete = constants.%Convert.bound.d04] +// CHECK:STDOUT: %specific_fn.loc26: = specific_function %impl.elem0.loc26, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc26_14.2: = bound_method %int_0, %specific_fn.loc26 [concrete = constants.%bound_method.b6e] +// CHECK:STDOUT: %int.convert_checked.loc26: init %i32 = call %bound_method.loc26_14.2(%int_0) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc26_14: init %i32 = converted %int_0, %int.convert_checked.loc26 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: assign %v.var, %.loc26_14 +// CHECK:STDOUT: %.loc26_21: type = splice_block %i32.loc26 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc26: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc26: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %v: ref %i32 = bind_name v, %v.var -// CHECK:STDOUT: %.loc23_18: %i32 = bind_value %v -// CHECK:STDOUT: return %.loc23_18 +// CHECK:STDOUT: %.loc26_18: %i32 = bind_value %v +// CHECK:STDOUT: return %.loc26_18 // CHECK:STDOUT: // CHECK:STDOUT: !if.else: // CHECK:STDOUT: name_binding_decl { @@ -214,19 +217,19 @@ fn EnclosingButAfter(b: bool) -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: %w.var: ref %i32 = var %w.var_patt // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] -// CHECK:STDOUT: %impl.elem0.loc26: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc26_12.1: = bound_method %int_1, %impl.elem0.loc26 [concrete = constants.%Convert.bound.ab5] -// CHECK:STDOUT: %specific_fn.loc26: = specific_function %impl.elem0.loc26, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc26_12.2: = bound_method %int_1, %specific_fn.loc26 [concrete = constants.%bound_method.9a1] -// CHECK:STDOUT: %int.convert_checked.loc26: init %i32 = call %bound_method.loc26_12.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc26_12: init %i32 = converted %int_1, %int.convert_checked.loc26 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: assign %w.var, %.loc26_12 -// CHECK:STDOUT: %.loc26_19: type = splice_block %i32.loc26 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc26: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc26: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %impl.elem0.loc29: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc29_12.1: = bound_method %int_1, %impl.elem0.loc29 [concrete = constants.%Convert.bound.ab5] +// CHECK:STDOUT: %specific_fn.loc29: = specific_function %impl.elem0.loc29, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc29_12.2: = bound_method %int_1, %specific_fn.loc29 [concrete = constants.%bound_method.9a1] +// CHECK:STDOUT: %int.convert_checked.loc29: init %i32 = call %bound_method.loc29_12.2(%int_1) [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: %.loc29_12: init %i32 = converted %int_1, %int.convert_checked.loc29 [concrete = constants.%int_1.5d2] +// CHECK:STDOUT: assign %w.var, %.loc29_12 +// CHECK:STDOUT: %.loc29_19: type = splice_block %i32.loc29 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc29: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc29: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %w: ref %i32 = bind_name w, %w.var -// CHECK:STDOUT: %.loc26_16: %i32 = bind_value %w -// CHECK:STDOUT: return %.loc26_16 +// CHECK:STDOUT: %.loc29_16: %i32 = bind_value %w +// CHECK:STDOUT: return %.loc29_16 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/struct.carbon b/toolchain/check/testdata/return/struct.carbon index 8c516252011c..6c619f5922e5 100644 --- a/toolchain/check/testdata/return/struct.carbon +++ b/toolchain/check/testdata/return/struct.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/struct.carbon @@ -78,16 +81,16 @@ fn Main() -> {.a: i32} { // CHECK:STDOUT: fn @Main() -> %struct_type.a.ba9 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3.1ba] -// CHECK:STDOUT: %.loc12_17.1: %struct_type.a.a6c = struct_literal (%int_3) +// CHECK:STDOUT: %.loc15_17.1: %struct_type.a.a6c = struct_literal (%int_3) // CHECK:STDOUT: %impl.elem0: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc12_17.1: = bound_method %int_3, %impl.elem0 [concrete = constants.%Convert.bound] +// CHECK:STDOUT: %bound_method.loc15_17.1: = bound_method %int_3, %impl.elem0 [concrete = constants.%Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc12_17.2: = bound_method %int_3, %specific_fn [concrete = constants.%bound_method] -// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc12_17.2(%int_3) [concrete = constants.%int_3.822] -// CHECK:STDOUT: %.loc12_17.2: %i32 = value_of_initializer %int.convert_checked [concrete = constants.%int_3.822] -// CHECK:STDOUT: %.loc12_17.3: %i32 = converted %int_3, %.loc12_17.2 [concrete = constants.%int_3.822] -// CHECK:STDOUT: %struct: %struct_type.a.ba9 = struct_value (%.loc12_17.3) [concrete = constants.%struct] -// CHECK:STDOUT: %.loc12_18: %struct_type.a.ba9 = converted %.loc12_17.1, %struct [concrete = constants.%struct] -// CHECK:STDOUT: return %.loc12_18 +// CHECK:STDOUT: %bound_method.loc15_17.2: = bound_method %int_3, %specific_fn [concrete = constants.%bound_method] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc15_17.2(%int_3) [concrete = constants.%int_3.822] +// CHECK:STDOUT: %.loc15_17.2: %i32 = value_of_initializer %int.convert_checked [concrete = constants.%int_3.822] +// CHECK:STDOUT: %.loc15_17.3: %i32 = converted %int_3, %.loc15_17.2 [concrete = constants.%int_3.822] +// CHECK:STDOUT: %struct: %struct_type.a.ba9 = struct_value (%.loc15_17.3) [concrete = constants.%struct] +// CHECK:STDOUT: %.loc15_18: %struct_type.a.ba9 = converted %.loc15_17.1, %struct [concrete = constants.%struct] +// CHECK:STDOUT: return %.loc15_18 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/tuple.carbon b/toolchain/check/testdata/return/tuple.carbon index 11c92c44dd43..f5505ab7eef2 100644 --- a/toolchain/check/testdata/return/tuple.carbon +++ b/toolchain/check/testdata/return/tuple.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/tuple.carbon @@ -73,12 +76,12 @@ fn Main() -> (i32, i32) { // CHECK:STDOUT: %return.patt: %pattern_type.511 = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.511 = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc12_15: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc12_15: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc12_20: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc12_20: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc12_23.1: %tuple.type.24b = tuple_literal (%i32.loc12_15, %i32.loc12_20) -// CHECK:STDOUT: %.loc12_23.2: type = converted %.loc12_23.1, constants.%tuple.type.d07 [concrete = constants.%tuple.type.d07] +// CHECK:STDOUT: %int_32.loc15_15: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc15_15: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc15_20: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc15_20: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc15_23.1: %tuple.type.24b = tuple_literal (%i32.loc15_15, %i32.loc15_20) +// CHECK:STDOUT: %.loc15_23.2: type = converted %.loc15_23.1, constants.%tuple.type.d07 [concrete = constants.%tuple.type.d07] // CHECK:STDOUT: %return.param: ref %tuple.type.d07 = out_param call_param0 // CHECK:STDOUT: %return: ref %tuple.type.d07 = return_slot %return.param // CHECK:STDOUT: } @@ -88,25 +91,25 @@ fn Main() -> (i32, i32) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %int_15: Core.IntLiteral = int_value 15 [concrete = constants.%int_15.447] // CHECK:STDOUT: %int_35: Core.IntLiteral = int_value 35 [concrete = constants.%int_35.c79] -// CHECK:STDOUT: %.loc13_17.1: %tuple.type.f94 = tuple_literal (%int_15, %int_35) -// CHECK:STDOUT: %impl.elem0.loc13_17.1: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc13_17.1: = bound_method %int_15, %impl.elem0.loc13_17.1 [concrete = constants.%Convert.bound.75f] -// CHECK:STDOUT: %specific_fn.loc13_17.1: = specific_function %impl.elem0.loc13_17.1, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc13_17.2: = bound_method %int_15, %specific_fn.loc13_17.1 [concrete = constants.%bound_method.984] -// CHECK:STDOUT: %int.convert_checked.loc13_17.1: init %i32 = call %bound_method.loc13_17.2(%int_15) [concrete = constants.%int_15.7f7] -// CHECK:STDOUT: %.loc13_17.2: init %i32 = converted %int_15, %int.convert_checked.loc13_17.1 [concrete = constants.%int_15.7f7] +// CHECK:STDOUT: %.loc16_17.1: %tuple.type.f94 = tuple_literal (%int_15, %int_35) +// CHECK:STDOUT: %impl.elem0.loc16_17.1: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc16_17.1: = bound_method %int_15, %impl.elem0.loc16_17.1 [concrete = constants.%Convert.bound.75f] +// CHECK:STDOUT: %specific_fn.loc16_17.1: = specific_function %impl.elem0.loc16_17.1, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc16_17.2: = bound_method %int_15, %specific_fn.loc16_17.1 [concrete = constants.%bound_method.984] +// CHECK:STDOUT: %int.convert_checked.loc16_17.1: init %i32 = call %bound_method.loc16_17.2(%int_15) [concrete = constants.%int_15.7f7] +// CHECK:STDOUT: %.loc16_17.2: init %i32 = converted %int_15, %int.convert_checked.loc16_17.1 [concrete = constants.%int_15.7f7] // CHECK:STDOUT: %tuple.elem0: ref %i32 = tuple_access %return, element0 -// CHECK:STDOUT: %.loc13_17.3: init %i32 = initialize_from %.loc13_17.2 to %tuple.elem0 [concrete = constants.%int_15.7f7] -// CHECK:STDOUT: %impl.elem0.loc13_17.2: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc13_17.3: = bound_method %int_35, %impl.elem0.loc13_17.2 [concrete = constants.%Convert.bound.76a] -// CHECK:STDOUT: %specific_fn.loc13_17.2: = specific_function %impl.elem0.loc13_17.2, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc13_17.4: = bound_method %int_35, %specific_fn.loc13_17.2 [concrete = constants.%bound_method.231] -// CHECK:STDOUT: %int.convert_checked.loc13_17.2: init %i32 = call %bound_method.loc13_17.4(%int_35) [concrete = constants.%int_35.c78] -// CHECK:STDOUT: %.loc13_17.4: init %i32 = converted %int_35, %int.convert_checked.loc13_17.2 [concrete = constants.%int_35.c78] +// CHECK:STDOUT: %.loc16_17.3: init %i32 = initialize_from %.loc16_17.2 to %tuple.elem0 [concrete = constants.%int_15.7f7] +// CHECK:STDOUT: %impl.elem0.loc16_17.2: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] +// CHECK:STDOUT: %bound_method.loc16_17.3: = bound_method %int_35, %impl.elem0.loc16_17.2 [concrete = constants.%Convert.bound.76a] +// CHECK:STDOUT: %specific_fn.loc16_17.2: = specific_function %impl.elem0.loc16_17.2, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc16_17.4: = bound_method %int_35, %specific_fn.loc16_17.2 [concrete = constants.%bound_method.231] +// CHECK:STDOUT: %int.convert_checked.loc16_17.2: init %i32 = call %bound_method.loc16_17.4(%int_35) [concrete = constants.%int_35.c78] +// CHECK:STDOUT: %.loc16_17.4: init %i32 = converted %int_35, %int.convert_checked.loc16_17.2 [concrete = constants.%int_35.c78] // CHECK:STDOUT: %tuple.elem1: ref %i32 = tuple_access %return, element1 -// CHECK:STDOUT: %.loc13_17.5: init %i32 = initialize_from %.loc13_17.4 to %tuple.elem1 [concrete = constants.%int_35.c78] -// CHECK:STDOUT: %.loc13_17.6: init %tuple.type.d07 = tuple_init (%.loc13_17.3, %.loc13_17.5) to %return [concrete = constants.%tuple] -// CHECK:STDOUT: %.loc13_18: init %tuple.type.d07 = converted %.loc13_17.1, %.loc13_17.6 [concrete = constants.%tuple] -// CHECK:STDOUT: return %.loc13_18 to %return +// CHECK:STDOUT: %.loc16_17.5: init %i32 = initialize_from %.loc16_17.4 to %tuple.elem1 [concrete = constants.%int_35.c78] +// CHECK:STDOUT: %.loc16_17.6: init %tuple.type.d07 = tuple_init (%.loc16_17.3, %.loc16_17.5) to %return [concrete = constants.%tuple] +// CHECK:STDOUT: %.loc16_18: init %tuple.type.d07 = converted %.loc16_17.1, %.loc16_17.6 [concrete = constants.%tuple] +// CHECK:STDOUT: return %.loc16_18 to %return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/value.carbon b/toolchain/check/testdata/return/value.carbon index 02346a5dc267..35bf15b2828c 100644 --- a/toolchain/check/testdata/return/value.carbon +++ b/toolchain/check/testdata/return/value.carbon @@ -2,6 +2,9 @@ // Exceptions. See /LICENSE for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // +// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". +// EXTRA-ARGS: --dump-sem-ir-ranges=if-present +// // AUTOUPDATE // TIP: To test this file alone, run: // TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/return/value.carbon @@ -75,12 +78,12 @@ fn Main() -> i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] // CHECK:STDOUT: %impl.elem0: %.9c3 = impl_witness_access constants.%ImplicitAs.impl_witness.c75, element0 [concrete = constants.%Convert.956] -// CHECK:STDOUT: %bound_method.loc12_11.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound] +// CHECK:STDOUT: %bound_method.loc15_11.1: = bound_method %int_0, %impl.elem0 [concrete = constants.%Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Convert.2(constants.%int_32) [concrete = constants.%Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc12_11.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] -// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc12_11.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc12_11.1: %i32 = value_of_initializer %int.convert_checked [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc12_11.2: %i32 = converted %int_0, %.loc12_11.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: return %.loc12_11.2 +// CHECK:STDOUT: %bound_method.loc15_11.2: = bound_method %int_0, %specific_fn [concrete = constants.%bound_method] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %bound_method.loc15_11.2(%int_0) [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc15_11.1: %i32 = value_of_initializer %int.convert_checked [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: %.loc15_11.2: %i32 = converted %int_0, %.loc15_11.1 [concrete = constants.%int_0.6a9] +// CHECK:STDOUT: return %.loc15_11.2 // CHECK:STDOUT: } // CHECK:STDOUT: