carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-05 22:02:55 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

More instructions get named (#4615)

Browse Source 
Goal is to reduce churn in names in test updates (by churning a lot of
them in this PR).

---------

Co-authored-by: Josh L <josh11b@users.noreply.github.com>
This commit is contained in:
josh11b
2024-12-03 20:47:53 +00:00
committed by GitHub
co-authored by Josh L
parent 48a84ca55d
commit 5d1b39e1f2
549 changed files with 30568 additions and 30383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
toolchain/check/testdata/function/generic/deduce.carbon
Vendored
+329 -329
View File
File diff suppressed because it is too large Load Diff
toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon
Vendored
+28 -28
View File
@@ -16,19 +16,19 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT: --- fail_todo_param_in_type.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %i32: type = int_type signed, %.1 [template]
// CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template]
// CHECK:STDOUT: %N.1: %i32 = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt.1: %i32 = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template]
// CHECK:STDOUT: %Convert.type.13: type = fn_type @Convert.4, @impl.3(%.1) [template]
// CHECK:STDOUT: %Convert.type.13: type = fn_type @Convert.4, @impl.3(%int_32) [template]
// CHECK:STDOUT: %Convert.13: %Convert.type.13 = struct_value () [template]
// CHECK:STDOUT: %.23: <witness> = interface_witness (%Convert.13) [template]
// CHECK:STDOUT: %.24: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
// CHECK:STDOUT: %.25: <specific function> = specific_function %.24, @Convert.4(%.1) [symbolic]
// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %.25(%N.1) [symbolic]
// CHECK:STDOUT: %interface.9: <witness> = interface_witness (%Convert.13) [template]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %N.1, %Convert.13 [symbolic]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.4(%int_32) [symbolic]
// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.1) [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: }
@@ -54,23 +54,23 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT: %a.patt: <error> = binding_pattern a
// CHECK:STDOUT: %a.param_patt: <error> = value_param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc14_10.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc14_10: init type = call constants.%Int(%.loc14_10.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc14_10.2: type = value_of_initializer %int.make_type_signed.loc14_10 [template = constants.%i32]
// CHECK:STDOUT: %.loc14_10.3: type = converted %int.make_type_signed.loc14_10, %.loc14_10.2 [template = constants.%i32]
// CHECK:STDOUT: %.loc14_19.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc14_19: init type = call constants.%Int(%.loc14_19.1) [template = constants.%i32]
// CHECK:STDOUT: %int_32.loc14_10: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc14_10: init type = call constants.%Int(%int_32.loc14_10) [template = constants.%i32]
// CHECK:STDOUT: %.loc14_10.1: type = value_of_initializer %int.make_type_signed.loc14_10 [template = constants.%i32]
// CHECK:STDOUT: %.loc14_10.2: type = converted %int.make_type_signed.loc14_10, %.loc14_10.1 [template = constants.%i32]
// CHECK:STDOUT: %int_32.loc14_19: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc14_19: init type = call constants.%Int(%int_32.loc14_19) [template = constants.%i32]
// CHECK:STDOUT: %N.ref: %i32 = name_ref N, %N.loc14_6.1 [symbolic = %N.loc14_6.2 (constants.%N.1)]
// CHECK:STDOUT: %.loc14_19.2: type = value_of_initializer %int.make_type_signed.loc14_19 [template = constants.%i32]
// CHECK:STDOUT: %.loc14_19.3: type = converted %int.make_type_signed.loc14_19, %.loc14_19.2 [template = constants.%i32]
// CHECK:STDOUT: %.loc14_24.1: %Convert.type.2 = interface_witness_access constants.%.23, element0 [template = constants.%Convert.13]
// CHECK:STDOUT: %.loc14_24.2: <bound method> = bound_method %N.ref, %.loc14_24.1 [symbolic = %.loc14_24.6 (constants.%.24)]
// CHECK:STDOUT: %.loc14_24.3: <specific function> = specific_function %.loc14_24.2, @Convert.4(constants.%.1) [symbolic = %.loc14_24.7 (constants.%.25)]
// CHECK:STDOUT: %int.convert_checked.loc14_24.1: init Core.IntLiteral = call %.loc14_24.3(%N.ref) [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %.loc14_24.4: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_24.1 [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %.loc14_24.5: Core.IntLiteral = converted %N.ref, %.loc14_24.4 [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %.loc14_25: type = array_type %.loc14_24.5, %i32 [template = <error>]
// CHECK:STDOUT: %.loc14_26: type = ptr_type <error> [template = <error>]
// CHECK:STDOUT: %.loc14_19.1: type = value_of_initializer %int.make_type_signed.loc14_19 [template = constants.%i32]
// CHECK:STDOUT: %.loc14_19.2: type = converted %int.make_type_signed.loc14_19, %.loc14_19.1 [template = constants.%i32]
// CHECK:STDOUT: %impl.elem0: %Convert.type.2 = interface_witness_access constants.%interface.9, element0 [template = constants.%Convert.13]
// CHECK:STDOUT: %Convert.bound.loc14_24.1: <bound method> = bound_method %N.ref, %impl.elem0 [symbolic = %Convert.bound.loc14_24.2 (constants.%Convert.bound)]
// CHECK:STDOUT: %Convert.specific_fn.loc14_24.1: <specific function> = specific_function %Convert.bound.loc14_24.1, @Convert.4(constants.%int_32) [symbolic = %Convert.specific_fn.loc14_24.2 (constants.%Convert.specific_fn)]
// CHECK:STDOUT: %int.convert_checked.loc14_24.1: init Core.IntLiteral = call %Convert.specific_fn.loc14_24.1(%N.ref) [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %.loc14_24.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_24.1 [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %.loc14_24.2: Core.IntLiteral = converted %N.ref, %.loc14_24.1 [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %array_type: type = array_type %.loc14_24.2, %i32 [template = <error>]
// CHECK:STDOUT: %ptr: type = ptr_type <error> [template = <error>]
// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc14_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc14_6.2 (constants.%N.1)]
// CHECK:STDOUT: %a.param: <error> = value_param runtime_param0
@@ -81,9 +81,9 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT: generic fn @F(%N.loc14_6.1: %i32) {
// CHECK:STDOUT: %N.loc14_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc14_6.2 (constants.%N.1)]
// CHECK:STDOUT: %N.patt.loc14_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc14_6.2 (constants.%N.patt.1)]
// CHECK:STDOUT: %.loc14_24.6: <bound method> = bound_method %N.loc14_6.2, constants.%Convert.13 [symbolic = %.loc14_24.6 (constants.%.24)]
// CHECK:STDOUT: %.loc14_24.7: <specific function> = specific_function %.loc14_24.6, @Convert.4(constants.%.1) [symbolic = %.loc14_24.7 (constants.%.25)]
// CHECK:STDOUT: %int.convert_checked.loc14_24.2: init Core.IntLiteral = call %.loc14_24.7(%N.loc14_6.2) [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT: %Convert.bound.loc14_24.2: <bound method> = bound_method %N.loc14_6.2, constants.%Convert.13 [symbolic = %Convert.bound.loc14_24.2 (constants.%Convert.bound)]
// CHECK:STDOUT: %Convert.specific_fn.loc14_24.2: <specific function> = specific_function %Convert.bound.loc14_24.2, @Convert.4(constants.%int_32) [symbolic = %Convert.specific_fn.loc14_24.2 (constants.%Convert.specific_fn)]
// CHECK:STDOUT: %int.convert_checked.loc14_24.2: init Core.IntLiteral = call %Convert.specific_fn.loc14_24.2(%N.loc14_6.2) [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%N.param_patt: %i32, %a.param_patt: <error>);
// CHECK:STDOUT: }
@@ -91,8 +91,8 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT: specific @F(constants.%N.1) {
// CHECK:STDOUT: %N.loc14_6.2 => constants.%N.1
// CHECK:STDOUT: %N.patt.loc14_6.2 => constants.%N.1
// CHECK:STDOUT: %.loc14_24.6 => constants.%.24
// CHECK:STDOUT: %.loc14_24.7 => constants.%.25
// CHECK:STDOUT: %Convert.bound.loc14_24.2 => constants.%Convert.bound
// CHECK:STDOUT: %Convert.specific_fn.loc14_24.2 => constants.%Convert.specific_fn
// CHECK:STDOUT: %int.convert_checked.loc14_24.2 => constants.%int.convert_checked
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/call.carbon
Vendored
+77 -77
View File
@@ -61,17 +61,17 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %Function: %Function.type = struct_value () [template]
// CHECK:STDOUT: %CallGeneric.type: type = fn_type @CallGeneric [template]
// CHECK:STDOUT: %CallGeneric: %CallGeneric.type = struct_value () [template]
// CHECK:STDOUT: %.1: <specific function> = specific_function %Function, @Function(%T) [symbolic]
// CHECK:STDOUT: %.2: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %Function.specific_fn.1: <specific function> = specific_function %Function, @Function(%T) [symbolic]
// CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %CallGenericPtr.type: type = fn_type @CallGenericPtr [template]
// CHECK:STDOUT: %CallGenericPtr: %CallGenericPtr.type = struct_value () [template]
// CHECK:STDOUT: %.3: <specific function> = specific_function %Function, @Function(%.2) [symbolic]
// CHECK:STDOUT: %Function.specific_fn.2: <specific function> = specific_function %Function, @Function(%ptr.1) [symbolic]
// CHECK:STDOUT: %C: type = class_type @C [template]
// CHECK:STDOUT: %.4: type = struct_type {} [template]
// CHECK:STDOUT: %.5: <witness> = complete_type_witness %.4 [template]
// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template]
// CHECK:STDOUT: %CallSpecific.type: type = fn_type @CallSpecific [template]
// CHECK:STDOUT: %CallSpecific: %CallSpecific.type = struct_value () [template]
// CHECK:STDOUT: %.7: <specific function> = specific_function %Function, @Function(%C) [template]
// CHECK:STDOUT: %Function.specific_fn.3: <specific function> = specific_function %Function, @Function(%C) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -119,21 +119,21 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %CallGenericPtr.decl: %CallGenericPtr.type = fn_decl @CallGenericPtr [template = constants.%CallGenericPtr] {
// CHECK:STDOUT: %T.patt.loc12_19.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc12_19.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc12_19.1, runtime_param<invalid> [symbolic = %T.patt.loc12_19.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @CallGenericPtr.%.loc12_33.2 (%.2) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.2) = value_param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @CallGenericPtr.%.loc12_33.2 (%.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @CallGenericPtr.%.loc12_33.2 (%.2) = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %x.patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = value_param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref.loc12_32: type = name_ref T, %T.loc12_19.1 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %.loc12_33.1: type = ptr_type %T [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc12_33.1: type = ptr_type %T [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.ref.loc12_39: type = name_ref T, %T.loc12_19.1 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %.loc12_40: type = ptr_type %T [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc12_40: type = ptr_type %T [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc12_19.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @CallGenericPtr.%.loc12_33.2 (%.2) = value_param runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%.loc12_33.2 (%.2) = bind_name x, %x.param
// CHECK:STDOUT: %return.param: ref @CallGenericPtr.%.loc12_33.2 (%.2) = out_param runtime_param1
// CHECK:STDOUT: %return: ref @CallGenericPtr.%.loc12_33.2 (%.2) = return_slot %return.param
// CHECK:STDOUT: %x.param: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = value_param runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = bind_name x, %x.param
// CHECK:STDOUT: %return.param: ref @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = out_param runtime_param1
// CHECK:STDOUT: %return: ref @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %CallSpecific.decl: %CallSpecific.type = fn_decl @CallSpecific [template = constants.%CallSpecific] {
@@ -152,11 +152,11 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: class @C {
// CHECK:STDOUT: %.loc16: <witness> = complete_type_witness %.4 [template = constants.%.5]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template = constants.%complete_type]
// CHECK:STDOUT:
// CHECK:STDOUT: !members:
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: complete_type_witness = %.loc16
// CHECK:STDOUT: complete_type_witness = %complete_type
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Function(%T.loc4_13.1: type) {
@@ -177,15 +177,15 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %T.patt.loc8_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc9_10.2: <specific function> = specific_function constants.%Function, @Function(%T.loc8_16.2) [symbolic = %.loc9_10.2 (constants.%.1)]
// CHECK:STDOUT: %Function.specific_fn.loc9_10.2: <specific function> = specific_function constants.%Function, @Function(%T.loc8_16.2) [symbolic = %Function.specific_fn.loc9_10.2 (constants.%Function.specific_fn.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGeneric.%T.loc8_16.2 (%T)) -> @CallGeneric.%T.loc8_16.2 (%T) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Function.ref: %Function.type = name_ref Function, file.%Function.decl [template = constants.%Function]
// CHECK:STDOUT: %T.ref.loc9: type = name_ref T, %T.loc8_16.1 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %x.ref: @CallGeneric.%T.loc8_16.2 (%T) = name_ref x, %x
// CHECK:STDOUT: %.loc9_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%T) [symbolic = %.loc9_10.2 (constants.%.1)]
// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.loc8_16.2 (%T) = call %.loc9_10.1(%x.ref)
// CHECK:STDOUT: %Function.specific_fn.loc9_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%T) [symbolic = %Function.specific_fn.loc9_10.2 (constants.%Function.specific_fn.1)]
// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.loc8_16.2 (%T) = call %Function.specific_fn.loc9_10.1(%x.ref)
// CHECK:STDOUT: %.loc9_24.1: @CallGeneric.%T.loc8_16.2 (%T) = value_of_initializer %Function.call
// CHECK:STDOUT: %.loc9_24.2: @CallGeneric.%T.loc8_16.2 (%T) = converted %Function.call, %.loc9_24.1
// CHECK:STDOUT: return %.loc9_24.2
@@ -195,21 +195,21 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: generic fn @CallGenericPtr(%T.loc12_19.1: type) {
// CHECK:STDOUT: %T.loc12_19.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc12_19.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc12_19.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc13_10.2: <specific function> = specific_function constants.%Function, @Function(%.loc12_33.2) [symbolic = %.loc13_10.2 (constants.%.3)]
// CHECK:STDOUT: %Function.specific_fn.loc13_10.2: <specific function> = specific_function constants.%Function, @Function(%ptr.loc12_33.2) [symbolic = %Function.specific_fn.loc13_10.2 (constants.%Function.specific_fn.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.2)) -> @CallGenericPtr.%.loc12_33.2 (%.2) {
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1)) -> @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Function.ref: %Function.type = name_ref Function, file.%Function.decl [template = constants.%Function]
// CHECK:STDOUT: %T.ref.loc13: type = name_ref T, %T.loc12_19.1 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %.loc13_20: type = ptr_type %T [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %x.ref: @CallGenericPtr.%.loc12_33.2 (%.2) = name_ref x, %x
// CHECK:STDOUT: %.loc13_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%.2) [symbolic = %.loc13_10.2 (constants.%.3)]
// CHECK:STDOUT: %Function.call: init @CallGenericPtr.%.loc12_33.2 (%.2) = call %.loc13_10.1(%x.ref)
// CHECK:STDOUT: %.loc13_25.1: @CallGenericPtr.%.loc12_33.2 (%.2) = value_of_initializer %Function.call
// CHECK:STDOUT: %.loc13_25.2: @CallGenericPtr.%.loc12_33.2 (%.2) = converted %Function.call, %.loc13_25.1
// CHECK:STDOUT: %ptr.loc13: type = ptr_type %T [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT: %x.ref: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = name_ref x, %x
// CHECK:STDOUT: %Function.specific_fn.loc13_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%ptr.1) [symbolic = %Function.specific_fn.loc13_10.2 (constants.%Function.specific_fn.2)]
// CHECK:STDOUT: %Function.call: init @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = call %Function.specific_fn.loc13_10.1(%x.ref)
// CHECK:STDOUT: %.loc13_25.1: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = value_of_initializer %Function.call
// CHECK:STDOUT: %.loc13_25.2: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = converted %Function.call, %.loc13_25.1
// CHECK:STDOUT: return %.loc13_25.2
// CHECK:STDOUT: }
// CHECK:STDOUT: }
@@ -219,9 +219,9 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %Function.ref: %Function.type = name_ref Function, file.%Function.decl [template = constants.%Function]
// CHECK:STDOUT: %C.ref.loc19: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %x.ref: %C = name_ref x, %x
// CHECK:STDOUT: %.loc19: <specific function> = specific_function %Function.ref, @Function(constants.%C) [template = constants.%.7]
// CHECK:STDOUT: %Function.specific_fn: <specific function> = specific_function %Function.ref, @Function(constants.%C) [template = constants.%Function.specific_fn.3]
// CHECK:STDOUT: %.loc18_23.2: ref %C = splice_block %return {}
// CHECK:STDOUT: %Function.call: init %C = call %.loc19(%x.ref) to %.loc18_23.2
// CHECK:STDOUT: %Function.call: init %C = call %Function.specific_fn(%x.ref) to %.loc18_23.2
// CHECK:STDOUT: return %Function.call to %return
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -245,19 +245,19 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: specific @CallGenericPtr(constants.%T) {
// CHECK:STDOUT: %T.loc12_19.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc12_19.2 => constants.%T
// CHECK:STDOUT: %.loc12_33.2 => constants.%.2
// CHECK:STDOUT: %ptr.loc12_33.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.2
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.2
// CHECK:STDOUT: specific @Function(constants.%ptr.1) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(@CallGenericPtr.%.loc12_33.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.2
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.2
// CHECK:STDOUT: specific @Function(@CallGenericPtr.%ptr.loc12_33.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%C) {
@@ -276,17 +276,17 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %Function: %Function.type = struct_value () [template]
// CHECK:STDOUT: %CallGeneric.type: type = fn_type @CallGeneric [template]
// CHECK:STDOUT: %CallGeneric: %CallGeneric.type = struct_value () [template]
// CHECK:STDOUT: %.1: <specific function> = specific_function %Function, @Function(%T) [symbolic]
// CHECK:STDOUT: %.2: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %Function.specific_fn.1: <specific function> = specific_function %Function, @Function(%T) [symbolic]
// CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %CallGenericPtr.type: type = fn_type @CallGenericPtr [template]
// CHECK:STDOUT: %CallGenericPtr: %CallGenericPtr.type = struct_value () [template]
// CHECK:STDOUT: %.3: <specific function> = specific_function %Function, @Function(%.2) [symbolic]
// CHECK:STDOUT: %Function.specific_fn.2: <specific function> = specific_function %Function, @Function(%ptr.1) [symbolic]
// CHECK:STDOUT: %C: type = class_type @C [template]
// CHECK:STDOUT: %.4: type = struct_type {} [template]
// CHECK:STDOUT: %.5: <witness> = complete_type_witness %.4 [template]
// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template]
// CHECK:STDOUT: %CallSpecific.type: type = fn_type @CallSpecific [template]
// CHECK:STDOUT: %CallSpecific: %CallSpecific.type = struct_value () [template]
// CHECK:STDOUT: %.7: <specific function> = specific_function %Function, @Function(%C) [template]
// CHECK:STDOUT: %Function.specific_fn.3: <specific function> = specific_function %Function, @Function(%C) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -334,21 +334,21 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %CallGenericPtr.decl: %CallGenericPtr.type = fn_decl @CallGenericPtr [template = constants.%CallGenericPtr] {
// CHECK:STDOUT: %T.patt.loc12_19.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc12_19.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc12_19.1, runtime_param<invalid> [symbolic = %T.patt.loc12_19.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @CallGenericPtr.%.loc12_33.2 (%.2) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.2) = value_param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @CallGenericPtr.%.loc12_33.2 (%.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @CallGenericPtr.%.loc12_33.2 (%.2) = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %x.patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = value_param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref.loc12_32: type = name_ref T, %T.loc12_19.1 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %.loc12_33.1: type = ptr_type %T [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc12_33.1: type = ptr_type %T [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.ref.loc12_39: type = name_ref T, %T.loc12_19.1 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %.loc12_40: type = ptr_type %T [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc12_40: type = ptr_type %T [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc12_19.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @CallGenericPtr.%.loc12_33.2 (%.2) = value_param runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%.loc12_33.2 (%.2) = bind_name x, %x.param
// CHECK:STDOUT: %return.param: ref @CallGenericPtr.%.loc12_33.2 (%.2) = out_param runtime_param1
// CHECK:STDOUT: %return: ref @CallGenericPtr.%.loc12_33.2 (%.2) = return_slot %return.param
// CHECK:STDOUT: %x.param: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = value_param runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = bind_name x, %x.param
// CHECK:STDOUT: %return.param: ref @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = out_param runtime_param1
// CHECK:STDOUT: %return: ref @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %CallSpecific.decl: %CallSpecific.type = fn_decl @CallSpecific [template = constants.%CallSpecific] {
@@ -367,11 +367,11 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: class @C {
// CHECK:STDOUT: %.loc16: <witness> = complete_type_witness %.4 [template = constants.%.5]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template = constants.%complete_type]
// CHECK:STDOUT:
// CHECK:STDOUT: !members:
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: complete_type_witness = %.loc16
// CHECK:STDOUT: complete_type_witness = %complete_type
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Function(%T.loc4_13.1: type) {
@@ -392,14 +392,14 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: %T.patt.loc8_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc9_10.2: <specific function> = specific_function constants.%Function, @Function(%T.loc8_16.2) [symbolic = %.loc9_10.2 (constants.%.1)]
// CHECK:STDOUT: %Function.specific_fn.loc9_10.2: <specific function> = specific_function constants.%Function, @Function(%T.loc8_16.2) [symbolic = %Function.specific_fn.loc9_10.2 (constants.%Function.specific_fn.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGeneric.%T.loc8_16.2 (%T)) -> @CallGeneric.%T.loc8_16.2 (%T) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Function.ref: %Function.type = name_ref Function, file.%Function.decl [template = constants.%Function]
// CHECK:STDOUT: %x.ref: @CallGeneric.%T.loc8_16.2 (%T) = name_ref x, %x
// CHECK:STDOUT: %.loc9_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%T) [symbolic = %.loc9_10.2 (constants.%.1)]
// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.loc8_16.2 (%T) = call %.loc9_10.1(%x.ref)
// CHECK:STDOUT: %Function.specific_fn.loc9_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%T) [symbolic = %Function.specific_fn.loc9_10.2 (constants.%Function.specific_fn.1)]
// CHECK:STDOUT: %Function.call: init @CallGeneric.%T.loc8_16.2 (%T) = call %Function.specific_fn.loc9_10.1(%x.ref)
// CHECK:STDOUT: %.loc9_21.1: @CallGeneric.%T.loc8_16.2 (%T) = value_of_initializer %Function.call
// CHECK:STDOUT: %.loc9_21.2: @CallGeneric.%T.loc8_16.2 (%T) = converted %Function.call, %.loc9_21.1
// CHECK:STDOUT: return %.loc9_21.2
@@ -409,19 +409,19 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: generic fn @CallGenericPtr(%T.loc12_19.1: type) {
// CHECK:STDOUT: %T.loc12_19.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc12_19.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc12_19.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %.loc12_33.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc13_10.2: <specific function> = specific_function constants.%Function, @Function(%.loc12_33.2) [symbolic = %.loc13_10.2 (constants.%.3)]
// CHECK:STDOUT: %Function.specific_fn.loc13_10.2: <specific function> = specific_function constants.%Function, @Function(%ptr.loc12_33.2) [symbolic = %Function.specific_fn.loc13_10.2 (constants.%Function.specific_fn.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.2)) -> @CallGenericPtr.%.loc12_33.2 (%.2) {
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1)) -> @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Function.ref: %Function.type = name_ref Function, file.%Function.decl [template = constants.%Function]
// CHECK:STDOUT: %x.ref: @CallGenericPtr.%.loc12_33.2 (%.2) = name_ref x, %x
// CHECK:STDOUT: %.loc13_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%.2) [symbolic = %.loc13_10.2 (constants.%.3)]
// CHECK:STDOUT: %Function.call: init @CallGenericPtr.%.loc12_33.2 (%.2) = call %.loc13_10.1(%x.ref)
// CHECK:STDOUT: %.loc13_21.1: @CallGenericPtr.%.loc12_33.2 (%.2) = value_of_initializer %Function.call
// CHECK:STDOUT: %.loc13_21.2: @CallGenericPtr.%.loc12_33.2 (%.2) = converted %Function.call, %.loc13_21.1
// CHECK:STDOUT: %x.ref: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = name_ref x, %x
// CHECK:STDOUT: %Function.specific_fn.loc13_10.1: <specific function> = specific_function %Function.ref, @Function(constants.%ptr.1) [symbolic = %Function.specific_fn.loc13_10.2 (constants.%Function.specific_fn.2)]
// CHECK:STDOUT: %Function.call: init @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = call %Function.specific_fn.loc13_10.1(%x.ref)
// CHECK:STDOUT: %.loc13_21.1: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = value_of_initializer %Function.call
// CHECK:STDOUT: %.loc13_21.2: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) = converted %Function.call, %.loc13_21.1
// CHECK:STDOUT: return %.loc13_21.2
// CHECK:STDOUT: }
// CHECK:STDOUT: }
@@ -430,9 +430,9 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Function.ref: %Function.type = name_ref Function, file.%Function.decl [template = constants.%Function]
// CHECK:STDOUT: %x.ref: %C = name_ref x, %x
// CHECK:STDOUT: %.loc19: <specific function> = specific_function %Function.ref, @Function(constants.%C) [template = constants.%.7]
// CHECK:STDOUT: %Function.specific_fn: <specific function> = specific_function %Function.ref, @Function(constants.%C) [template = constants.%Function.specific_fn.3]
// CHECK:STDOUT: %.loc18_23.2: ref %C = splice_block %return {}
// CHECK:STDOUT: %Function.call: init %C = call %.loc19(%x.ref) to %.loc18_23.2
// CHECK:STDOUT: %Function.call: init %C = call %Function.specific_fn(%x.ref) to %.loc18_23.2
// CHECK:STDOUT: return %Function.call to %return
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -456,19 +456,19 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: specific @CallGenericPtr(constants.%T) {
// CHECK:STDOUT: %T.loc12_19.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc12_19.2 => constants.%T
// CHECK:STDOUT: %.loc12_33.2 => constants.%.2
// CHECK:STDOUT: %ptr.loc12_33.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.2
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.2
// CHECK:STDOUT: specific @Function(constants.%ptr.1) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(@CallGenericPtr.%.loc12_33.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.2
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.2
// CHECK:STDOUT: specific @Function(@CallGenericPtr.%ptr.loc12_33.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%C) {
toolchain/check/testdata/function/generic/no_prelude/fail_type_param_mismatch.carbon
Vendored
+7 -7
View File
@@ -25,7 +25,7 @@ fn F(T:! type, U:! type) {
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -52,17 +52,17 @@ fn F(T:! type, U:! type) {
// CHECK:STDOUT: %U.patt.loc11_16.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc11_16.2 (constants.%U.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %.loc12_11.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %ptr.loc12_11.2 (constants.%ptr)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc12_11.1: type = ptr_type %T [symbolic = %.loc12_11.2 (constants.%.1)]
// CHECK:STDOUT: %p.var: ref @F.%.loc12_11.2 (%.1) = var p
// CHECK:STDOUT: %p: ref @F.%.loc12_11.2 (%.1) = bind_name p, %p.var
// CHECK:STDOUT: %ptr.loc12_11.1: type = ptr_type %T [symbolic = %ptr.loc12_11.2 (constants.%ptr)]
// CHECK:STDOUT: %p.var: ref @F.%ptr.loc12_11.2 (%ptr) = var p
// CHECK:STDOUT: %p: ref @F.%ptr.loc12_11.2 (%ptr) = bind_name p, %p.var
// CHECK:STDOUT: %U.ref: type = name_ref U, %U.loc11_16.1 [symbolic = %U.loc11_16.2 (constants.%U)]
// CHECK:STDOUT: %p.ref: ref @F.%.loc12_11.2 (%.1) = name_ref p, %p
// CHECK:STDOUT: %.loc16_15: @F.%.loc12_11.2 (%.1) = bind_value %p.ref
// CHECK:STDOUT: %p.ref: ref @F.%ptr.loc12_11.2 (%ptr) = name_ref p, %p
// CHECK:STDOUT: %.loc16_15: @F.%ptr.loc12_11.2 (%ptr) = bind_value %p.ref
// CHECK:STDOUT: %.loc16_14: ref @F.%T.loc11_6.2 (%T) = deref %.loc16_15
// CHECK:STDOUT: %.loc16_16: @F.%U.loc11_16.2 (%U) = converted %.loc16_14, <error> [template = <error>]
// CHECK:STDOUT: %n: @F.%U.loc11_16.2 (%U) = bind_name n, <error>
toolchain/check/testdata/function/generic/no_prelude/import_specific.carbon
Vendored
+17 -17
View File
@@ -44,7 +44,7 @@ fn H() {
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %G.type: type = fn_type @G [template]
// CHECK:STDOUT: %G: %G.type = struct_value () [template]
// CHECK:STDOUT: %.1: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: %F.specific_fn: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -85,14 +85,14 @@ fn H() {
// CHECK:STDOUT: %T.patt.loc7_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc7_6.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc8_3.2: <specific function> = specific_function constants.%F, @F(%T.loc7_6.2) [symbolic = %.loc8_3.2 (constants.%.1)]
// CHECK:STDOUT: %F.specific_fn.loc8_3.2: <specific function> = specific_function constants.%F, @F(%T.loc7_6.2) [symbolic = %F.specific_fn.loc8_3.2 (constants.%F.specific_fn)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc7_6.1 [symbolic = %T.loc7_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc8_3.1: <specific function> = specific_function %F.ref, @F(constants.%T) [symbolic = %.loc8_3.2 (constants.%.1)]
// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %.loc8_3.1()
// CHECK:STDOUT: %F.specific_fn.loc8_3.1: <specific function> = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc8_3.2 (constants.%F.specific_fn)]
// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn.loc8_3.1()
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT: }
@@ -118,8 +118,8 @@ fn H() {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %C: type = class_type @C [template]
// CHECK:STDOUT: %.1: type = struct_type {} [template]
// CHECK:STDOUT: %.2: <witness> = complete_type_witness %.1 [template]
// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template]
// CHECK:STDOUT: %H.type: type = fn_type @H [template]
// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template]
// CHECK:STDOUT: %H: %H.type = struct_value () [template]
@@ -127,11 +127,11 @@ fn H() {
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.3: <specific function> = specific_function %F, @F(%C) [template]
// CHECK:STDOUT: %F.specific_fn.1: <specific function> = specific_function %F, @F(%C) [template]
// CHECK:STDOUT: %G.type: type = fn_type @G [template]
// CHECK:STDOUT: %G: %G.type = struct_value () [template]
// CHECK:STDOUT: %.4: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: %.5: <specific function> = specific_function %G, @G(%C) [template]
// CHECK:STDOUT: %F.specific_fn.2: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: %G.specific_fn: <specific function> = specific_function %G, @G(%C) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -152,23 +152,23 @@ fn H() {
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: class @C {
// CHECK:STDOUT: %.loc6: <witness> = complete_type_witness %.1 [template = constants.%.2]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template = constants.%complete_type]
// CHECK:STDOUT:
// CHECK:STDOUT: !members:
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: complete_type_witness = %.loc6
// CHECK:STDOUT: complete_type_witness = %complete_type
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @H() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, imports.%import_ref.1 [template = constants.%F]
// CHECK:STDOUT: %C.ref.loc10: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %.loc10: <specific function> = specific_function %F.ref, @F(constants.%C) [template = constants.%.3]
// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %.loc10()
// CHECK:STDOUT: %F.specific_fn: <specific function> = specific_function %F.ref, @F(constants.%C) [template = constants.%F.specific_fn.1]
// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn()
// CHECK:STDOUT: %G.ref: %G.type = name_ref G, imports.%import_ref.2 [template = constants.%G]
// CHECK:STDOUT: %C.ref.loc12: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %.loc12: <specific function> = specific_function %G.ref, @G(constants.%C) [template = constants.%.5]
// CHECK:STDOUT: %G.call: init %empty_tuple.type = call %.loc12()
// CHECK:STDOUT: %G.specific_fn: <specific function> = specific_function %G.ref, @G(constants.%C) [template = constants.%G.specific_fn]
// CHECK:STDOUT: %G.call: init %empty_tuple.type = call %G.specific_fn()
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -186,7 +186,7 @@ fn H() {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.1: <specific function> = specific_function constants.%F, @F(%T) [symbolic = %.1 (constants.%.4)]
// CHECK:STDOUT: %F.specific_fn: <specific function> = specific_function constants.%F, @F(%T) [symbolic = %F.specific_fn (constants.%F.specific_fn.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type);
// CHECK:STDOUT: }
@@ -220,6 +220,6 @@ fn H() {
// CHECK:STDOUT: %T.patt => constants.%C
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.1 => constants.%.3
// CHECK:STDOUT: %F.specific_fn => constants.%F.specific_fn.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/indirect_generic_type.carbon
Vendored
+21 -21
View File
@@ -17,8 +17,8 @@ fn F(T:! type, p: T**) -> T* {
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %.2: type = ptr_type %.1 [symbolic]
// CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ptr.2: type = ptr_type %ptr.1 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: }
@@ -30,38 +30,38 @@ fn F(T:! type, p: T**) -> T* {
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt.loc11_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc11_6.1, runtime_param<invalid> [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %p.patt: @F.%.loc11_21.2 (%.2) = binding_pattern p
// CHECK:STDOUT: %p.param_patt: @F.%.loc11_21.2 (%.2) = value_param_pattern %p.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @F.%.loc11_20.2 (%.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%.loc11_20.2 (%.1) = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %p.patt: @F.%ptr.loc11_21.2 (%ptr.2) = binding_pattern p
// CHECK:STDOUT: %p.param_patt: @F.%ptr.loc11_21.2 (%ptr.2) = value_param_pattern %p.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @F.%ptr.loc11_20.2 (%ptr.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%ptr.loc11_20.2 (%ptr.1) = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref.loc11_19: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc11_20.1: type = ptr_type %T [symbolic = %.loc11_20.2 (constants.%.1)]
// CHECK:STDOUT: %.loc11_21.1: type = ptr_type %.1 [symbolic = %.loc11_21.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc11_20.1: type = ptr_type %T [symbolic = %ptr.loc11_20.2 (constants.%ptr.1)]
// CHECK:STDOUT: %ptr.loc11_21.1: type = ptr_type %ptr.1 [symbolic = %ptr.loc11_21.2 (constants.%ptr.2)]
// CHECK:STDOUT: %T.ref.loc11_27: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc11_28: type = ptr_type %T [symbolic = %.loc11_20.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc11_28: type = ptr_type %T [symbolic = %ptr.loc11_20.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %p.param: @F.%.loc11_21.2 (%.2) = value_param runtime_param0
// CHECK:STDOUT: %p: @F.%.loc11_21.2 (%.2) = bind_name p, %p.param
// CHECK:STDOUT: %return.param: ref @F.%.loc11_20.2 (%.1) = out_param runtime_param1
// CHECK:STDOUT: %return: ref @F.%.loc11_20.2 (%.1) = return_slot %return.param
// CHECK:STDOUT: %p.param: @F.%ptr.loc11_21.2 (%ptr.2) = value_param runtime_param0
// CHECK:STDOUT: %p: @F.%ptr.loc11_21.2 (%ptr.2) = bind_name p, %p.param
// CHECK:STDOUT: %return.param: ref @F.%ptr.loc11_20.2 (%ptr.1) = out_param runtime_param1
// CHECK:STDOUT: %return: ref @F.%ptr.loc11_20.2 (%ptr.1) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%T.loc11_6.1: type) {
// CHECK:STDOUT: %T.loc11_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc11_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc11_20.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %.loc11_20.2 (constants.%.1)]
// CHECK:STDOUT: %.loc11_21.2: type = ptr_type @F.%.loc11_20.2 (%.1) [symbolic = %.loc11_21.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc11_20.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %ptr.loc11_20.2 (constants.%ptr.1)]
// CHECK:STDOUT: %ptr.loc11_21.2: type = ptr_type @F.%ptr.loc11_20.2 (%ptr.1) [symbolic = %ptr.loc11_21.2 (constants.%ptr.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %p.param_patt: @F.%.loc11_21.2 (%.2)) -> @F.%.loc11_20.2 (%.1) {
// CHECK:STDOUT: fn(%T.param_patt: type, %p.param_patt: @F.%ptr.loc11_21.2 (%ptr.2)) -> @F.%ptr.loc11_20.2 (%ptr.1) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %p.ref: @F.%.loc11_21.2 (%.2) = name_ref p, %p
// CHECK:STDOUT: %.loc12_10.1: ref @F.%.loc11_20.2 (%.1) = deref %p.ref
// CHECK:STDOUT: %.loc12_10.2: @F.%.loc11_20.2 (%.1) = bind_value %.loc12_10.1
// CHECK:STDOUT: %p.ref: @F.%ptr.loc11_21.2 (%ptr.2) = name_ref p, %p
// CHECK:STDOUT: %.loc12_10.1: ref @F.%ptr.loc11_20.2 (%ptr.1) = deref %p.ref
// CHECK:STDOUT: %.loc12_10.2: @F.%ptr.loc11_20.2 (%ptr.1) = bind_value %.loc12_10.1
// CHECK:STDOUT: return %.loc12_10.2
// CHECK:STDOUT: }
// CHECK:STDOUT: }
@@ -69,7 +69,7 @@ fn F(T:! type, p: T**) -> T* {
// CHECK:STDOUT: specific @F(constants.%T) {
// CHECK:STDOUT: %T.loc11_6.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc11_6.2 => constants.%T
// CHECK:STDOUT: %.loc11_20.2 => constants.%.1
// CHECK:STDOUT: %.loc11_21.2 => constants.%.2
// CHECK:STDOUT: %ptr.loc11_20.2 => constants.%ptr.1
// CHECK:STDOUT: %ptr.loc11_21.2 => constants.%ptr.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/type_param.carbon
Vendored
+7 -7
View File
@@ -20,7 +20,7 @@ fn F(T:! type) {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -41,17 +41,17 @@ fn F(T:! type) {
// CHECK:STDOUT: %T.patt.loc11_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %.loc12_11.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %ptr.loc12_11.2 (constants.%ptr)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %T.ref.loc12: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc12_11.1: type = ptr_type %T [symbolic = %.loc12_11.2 (constants.%.1)]
// CHECK:STDOUT: %p.var: ref @F.%.loc12_11.2 (%.1) = var p
// CHECK:STDOUT: %p: ref @F.%.loc12_11.2 (%.1) = bind_name p, %p.var
// CHECK:STDOUT: %ptr.loc12_11.1: type = ptr_type %T [symbolic = %ptr.loc12_11.2 (constants.%ptr)]
// CHECK:STDOUT: %p.var: ref @F.%ptr.loc12_11.2 (%ptr) = var p
// CHECK:STDOUT: %p: ref @F.%ptr.loc12_11.2 (%ptr) = bind_name p, %p.var
// CHECK:STDOUT: %T.ref.loc13: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %p.ref: ref @F.%.loc12_11.2 (%.1) = name_ref p, %p
// CHECK:STDOUT: %.loc13_15: @F.%.loc12_11.2 (%.1) = bind_value %p.ref
// CHECK:STDOUT: %p.ref: ref @F.%ptr.loc12_11.2 (%ptr) = name_ref p, %p
// CHECK:STDOUT: %.loc13_15: @F.%ptr.loc12_11.2 (%ptr) = bind_value %p.ref
// CHECK:STDOUT: %.loc13_14.1: ref @F.%T.loc11_6.2 (%T) = deref %.loc13_15
// CHECK:STDOUT: %.loc13_14.2: @F.%T.loc11_6.2 (%T) = bind_value %.loc13_14.1
// CHECK:STDOUT: %n: @F.%T.loc11_6.2 (%T) = bind_name n, %.loc13_14.2
toolchain/check/testdata/function/generic/redeclare.carbon
Vendored
+82 -82
View File
@@ -94,10 +94,10 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %.2: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: %F.specific_fn: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -116,47 +116,47 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %F.decl.loc4: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt.loc6: type = symbolic_binding_pattern T, 0 [symbolic = constants.%T.patt]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc6, runtime_param<invalid> [symbolic = constants.%T.patt]
// CHECK:STDOUT: %return.patt: %.1 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %.1 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: %ptr = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %ptr = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref.loc4: type = name_ref T, %T.loc4_6.1 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc4_20.1: type = ptr_type %T [symbolic = %.loc4_20.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_20.1: type = ptr_type %T [symbolic = %ptr.loc4_20.2 (constants.%ptr)]
// CHECK:STDOUT: %T.param.loc4: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %T.param.loc4 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %return.param.loc4: ref @F.%.loc4_20.2 (%.1) = out_param runtime_param0
// CHECK:STDOUT: %.loc4_16: ref @F.%.loc4_20.2 (%.1) = return_slot %return.param.loc4
// CHECK:STDOUT: %return.param.loc4: ref @F.%ptr.loc4_20.2 (%ptr) = out_param runtime_param0
// CHECK:STDOUT: %.loc4: ref @F.%ptr.loc4_20.2 (%ptr) = return_slot %return.param.loc4
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl.loc6: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt.loc6: type = symbolic_binding_pattern T, 0 [symbolic = constants.%T.patt]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc6, runtime_param<invalid> [symbolic = constants.%T.patt]
// CHECK:STDOUT: %return.patt: %.1 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %.1 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: %ptr = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %ptr = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref.loc6: type = name_ref T, %T.loc6 [symbolic = constants.%T]
// CHECK:STDOUT: %.loc6_20: type = ptr_type %T [symbolic = constants.%.1]
// CHECK:STDOUT: %ptr.loc6: type = ptr_type %T [symbolic = constants.%ptr]
// CHECK:STDOUT: %T.param.loc6: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc6: type = bind_symbolic_name T, 0, %T.param.loc6 [symbolic = constants.%T]
// CHECK:STDOUT: %return.param.loc6: ref %.1 = out_param runtime_param0
// CHECK:STDOUT: %return: ref %.1 = return_slot %return.param.loc6
// CHECK:STDOUT: %return.param.loc6: ref %ptr = out_param runtime_param0
// CHECK:STDOUT: %return: ref %ptr = return_slot %return.param.loc6
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%T.loc4_6.1: type) {
// CHECK:STDOUT: %T.loc4_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4 (constants.%T.patt)]
// CHECK:STDOUT: %.loc4_20.2: type = ptr_type @F.%T.loc4_6.2 (%T) [symbolic = %.loc4_20.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_20.2: type = ptr_type @F.%T.loc4_6.2 (%T) [symbolic = %ptr.loc4_20.2 (constants.%ptr)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc7_10.2: <specific function> = specific_function constants.%F, @F(%T.loc4_6.2) [symbolic = %.loc7_10.2 (constants.%.2)]
// CHECK:STDOUT: %F.specific_fn.loc7_10.2: <specific function> = specific_function constants.%F, @F(%T.loc4_6.2) [symbolic = %F.specific_fn.loc7_10.2 (constants.%F.specific_fn)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type) -> %.1 {
// CHECK:STDOUT: fn(%T.param_patt: type) -> %ptr {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl.loc4 [template = constants.%F]
// CHECK:STDOUT: %T.ref.loc7: type = name_ref T, %T.loc6 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc7_10.1: <specific function> = specific_function %F.ref, @F(constants.%T) [symbolic = %.loc7_10.2 (constants.%.2)]
// CHECK:STDOUT: %F.call: init @F.%.loc4_20.2 (%.1) = call %.loc7_10.1()
// CHECK:STDOUT: %.loc7_14.1: @F.%.loc4_20.2 (%.1) = value_of_initializer %F.call
// CHECK:STDOUT: %.loc7_14.2: @F.%.loc4_20.2 (%.1) = converted %F.call, %.loc7_14.1
// CHECK:STDOUT: %F.specific_fn.loc7_10.1: <specific function> = specific_function %F.ref, @F(constants.%T) [symbolic = %F.specific_fn.loc7_10.2 (constants.%F.specific_fn)]
// CHECK:STDOUT: %F.call: init @F.%ptr.loc4_20.2 (%ptr) = call %F.specific_fn.loc7_10.1()
// CHECK:STDOUT: %.loc7_14.1: @F.%ptr.loc4_20.2 (%ptr) = value_of_initializer %F.call
// CHECK:STDOUT: %.loc7_14.2: @F.%ptr.loc4_20.2 (%ptr) = converted %F.call, %.loc7_14.1
// CHECK:STDOUT: return %.loc7_14.2
// CHECK:STDOUT: }
// CHECK:STDOUT: }
@@ -164,16 +164,16 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: specific @F(constants.%T) {
// CHECK:STDOUT: %T.loc4_6.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4 => constants.%T
// CHECK:STDOUT: %.loc4_20.2 => constants.%.1
// CHECK:STDOUT: %ptr.loc4_20.2 => constants.%ptr
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc7_10.2 => constants.%.2
// CHECK:STDOUT: %F.specific_fn.loc7_10.2 => constants.%F.specific_fn
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(%T.loc4_6.2) {
// CHECK:STDOUT: %T.loc4_6.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4 => constants.%T
// CHECK:STDOUT: %.loc4_20.2 => constants.%.1
// CHECK:STDOUT: %ptr.loc4_20.2 => constants.%ptr
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_different_return_type.carbon
@@ -183,12 +183,12 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %U: type = bind_symbolic_name U, 1 [symbolic]
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %.2: type = ptr_type %U [symbolic]
// CHECK:STDOUT: %ptr.2: type = ptr_type %U [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.3: %.type = struct_value () [template]
// CHECK:STDOUT: %.1: %.type = struct_value () [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -209,34 +209,34 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc4_6.1, runtime_param<invalid> [symbolic = %T.patt.loc4_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.patt.loc4_16.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc4_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %U.param_patt: type = value_param_pattern %U.patt.loc4_16.1, runtime_param<invalid> [symbolic = %U.patt.loc4_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %return.patt: @F.%.loc4_30.2 (%.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%.loc4_30.2 (%.1) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @F.%ptr.loc4_30.2 (%ptr.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%ptr.loc4_30.2 (%ptr.1) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc4_6.1 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %.loc4_30.1: type = ptr_type %T [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_30.1: type = ptr_type %T [symbolic = %ptr.loc4_30.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %U.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %U.loc4_16.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc4_16.2 (constants.%U)]
// CHECK:STDOUT: %return.param: ref @F.%.loc4_30.2 (%.1) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @F.%.loc4_30.2 (%.1) = return_slot %return.param
// CHECK:STDOUT: %return.param: ref @F.%ptr.loc4_30.2 (%ptr.1) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @F.%ptr.loc4_30.2 (%ptr.1) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.3] {
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.1] {
// CHECK:STDOUT: %T.patt.loc13_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc13_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc13_6.1, runtime_param<invalid> [symbolic = %T.patt.loc13_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.patt.loc13_16.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc13_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %U.param_patt: type = value_param_pattern %U.patt.loc13_16.1, runtime_param<invalid> [symbolic = %U.patt.loc13_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %return.patt: @.1.%.loc13_30.2 (%.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @.1.%.loc13_30.2 (%.2) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @.1.%ptr.loc13_30.2 (%ptr.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @.1.%ptr.loc13_30.2 (%ptr.2) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %U.ref: type = name_ref U, %U.loc13_16.1 [symbolic = %U.loc13_16.2 (constants.%U)]
// CHECK:STDOUT: %.loc13_30.1: type = ptr_type %U [symbolic = %.loc13_30.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc13_30.1: type = ptr_type %U [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc13_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc13_6.2 (constants.%T)]
// CHECK:STDOUT: %U.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %U.loc13_16.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc13_16.2 (constants.%U)]
// CHECK:STDOUT: %return.param: ref @.1.%.loc13_30.2 (%.2) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @.1.%.loc13_30.2 (%.2) = return_slot %return.param
// CHECK:STDOUT: %return.param: ref @.1.%ptr.loc13_30.2 (%ptr.2) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @.1.%ptr.loc13_30.2 (%ptr.2) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -245,9 +245,9 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc4_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.loc4_16.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc4_16.2 (constants.%U)]
// CHECK:STDOUT: %U.patt.loc4_16.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc4_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %.loc4_30.2: type = ptr_type @F.%T.loc4_6.2 (%T) [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_30.2: type = ptr_type @F.%T.loc4_6.2 (%T) [symbolic = %ptr.loc4_30.2 (constants.%ptr.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%ptr.loc4_30.2 (%ptr.1);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%T.loc13_6.1: type, %U.loc13_16.1: type) {
@@ -255,11 +255,11 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc13_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc13_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.loc13_16.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc13_16.2 (constants.%U)]
// CHECK:STDOUT: %U.patt.loc13_16.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc13_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %.loc13_30.2: type = ptr_type @.1.%U.loc13_16.2 (%U) [symbolic = %.loc13_30.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc13_30.2: type = ptr_type @.1.%U.loc13_16.2 (%U) [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @.1.%.loc13_30.2 (%.2) {
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @.1.%ptr.loc13_30.2 (%ptr.2) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc13_6.1 [symbolic = %T.loc13_6.2 (constants.%T)]
@@ -272,7 +272,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc4_6.2 => constants.%T
// CHECK:STDOUT: %U.loc4_16.2 => constants.%U
// CHECK:STDOUT: %U.patt.loc4_16.2 => constants.%U
// CHECK:STDOUT: %.loc4_30.2 => constants.%.1
// CHECK:STDOUT: %ptr.loc4_30.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%T, constants.%U) {
@@ -280,7 +280,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc13_6.2 => constants.%T
// CHECK:STDOUT: %U.loc13_16.2 => constants.%U
// CHECK:STDOUT: %U.patt.loc13_16.2 => constants.%U
// CHECK:STDOUT: %.loc13_30.2 => constants.%.2
// CHECK:STDOUT: %ptr.loc13_30.2 => constants.%ptr.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_reorder.carbon
@@ -290,16 +290,16 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %U.1: type = bind_symbolic_name U, 1 [symbolic]
// CHECK:STDOUT: %U.patt.1: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T.1 [symbolic]
// CHECK:STDOUT: %ptr.1: type = ptr_type %T.1 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %U.2: type = bind_symbolic_name U, 0 [symbolic]
// CHECK:STDOUT: %U.patt.2: type = symbolic_binding_pattern U, 0 [symbolic]
// CHECK:STDOUT: %T.2: type = bind_symbolic_name T, 1 [symbolic]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 1 [symbolic]
// CHECK:STDOUT: %.2: type = ptr_type %T.2 [symbolic]
// CHECK:STDOUT: %ptr.2: type = ptr_type %T.2 [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.3: %.type = struct_value () [template]
// CHECK:STDOUT: %.1: %.type = struct_value () [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -320,34 +320,34 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc4_6.1, runtime_param<invalid> [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %U.patt.loc4_16.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: %U.param_patt: type = value_param_pattern %U.patt.loc4_16.1, runtime_param<invalid> [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: %return.patt: @F.%.loc4_30.2 (%.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%.loc4_30.2 (%.1) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @F.%ptr.loc4_30.2 (%ptr.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%ptr.loc4_30.2 (%ptr.1) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc4_6.1 [symbolic = %T.loc4_6.2 (constants.%T.1)]
// CHECK:STDOUT: %.loc4_30.1: type = ptr_type %T.1 [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_30.1: type = ptr_type %T.1 [symbolic = %ptr.loc4_30.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_6.2 (constants.%T.1)]
// CHECK:STDOUT: %U.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %U.loc4_16.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc4_16.2 (constants.%U.1)]
// CHECK:STDOUT: %return.param: ref @F.%.loc4_30.2 (%.1) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @F.%.loc4_30.2 (%.1) = return_slot %return.param
// CHECK:STDOUT: %return.param: ref @F.%ptr.loc4_30.2 (%ptr.1) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @F.%ptr.loc4_30.2 (%ptr.1) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.3] {
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.1] {
// CHECK:STDOUT: %U.patt.loc13_6.1: type = symbolic_binding_pattern U, 0 [symbolic = %U.patt.loc13_6.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %U.param_patt: type = value_param_pattern %U.patt.loc13_6.1, runtime_param<invalid> [symbolic = %U.patt.loc13_6.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %T.patt.loc13_16.1: type = symbolic_binding_pattern T, 1 [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc13_16.1, runtime_param<invalid> [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %return.patt: @.1.%.loc13_30.2 (%.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @.1.%.loc13_30.2 (%.2) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @.1.%ptr.loc13_30.2 (%ptr.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @.1.%ptr.loc13_30.2 (%ptr.2) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref.loc13: type = name_ref T, %T.loc13_16.1 [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: %.loc13_30.1: type = ptr_type %T.2 [symbolic = %.loc13_30.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc13_30.1: type = ptr_type %T.2 [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)]
// CHECK:STDOUT: %U.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %U.loc13_6.1: type = bind_symbolic_name U, 0, %U.param [symbolic = %U.loc13_6.2 (constants.%U.2)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc13_16.1: type = bind_symbolic_name T, 1, %T.param [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: %return.param: ref @.1.%.loc13_30.2 (%.2) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @.1.%.loc13_30.2 (%.2) = return_slot %return.param
// CHECK:STDOUT: %return.param: ref @.1.%ptr.loc13_30.2 (%ptr.2) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @.1.%ptr.loc13_30.2 (%ptr.2) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -356,9 +356,9 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc4_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %U.loc4_16.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc4_16.2 (constants.%U.1)]
// CHECK:STDOUT: %U.patt.loc4_16.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: %.loc4_30.2: type = ptr_type @F.%T.loc4_6.2 (%T.1) [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_30.2: type = ptr_type @F.%T.loc4_6.2 (%T.1) [symbolic = %ptr.loc4_30.2 (constants.%ptr.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%ptr.loc4_30.2 (%ptr.1);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%U.loc13_6.1: type, %T.loc13_16.1: type) {
@@ -366,11 +366,11 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %U.patt.loc13_6.2: type = symbolic_binding_pattern U, 0 [symbolic = %U.patt.loc13_6.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %T.loc13_16.2: type = bind_symbolic_name T, 1 [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: %T.patt.loc13_16.2: type = symbolic_binding_pattern T, 1 [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %.loc13_30.2: type = ptr_type @.1.%T.loc13_16.2 (%T.2) [symbolic = %.loc13_30.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc13_30.2: type = ptr_type @.1.%T.loc13_16.2 (%T.2) [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%.loc13_30.2 (%.2) {
// CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%ptr.loc13_30.2 (%ptr.2) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %T.ref.loc21: type = name_ref T, %T.loc13_16.1 [symbolic = %T.loc13_16.2 (constants.%T.2)]
@@ -383,7 +383,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc4_6.2 => constants.%T.1
// CHECK:STDOUT: %U.loc4_16.2 => constants.%U.1
// CHECK:STDOUT: %U.patt.loc4_16.2 => constants.%U.1
// CHECK:STDOUT: %.loc4_30.2 => constants.%.1
// CHECK:STDOUT: %ptr.loc4_30.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%U.2, constants.%T.2) {
@@ -391,7 +391,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %U.patt.loc13_6.2 => constants.%U.2
// CHECK:STDOUT: %T.loc13_16.2 => constants.%T.2
// CHECK:STDOUT: %T.patt.loc13_16.2 => constants.%T.2
// CHECK:STDOUT: %.loc13_30.2 => constants.%.2
// CHECK:STDOUT: %ptr.loc13_30.2 => constants.%ptr.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_rename.carbon
@@ -401,16 +401,16 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %U.1: type = bind_symbolic_name U, 1 [symbolic]
// CHECK:STDOUT: %U.patt.1: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T.1 [symbolic]
// CHECK:STDOUT: %ptr.1: type = ptr_type %T.1 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %U.2: type = bind_symbolic_name U, 0 [symbolic]
// CHECK:STDOUT: %U.patt.2: type = symbolic_binding_pattern U, 0 [symbolic]
// CHECK:STDOUT: %T.2: type = bind_symbolic_name T, 1 [symbolic]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 1 [symbolic]
// CHECK:STDOUT: %.2: type = ptr_type %U.2 [symbolic]
// CHECK:STDOUT: %ptr.2: type = ptr_type %U.2 [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.3: %.type = struct_value () [template]
// CHECK:STDOUT: %.1: %.type = struct_value () [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -431,34 +431,34 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc4_6.1, runtime_param<invalid> [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %U.patt.loc4_16.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: %U.param_patt: type = value_param_pattern %U.patt.loc4_16.1, runtime_param<invalid> [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: %return.patt: @F.%.loc4_30.2 (%.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%.loc4_30.2 (%.1) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @F.%ptr.loc4_30.2 (%ptr.1) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @F.%ptr.loc4_30.2 (%ptr.1) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc4_6.1 [symbolic = %T.loc4_6.2 (constants.%T.1)]
// CHECK:STDOUT: %.loc4_30.1: type = ptr_type %T.1 [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_30.1: type = ptr_type %T.1 [symbolic = %ptr.loc4_30.2 (constants.%ptr.1)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_6.2 (constants.%T.1)]
// CHECK:STDOUT: %U.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %U.loc4_16.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc4_16.2 (constants.%U.1)]
// CHECK:STDOUT: %return.param: ref @F.%.loc4_30.2 (%.1) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @F.%.loc4_30.2 (%.1) = return_slot %return.param
// CHECK:STDOUT: %return.param: ref @F.%ptr.loc4_30.2 (%ptr.1) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @F.%ptr.loc4_30.2 (%ptr.1) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.3] {
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.1] {
// CHECK:STDOUT: %U.patt.loc13_6.1: type = symbolic_binding_pattern U, 0 [symbolic = %U.patt.loc13_6.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %U.param_patt: type = value_param_pattern %U.patt.loc13_6.1, runtime_param<invalid> [symbolic = %U.patt.loc13_6.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %T.patt.loc13_16.1: type = symbolic_binding_pattern T, 1 [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc13_16.1, runtime_param<invalid> [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %return.patt: @.1.%.loc13_30.2 (%.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @.1.%.loc13_30.2 (%.2) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: %return.patt: @.1.%ptr.loc13_30.2 (%ptr.2) = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: @.1.%ptr.loc13_30.2 (%ptr.2) = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %U.ref: type = name_ref U, %U.loc13_6.1 [symbolic = %U.loc13_6.2 (constants.%U.2)]
// CHECK:STDOUT: %.loc13_30.1: type = ptr_type %U.2 [symbolic = %.loc13_30.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc13_30.1: type = ptr_type %U.2 [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)]
// CHECK:STDOUT: %U.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %U.loc13_6.1: type = bind_symbolic_name U, 0, %U.param [symbolic = %U.loc13_6.2 (constants.%U.2)]
// CHECK:STDOUT: %T.param: type = value_param runtime_param<invalid>
// CHECK:STDOUT: %T.loc13_16.1: type = bind_symbolic_name T, 1, %T.param [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: %return.param: ref @.1.%.loc13_30.2 (%.2) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @.1.%.loc13_30.2 (%.2) = return_slot %return.param
// CHECK:STDOUT: %return.param: ref @.1.%ptr.loc13_30.2 (%ptr.2) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @.1.%ptr.loc13_30.2 (%ptr.2) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -467,9 +467,9 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc4_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %U.loc4_16.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc4_16.2 (constants.%U.1)]
// CHECK:STDOUT: %U.patt.loc4_16.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: %.loc4_30.2: type = ptr_type @F.%T.loc4_6.2 (%T.1) [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT: %ptr.loc4_30.2: type = ptr_type @F.%T.loc4_6.2 (%T.1) [symbolic = %ptr.loc4_30.2 (constants.%ptr.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%ptr.loc4_30.2 (%ptr.1);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%U.loc13_6.1: type, %T.loc13_16.1: type) {
@@ -477,11 +477,11 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %U.patt.loc13_6.2: type = symbolic_binding_pattern U, 0 [symbolic = %U.patt.loc13_6.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %T.loc13_16.2: type = bind_symbolic_name T, 1 [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: %T.patt.loc13_16.2: type = symbolic_binding_pattern T, 1 [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %.loc13_30.2: type = ptr_type @.1.%U.loc13_6.2 (%U.2) [symbolic = %.loc13_30.2 (constants.%.2)]
// CHECK:STDOUT: %ptr.loc13_30.2: type = ptr_type @.1.%U.loc13_6.2 (%U.2) [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%.loc13_30.2 (%.2) {
// CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%ptr.loc13_30.2 (%ptr.2) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc13_16.1 [symbolic = %T.loc13_16.2 (constants.%T.2)]
@@ -494,7 +494,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %T.patt.loc4_6.2 => constants.%T.1
// CHECK:STDOUT: %U.loc4_16.2 => constants.%U.1
// CHECK:STDOUT: %U.patt.loc4_16.2 => constants.%U.1
// CHECK:STDOUT: %.loc4_30.2 => constants.%.1
// CHECK:STDOUT: %ptr.loc4_30.2 => constants.%ptr.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%U.2, constants.%T.2) {
@@ -502,6 +502,6 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: %U.patt.loc13_6.2 => constants.%U.2
// CHECK:STDOUT: %T.loc13_16.2 => constants.%T.2
// CHECK:STDOUT: %T.patt.loc13_16.2 => constants.%T.2
// CHECK:STDOUT: %.loc13_30.2 => constants.%.2
// CHECK:STDOUT: %ptr.loc13_30.2 => constants.%ptr.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/resolve_used.carbon
Vendored
+8 -8
View File
@@ -42,8 +42,8 @@ fn CallNegative() {
// CHECK:STDOUT: %iN: type = int_type signed, %N [symbolic]
// CHECK:STDOUT: %CallNegative.type: type = fn_type @CallNegative [template]
// CHECK:STDOUT: %CallNegative: %CallNegative.type = struct_value () [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %.2: <specific function> = specific_function %ErrorIfNIsZero, @ErrorIfNIsZero(%.1) [template]
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %ErrorIfNIsZero.specific_fn: <specific function> = specific_function %ErrorIfNIsZero, @ErrorIfNIsZero(%int_0) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -103,9 +103,9 @@ fn CallNegative() {
// CHECK:STDOUT: fn @CallNegative() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ErrorIfNIsZero.ref: %ErrorIfNIsZero.type = name_ref ErrorIfNIsZero, file.%ErrorIfNIsZero.decl [template = constants.%ErrorIfNIsZero]
// CHECK:STDOUT: %.loc16_18: Core.IntLiteral = int_value 0 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_3: <specific function> = specific_function %ErrorIfNIsZero.ref, @ErrorIfNIsZero(constants.%.1) [template = constants.%.2]
// CHECK:STDOUT: %ErrorIfNIsZero.call: init %empty_tuple.type = call %.loc16_3()
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0]
// CHECK:STDOUT: %ErrorIfNIsZero.specific_fn: <specific function> = specific_function %ErrorIfNIsZero.ref, @ErrorIfNIsZero(constants.%int_0) [template = constants.%ErrorIfNIsZero.specific_fn]
// CHECK:STDOUT: %ErrorIfNIsZero.call: init %empty_tuple.type = call %ErrorIfNIsZero.specific_fn()
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -114,9 +114,9 @@ fn CallNegative() {
// CHECK:STDOUT: %N.patt.loc4_19.2 => constants.%N
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ErrorIfNIsZero(constants.%.1) {
// CHECK:STDOUT: %N.loc4_19.2 => constants.%.1
// CHECK:STDOUT: %N.patt.loc4_19.2 => constants.%.1
// CHECK:STDOUT: specific @ErrorIfNIsZero(constants.%int_0) {
// CHECK:STDOUT: %N.loc4_19.2 => constants.%int_0
// CHECK:STDOUT: %N.patt.loc4_19.2 => constants.%int_0
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %iN => <error>
toolchain/check/testdata/function/generic/return_slot.carbon
Vendored
+64 -64
View File
@@ -27,37 +27,37 @@ fn G() {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Wrap.type: type = generic_class_type @Wrap [template]
// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template]
// CHECK:STDOUT: %Wrap.1: %Wrap.type = struct_value () [template]
// CHECK:STDOUT: %Wrap.2: type = class_type @Wrap, @Wrap(%T) [symbolic]
// CHECK:STDOUT: %Wrap.generic: %Wrap.type = struct_value () [template]
// CHECK:STDOUT: %Wrap.1: type = class_type @Wrap, @Wrap(%T) [symbolic]
// CHECK:STDOUT: %Make.type.1: type = fn_type @Make, @Wrap(%T) [symbolic]
// CHECK:STDOUT: %Make.1: %Make.type.1 = struct_value () [symbolic]
// CHECK:STDOUT: %.1: type = struct_type {} [template]
// CHECK:STDOUT: %.2: <witness> = complete_type_witness %.1 [template]
// CHECK:STDOUT: %.3: <specific function> = specific_function %Make.1, @Make(%T) [symbolic]
// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template]
// CHECK:STDOUT: %complete_type.1: <witness> = complete_type_witness %empty_struct_type [template]
// CHECK:STDOUT: %Make.specific_fn.1: <specific function> = specific_function %Make.1, @Make(%T) [symbolic]
// CHECK:STDOUT: %C: type = class_type @C [template]
// CHECK:STDOUT: %.4: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %i32: type = int_type signed, %.4 [template]
// CHECK:STDOUT: %.5: Core.IntLiteral = int_value 100 [template]
// CHECK:STDOUT: %.6: type = array_type %.5, %i32 [template]
// CHECK:STDOUT: %.8: type = unbound_element_type %C, %.6 [template]
// CHECK:STDOUT: %.9: type = struct_type {.arr: %.6} [template]
// CHECK:STDOUT: %.10: <witness> = complete_type_witness %.9 [template]
// CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template]
// CHECK:STDOUT: %int_100: Core.IntLiteral = int_value 100 [template]
// CHECK:STDOUT: %array_type: type = array_type %int_100, %i32 [template]
// CHECK:STDOUT: %C.elem: type = unbound_element_type %C, %array_type [template]
// CHECK:STDOUT: %struct_type.arr.1: type = struct_type {.arr: %array_type} [template]
// CHECK:STDOUT: %complete_type.2: <witness> = complete_type_witness %struct_type.arr.1 [template]
// CHECK:STDOUT: %G.type: type = fn_type @G [template]
// CHECK:STDOUT: %G: %G.type = struct_value () [template]
// CHECK:STDOUT: %Wrap.3: type = class_type @Wrap, @Wrap(%i32) [template]
// CHECK:STDOUT: %Wrap.2: type = class_type @Wrap, @Wrap(%i32) [template]
// CHECK:STDOUT: %Make.type.2: type = fn_type @Make, @Wrap(%i32) [template]
// CHECK:STDOUT: %Make.2: %Make.type.2 = struct_value () [template]
// CHECK:STDOUT: %.12: <specific function> = specific_function %Make.2, @Make(%i32) [template]
// CHECK:STDOUT: %Wrap.4: type = class_type @Wrap, @Wrap(%empty_tuple.type) [template]
// CHECK:STDOUT: %Make.specific_fn.2: <specific function> = specific_function %Make.2, @Make(%i32) [template]
// CHECK:STDOUT: %Wrap.3: type = class_type @Wrap, @Wrap(%empty_tuple.type) [template]
// CHECK:STDOUT: %Make.type.3: type = fn_type @Make, @Wrap(%empty_tuple.type) [template]
// CHECK:STDOUT: %Make.3: %Make.type.3 = struct_value () [template]
// CHECK:STDOUT: %.13: <specific function> = specific_function %Make.3, @Make(%empty_tuple.type) [template]
// CHECK:STDOUT: %Wrap.5: type = class_type @Wrap, @Wrap(%C) [template]
// CHECK:STDOUT: %Make.specific_fn.3: <specific function> = specific_function %Make.3, @Make(%empty_tuple.type) [template]
// CHECK:STDOUT: %Wrap.4: type = class_type @Wrap, @Wrap(%C) [template]
// CHECK:STDOUT: %Make.type.4: type = fn_type @Make, @Wrap(%C) [template]
// CHECK:STDOUT: %Make.4: %Make.type.4 = struct_value () [template]
// CHECK:STDOUT: %.16: <specific function> = specific_function %Make.4, @Make(%C) [template]
// CHECK:STDOUT: %Make.specific_fn.4: <specific function> = specific_function %Make.4, @Make(%C) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -76,7 +76,7 @@ fn G() {
// CHECK:STDOUT: .G = %G.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Wrap.decl: %Wrap.type = class_decl @Wrap [template = constants.%Wrap.1] {
// CHECK:STDOUT: %Wrap.decl: %Wrap.type = class_decl @Wrap [template = constants.%Wrap.generic] {
// CHECK:STDOUT: %T.patt.loc11_12.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_12.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc11_12.1, runtime_param<invalid> [symbolic = %T.patt.loc11_12.2 (constants.%T.patt)]
// CHECK:STDOUT: } {
@@ -104,29 +104,29 @@ fn G() {
// CHECK:STDOUT: %return.param: ref @Make.%T (%T) = out_param runtime_param0
// CHECK:STDOUT: %return: ref @Make.%T (%T) = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.loc13: <witness> = complete_type_witness %.1 [template = constants.%.2]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %empty_struct_type [template = constants.%complete_type.1]
// CHECK:STDOUT:
// CHECK:STDOUT: !members:
// CHECK:STDOUT: .Self = constants.%Wrap.2
// CHECK:STDOUT: .Self = constants.%Wrap.1
// CHECK:STDOUT: .Make = %Make.decl
// CHECK:STDOUT: complete_type_witness = %.loc13
// CHECK:STDOUT: complete_type_witness = %complete_type
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: class @C {
// CHECK:STDOUT: %.loc15_21.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
// CHECK:STDOUT: %int.make_type_signed: init type = call constants.%Int(%.loc15_21.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc15_26: Core.IntLiteral = int_value 100 [template = constants.%.5]
// CHECK:STDOUT: %.loc15_21.2: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
// CHECK:STDOUT: %.loc15_21.3: type = converted %int.make_type_signed, %.loc15_21.2 [template = constants.%i32]
// CHECK:STDOUT: %.loc15_29: type = array_type %.loc15_26, %i32 [template = constants.%.6]
// CHECK:STDOUT: %.loc15_18: %.8 = field_decl arr, element0 [template]
// CHECK:STDOUT: %.loc15_32: <witness> = complete_type_witness %.9 [template = constants.%.10]
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed: init type = call constants.%Int(%int_32) [template = constants.%i32]
// CHECK:STDOUT: %int_100: Core.IntLiteral = int_value 100 [template = constants.%int_100]
// CHECK:STDOUT: %.loc15_21.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32]
// CHECK:STDOUT: %.loc15_21.2: type = converted %int.make_type_signed, %.loc15_21.1 [template = constants.%i32]
// CHECK:STDOUT: %array_type: type = array_type %int_100, %i32 [template = constants.%array_type]
// CHECK:STDOUT: %.loc15_18: %C.elem = field_decl arr, element0 [template]
// CHECK:STDOUT: %complete_type: <witness> = complete_type_witness %struct_type.arr.1 [template = constants.%complete_type.2]
// CHECK:STDOUT:
// CHECK:STDOUT: !members:
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: .arr = %.loc15_18
// CHECK:STDOUT: complete_type_witness = %.loc15_32
// CHECK:STDOUT: complete_type_witness = %complete_type
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Make(@Wrap.%T.loc11_12.1: type) {
@@ -135,14 +135,14 @@ fn G() {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type: type = fn_type @Make, @Wrap(%T) [symbolic = %Make.type (constants.%Make.type.1)]
// CHECK:STDOUT: %Make: @Make.%Make.type (%Make.type.1) = struct_value () [symbolic = %Make (constants.%Make.1)]
// CHECK:STDOUT: %.loc12_27.3: <specific function> = specific_function %Make, @Make(%T) [symbolic = %.loc12_27.3 (constants.%.3)]
// CHECK:STDOUT: %Make.specific_fn.loc12_27.2: <specific function> = specific_function %Make, @Make(%T) [symbolic = %Make.specific_fn.loc12_27.2 (constants.%Make.specific_fn.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn() -> @Make.%T (%T) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc12_27.1: @Make.%Make.type (%Make.type.1) = specific_constant @Wrap.%Make.decl, @Wrap(constants.%T) [symbolic = %Make (constants.%Make.1)]
// CHECK:STDOUT: %Make.ref: @Make.%Make.type (%Make.type.1) = name_ref Make, %.loc12_27.1 [symbolic = %Make (constants.%Make.1)]
// CHECK:STDOUT: %.loc12_27.2: <specific function> = specific_function %Make.ref, @Make(constants.%T) [symbolic = %.loc12_27.3 (constants.%.3)]
// CHECK:STDOUT: %Make.call: init @Make.%T (%T) = call %.loc12_27.2()
// CHECK:STDOUT: %.loc12_27: @Make.%Make.type (%Make.type.1) = specific_constant @Wrap.%Make.decl, @Wrap(constants.%T) [symbolic = %Make (constants.%Make.1)]
// CHECK:STDOUT: %Make.ref: @Make.%Make.type (%Make.type.1) = name_ref Make, %.loc12_27 [symbolic = %Make (constants.%Make.1)]
// CHECK:STDOUT: %Make.specific_fn.loc12_27.1: <specific function> = specific_function %Make.ref, @Make(constants.%T) [symbolic = %Make.specific_fn.loc12_27.2 (constants.%Make.specific_fn.1)]
// CHECK:STDOUT: %Make.call: init @Make.%T (%T) = call %Make.specific_fn.loc12_27.1()
// CHECK:STDOUT: %.loc12_33.1: @Make.%T (%T) = value_of_initializer %Make.call
// CHECK:STDOUT: %.loc12_33.2: @Make.%T (%T) = converted %Make.call, %.loc12_33.1
// CHECK:STDOUT: return %.loc12_33.2
@@ -151,47 +151,47 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc18_10.1: Core.IntLiteral = int_value 32 [template = constants.%.4]
// CHECK:STDOUT: %int.make_type_signed.loc18_10: init type = call constants.%Int(%.loc18_10.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc18_10.2: type = value_of_initializer %int.make_type_signed.loc18_10 [template = constants.%i32]
// CHECK:STDOUT: %.loc18_10.3: type = converted %int.make_type_signed.loc18_10, %.loc18_10.2 [template = constants.%i32]
// CHECK:STDOUT: %int_32.loc18_10: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc18_10: init type = call constants.%Int(%int_32.loc18_10) [template = constants.%i32]
// CHECK:STDOUT: %.loc18_10.1: type = value_of_initializer %int.make_type_signed.loc18_10 [template = constants.%i32]
// CHECK:STDOUT: %.loc18_10.2: type = converted %int.make_type_signed.loc18_10, %.loc18_10.1 [template = constants.%i32]
// CHECK:STDOUT: %a.var: ref %i32 = var a
// CHECK:STDOUT: %a: ref %i32 = bind_name a, %a.var
// CHECK:STDOUT: %Wrap.ref.loc18: %Wrap.type = name_ref Wrap, file.%Wrap.decl [template = constants.%Wrap.1]
// CHECK:STDOUT: %.loc18_21: Core.IntLiteral = int_value 32 [template = constants.%.4]
// CHECK:STDOUT: %int.make_type_signed.loc18_21: init type = call constants.%Int(%.loc18_21) [template = constants.%i32]
// CHECK:STDOUT: %Wrap.ref.loc18: %Wrap.type = name_ref Wrap, file.%Wrap.decl [template = constants.%Wrap.generic]
// CHECK:STDOUT: %int_32.loc18_21: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc18_21: init type = call constants.%Int(%int_32.loc18_21) [template = constants.%i32]
// CHECK:STDOUT: %.loc18_24.1: type = value_of_initializer %int.make_type_signed.loc18_21 [template = constants.%i32]
// CHECK:STDOUT: %.loc18_24.2: type = converted %int.make_type_signed.loc18_21, %.loc18_24.1 [template = constants.%i32]
// CHECK:STDOUT: %Wrap.loc18: type = class_type @Wrap, @Wrap(constants.%i32) [template = constants.%Wrap.3]
// CHECK:STDOUT: %.loc18_25.1: %Make.type.2 = specific_constant @Wrap.%Make.decl, @Wrap(constants.%i32) [template = constants.%Make.2]
// CHECK:STDOUT: %Make.ref.loc18: %Make.type.2 = name_ref Make, %.loc18_25.1 [template = constants.%Make.2]
// CHECK:STDOUT: %.loc18_25.2: <specific function> = specific_function %Make.ref.loc18, @Make(constants.%i32) [template = constants.%.12]
// CHECK:STDOUT: %Make.call.loc18: init %i32 = call %.loc18_25.2()
// CHECK:STDOUT: %Wrap.loc18: type = class_type @Wrap, @Wrap(constants.%i32) [template = constants.%Wrap.2]
// CHECK:STDOUT: %.loc18_25: %Make.type.2 = specific_constant @Wrap.%Make.decl, @Wrap(constants.%i32) [template = constants.%Make.2]
// CHECK:STDOUT: %Make.ref.loc18: %Make.type.2 = name_ref Make, %.loc18_25 [template = constants.%Make.2]
// CHECK:STDOUT: %Make.specific_fn.loc18: <specific function> = specific_function %Make.ref.loc18, @Make(constants.%i32) [template = constants.%Make.specific_fn.2]
// CHECK:STDOUT: %Make.call.loc18: init %i32 = call %Make.specific_fn.loc18()
// CHECK:STDOUT: assign %a.var, %Make.call.loc18
// CHECK:STDOUT: %.loc19_11.1: %empty_tuple.type = tuple_literal ()
// CHECK:STDOUT: %.loc19_11.2: type = converted %.loc19_11.1, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
// CHECK:STDOUT: %b.var: ref %empty_tuple.type = var b
// CHECK:STDOUT: %b: ref %empty_tuple.type = bind_name b, %b.var
// CHECK:STDOUT: %Wrap.ref.loc19: %Wrap.type = name_ref Wrap, file.%Wrap.decl [template = constants.%Wrap.1]
// CHECK:STDOUT: %Wrap.ref.loc19: %Wrap.type = name_ref Wrap, file.%Wrap.decl [template = constants.%Wrap.generic]
// CHECK:STDOUT: %.loc19_21: %empty_tuple.type = tuple_literal ()
// CHECK:STDOUT: %.loc19_22: type = converted %.loc19_21, constants.%empty_tuple.type [template = constants.%empty_tuple.type]
// CHECK:STDOUT: %Wrap.loc19: type = class_type @Wrap, @Wrap(constants.%empty_tuple.type) [template = constants.%Wrap.4]
// CHECK:STDOUT: %.loc19_23.1: %Make.type.3 = specific_constant @Wrap.%Make.decl, @Wrap(constants.%empty_tuple.type) [template = constants.%Make.3]
// CHECK:STDOUT: %Make.ref.loc19: %Make.type.3 = name_ref Make, %.loc19_23.1 [template = constants.%Make.3]
// CHECK:STDOUT: %.loc19_23.2: <specific function> = specific_function %Make.ref.loc19, @Make(constants.%empty_tuple.type) [template = constants.%.13]
// CHECK:STDOUT: %Make.call.loc19: init %empty_tuple.type = call %.loc19_23.2()
// CHECK:STDOUT: %Wrap.loc19: type = class_type @Wrap, @Wrap(constants.%empty_tuple.type) [template = constants.%Wrap.3]
// CHECK:STDOUT: %.loc19_23: %Make.type.3 = specific_constant @Wrap.%Make.decl, @Wrap(constants.%empty_tuple.type) [template = constants.%Make.3]
// CHECK:STDOUT: %Make.ref.loc19: %Make.type.3 = name_ref Make, %.loc19_23 [template = constants.%Make.3]
// CHECK:STDOUT: %Make.specific_fn.loc19: <specific function> = specific_function %Make.ref.loc19, @Make(constants.%empty_tuple.type) [template = constants.%Make.specific_fn.3]
// CHECK:STDOUT: %Make.call.loc19: init %empty_tuple.type = call %Make.specific_fn.loc19()
// CHECK:STDOUT: assign %b.var, %Make.call.loc19
// CHECK:STDOUT: %C.ref.loc20_10: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %c.var: ref %C = var c
// CHECK:STDOUT: %c: ref %C = bind_name c, %c.var
// CHECK:STDOUT: %Wrap.ref.loc20: %Wrap.type = name_ref Wrap, file.%Wrap.decl [template = constants.%Wrap.1]
// CHECK:STDOUT: %Wrap.ref.loc20: %Wrap.type = name_ref Wrap, file.%Wrap.decl [template = constants.%Wrap.generic]
// CHECK:STDOUT: %C.ref.loc20_19: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %Wrap.loc20: type = class_type @Wrap, @Wrap(constants.%C) [template = constants.%Wrap.5]
// CHECK:STDOUT: %.loc20_21.1: %Make.type.4 = specific_constant @Wrap.%Make.decl, @Wrap(constants.%C) [template = constants.%Make.4]
// CHECK:STDOUT: %Make.ref.loc20: %Make.type.4 = name_ref Make, %.loc20_21.1 [template = constants.%Make.4]
// CHECK:STDOUT: %.loc20_21.2: <specific function> = specific_function %Make.ref.loc20, @Make(constants.%C) [template = constants.%.16]
// CHECK:STDOUT: %Wrap.loc20: type = class_type @Wrap, @Wrap(constants.%C) [template = constants.%Wrap.4]
// CHECK:STDOUT: %.loc20_21: %Make.type.4 = specific_constant @Wrap.%Make.decl, @Wrap(constants.%C) [template = constants.%Make.4]
// CHECK:STDOUT: %Make.ref.loc20: %Make.type.4 = name_ref Make, %.loc20_21 [template = constants.%Make.4]
// CHECK:STDOUT: %Make.specific_fn.loc20: <specific function> = specific_function %Make.ref.loc20, @Make(constants.%C) [template = constants.%Make.specific_fn.4]
// CHECK:STDOUT: %.loc20_7: ref %C = splice_block %c.var {}
// CHECK:STDOUT: %Make.call.loc20: init %C = call %.loc20_21.2() to %.loc20_7
// CHECK:STDOUT: %Make.call.loc20: init %C = call %Make.specific_fn.loc20() to %.loc20_7
// CHECK:STDOUT: assign %c.var, %Make.call.loc20
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -211,7 +211,7 @@ fn G() {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.1
// CHECK:STDOUT: %Make => constants.%Make.1
// CHECK:STDOUT: %.loc12_27.3 => constants.%.3
// CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(%T.loc11_12.2) {
@@ -243,7 +243,7 @@ fn G() {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.2
// CHECK:STDOUT: %Make => constants.%Make.2
// CHECK:STDOUT: %.loc12_27.3 => constants.%.12
// CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(constants.%empty_tuple.type) {
@@ -261,7 +261,7 @@ fn G() {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.3
// CHECK:STDOUT: %Make => constants.%Make.3
// CHECK:STDOUT: %.loc12_27.3 => constants.%.13
// CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(constants.%C) {
@@ -279,6 +279,6 @@ fn G() {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.4
// CHECK:STDOUT: %Make => constants.%Make.4
// CHECK:STDOUT: %.loc12_27.3 => constants.%.16
// CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.4
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/undefined.carbon
Vendored
+78 -78
View File
@@ -57,21 +57,21 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Defined.type: type = fn_type @Defined [template]
// CHECK:STDOUT: %Defined: %Defined.type = struct_value () [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %i32: type = int_type signed, %.1 [template]
// CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template]
// CHECK:STDOUT: %CallDefined.type: type = fn_type @CallDefined [template]
// CHECK:STDOUT: %CallDefined: %CallDefined.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
// CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%.1) [template]
// CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%int_32) [template]
// CHECK:STDOUT: %Convert.14: %Convert.type.14 = struct_value () [template]
// CHECK:STDOUT: %.26: <witness> = interface_witness (%Convert.14) [template]
// CHECK:STDOUT: %.27: <bound method> = bound_method %.2, %Convert.14 [template]
// CHECK:STDOUT: %.28: <specific function> = specific_function %.27, @Convert.7(%.1) [template]
// CHECK:STDOUT: %.29: %i32 = int_value 0 [template]
// CHECK:STDOUT: %.30: <specific function> = specific_function %Defined, @Defined(%i32) [template]
// CHECK:STDOUT: %interface.9: <witness> = interface_witness (%Convert.14) [template]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %int_0.1, %Convert.14 [template]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.7(%int_32) [template]
// CHECK:STDOUT: %int_0.2: %i32 = int_value 0 [template]
// CHECK:STDOUT: %Defined.specific_fn: <specific function> = specific_function %Defined, @Defined(%i32) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -111,10 +111,10 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_21.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc8: init type = call constants.%Int(%.loc8_21.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc8_21.2: type = value_of_initializer %int.make_type_signed.loc8 [template = constants.%i32]
// CHECK:STDOUT: %.loc8_21.3: type = converted %int.make_type_signed.loc8, %.loc8_21.2 [template = constants.%i32]
// CHECK:STDOUT: %int_32.loc8: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc8: init type = call constants.%Int(%int_32.loc8) [template = constants.%i32]
// CHECK:STDOUT: %.loc8_21.1: type = value_of_initializer %int.make_type_signed.loc8 [template = constants.%i32]
// CHECK:STDOUT: %.loc8_21.2: type = converted %int.make_type_signed.loc8, %.loc8_21.1 [template = constants.%i32]
// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0
// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param
// CHECK:STDOUT: }
@@ -136,19 +136,19 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: fn @CallDefined() -> %i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Defined.ref: %Defined.type = name_ref Defined, file.%Defined.decl [template = constants.%Defined]
// CHECK:STDOUT: %.loc9_18: Core.IntLiteral = int_value 0 [template = constants.%.2]
// CHECK:STDOUT: %.loc9_23.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc9: init type = call constants.%Int(%.loc9_23.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc9_23.2: type = value_of_initializer %int.make_type_signed.loc9 [template = constants.%i32]
// CHECK:STDOUT: %.loc9_23.3: type = converted %int.make_type_signed.loc9, %.loc9_23.2 [template = constants.%i32]
// CHECK:STDOUT: %.loc9_20.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
// CHECK:STDOUT: %.loc9_20.2: <bound method> = bound_method %.loc9_18, %.loc9_20.1 [template = constants.%.27]
// CHECK:STDOUT: %.loc9_20.3: <specific function> = specific_function %.loc9_20.2, @Convert.7(constants.%.1) [template = constants.%.28]
// CHECK:STDOUT: %int.convert_checked: init %i32 = call %.loc9_20.3(%.loc9_18) [template = constants.%.29]
// CHECK:STDOUT: %.loc9_20.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
// CHECK:STDOUT: %.loc9_20.5: %i32 = converted %.loc9_18, %.loc9_20.4 [template = constants.%.29]
// CHECK:STDOUT: %.loc9_10: <specific function> = specific_function %Defined.ref, @Defined(constants.%i32) [template = constants.%.30]
// CHECK:STDOUT: %Defined.call: init %i32 = call %.loc9_10(%.loc9_20.5)
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0.1]
// CHECK:STDOUT: %int_32.loc9: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc9: init type = call constants.%Int(%int_32.loc9) [template = constants.%i32]
// CHECK:STDOUT: %.loc9_23.1: type = value_of_initializer %int.make_type_signed.loc9 [template = constants.%i32]
// CHECK:STDOUT: %.loc9_23.2: type = converted %int.make_type_signed.loc9, %.loc9_23.1 [template = constants.%i32]
// CHECK:STDOUT: %impl.elem0: %Convert.type.2 = interface_witness_access constants.%interface.9, element0 [template = constants.%Convert.14]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %int_0, %impl.elem0 [template = constants.%Convert.bound]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.7(constants.%int_32) [template = constants.%Convert.specific_fn]
// CHECK:STDOUT: %int.convert_checked: init %i32 = call %Convert.specific_fn(%int_0) [template = constants.%int_0.2]
// CHECK:STDOUT: %.loc9_20.1: %i32 = value_of_initializer %int.convert_checked [template = constants.%int_0.2]
// CHECK:STDOUT: %.loc9_20.2: %i32 = converted %int_0, %.loc9_20.1 [template = constants.%int_0.2]
// CHECK:STDOUT: %Defined.specific_fn: <specific function> = specific_function %Defined.ref, @Defined(constants.%i32) [template = constants.%Defined.specific_fn]
// CHECK:STDOUT: %Defined.call: init %i32 = call %Defined.specific_fn(%.loc9_20.2)
// CHECK:STDOUT: %.loc9_27.1: %i32 = value_of_initializer %Defined.call
// CHECK:STDOUT: %.loc9_27.2: %i32 = converted %Defined.call, %.loc9_27.1
// CHECK:STDOUT: return %.loc9_27.2
@@ -173,21 +173,21 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Defined.type: type = fn_type @Defined [template]
// CHECK:STDOUT: %Defined: %Defined.type = struct_value () [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %i32: type = int_type signed, %.1 [template]
// CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template]
// CHECK:STDOUT: %CallDefined.type: type = fn_type @CallDefined [template]
// CHECK:STDOUT: %CallDefined: %CallDefined.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
// CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%.1) [template]
// CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%int_32) [template]
// CHECK:STDOUT: %Convert.14: %Convert.type.14 = struct_value () [template]
// CHECK:STDOUT: %.26: <witness> = interface_witness (%Convert.14) [template]
// CHECK:STDOUT: %.27: <bound method> = bound_method %.2, %Convert.14 [template]
// CHECK:STDOUT: %.28: <specific function> = specific_function %.27, @Convert.7(%.1) [template]
// CHECK:STDOUT: %.29: %i32 = int_value 0 [template]
// CHECK:STDOUT: %.30: <specific function> = specific_function %Defined, @Defined(%i32) [template]
// CHECK:STDOUT: %interface.9: <witness> = interface_witness (%Convert.14) [template]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %int_0.1, %Convert.14 [template]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.7(%int_32) [template]
// CHECK:STDOUT: %int_0.2: %i32 = int_value 0 [template]
// CHECK:STDOUT: %Defined.specific_fn: <specific function> = specific_function %Defined, @Defined(%i32) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -227,10 +227,10 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc6_21.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc6: init type = call constants.%Int(%.loc6_21.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc6_21.2: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
// CHECK:STDOUT: %.loc6_21.3: type = converted %int.make_type_signed.loc6, %.loc6_21.2 [template = constants.%i32]
// CHECK:STDOUT: %int_32.loc6: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc6: init type = call constants.%Int(%int_32.loc6) [template = constants.%i32]
// CHECK:STDOUT: %.loc6_21.1: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
// CHECK:STDOUT: %.loc6_21.2: type = converted %int.make_type_signed.loc6, %.loc6_21.1 [template = constants.%i32]
// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0
// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param
// CHECK:STDOUT: }
@@ -269,19 +269,19 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: fn @CallDefined() -> %i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Defined.ref: %Defined.type = name_ref Defined, file.%Defined.decl.loc4 [template = constants.%Defined]
// CHECK:STDOUT: %.loc7_18: Core.IntLiteral = int_value 0 [template = constants.%.2]
// CHECK:STDOUT: %.loc7_23.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc7: init type = call constants.%Int(%.loc7_23.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc7_23.2: type = value_of_initializer %int.make_type_signed.loc7 [template = constants.%i32]
// CHECK:STDOUT: %.loc7_23.3: type = converted %int.make_type_signed.loc7, %.loc7_23.2 [template = constants.%i32]
// CHECK:STDOUT: %.loc7_20.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
// CHECK:STDOUT: %.loc7_20.2: <bound method> = bound_method %.loc7_18, %.loc7_20.1 [template = constants.%.27]
// CHECK:STDOUT: %.loc7_20.3: <specific function> = specific_function %.loc7_20.2, @Convert.7(constants.%.1) [template = constants.%.28]
// CHECK:STDOUT: %int.convert_checked: init %i32 = call %.loc7_20.3(%.loc7_18) [template = constants.%.29]
// CHECK:STDOUT: %.loc7_20.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
// CHECK:STDOUT: %.loc7_20.5: %i32 = converted %.loc7_18, %.loc7_20.4 [template = constants.%.29]
// CHECK:STDOUT: %.loc7_10: <specific function> = specific_function %Defined.ref, @Defined(constants.%i32) [template = constants.%.30]
// CHECK:STDOUT: %Defined.call: init %i32 = call %.loc7_10(%.loc7_20.5)
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0.1]
// CHECK:STDOUT: %int_32.loc7: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc7: init type = call constants.%Int(%int_32.loc7) [template = constants.%i32]
// CHECK:STDOUT: %.loc7_23.1: type = value_of_initializer %int.make_type_signed.loc7 [template = constants.%i32]
// CHECK:STDOUT: %.loc7_23.2: type = converted %int.make_type_signed.loc7, %.loc7_23.1 [template = constants.%i32]
// CHECK:STDOUT: %impl.elem0: %Convert.type.2 = interface_witness_access constants.%interface.9, element0 [template = constants.%Convert.14]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %int_0, %impl.elem0 [template = constants.%Convert.bound]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.7(constants.%int_32) [template = constants.%Convert.specific_fn]
// CHECK:STDOUT: %int.convert_checked: init %i32 = call %Convert.specific_fn(%int_0) [template = constants.%int_0.2]
// CHECK:STDOUT: %.loc7_20.1: %i32 = value_of_initializer %int.convert_checked [template = constants.%int_0.2]
// CHECK:STDOUT: %.loc7_20.2: %i32 = converted %int_0, %.loc7_20.1 [template = constants.%int_0.2]
// CHECK:STDOUT: %Defined.specific_fn: <specific function> = specific_function %Defined.ref, @Defined(constants.%i32) [template = constants.%Defined.specific_fn]
// CHECK:STDOUT: %Defined.call: init %i32 = call %Defined.specific_fn(%.loc7_20.2)
// CHECK:STDOUT: %.loc7_27.1: %i32 = value_of_initializer %Defined.call
// CHECK:STDOUT: %.loc7_27.2: %i32 = converted %Defined.call, %.loc7_27.1
// CHECK:STDOUT: return %.loc7_27.2
@@ -306,21 +306,21 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Undefined.type: type = fn_type @Undefined [template]
// CHECK:STDOUT: %Undefined: %Undefined.type = struct_value () [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %i32: type = int_type signed, %.1 [template]
// CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template]
// CHECK:STDOUT: %CallUndefined.type: type = fn_type @CallUndefined [template]
// CHECK:STDOUT: %CallUndefined: %CallUndefined.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template]
// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template]
// CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%.1) [template]
// CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%int_32) [template]
// CHECK:STDOUT: %Convert.14: %Convert.type.14 = struct_value () [template]
// CHECK:STDOUT: %.26: <witness> = interface_witness (%Convert.14) [template]
// CHECK:STDOUT: %.27: <bound method> = bound_method %.2, %Convert.14 [template]
// CHECK:STDOUT: %.28: <specific function> = specific_function %.27, @Convert.7(%.1) [template]
// CHECK:STDOUT: %.29: %i32 = int_value 0 [template]
// CHECK:STDOUT: %.30: <specific function> = specific_function %Undefined, @Undefined(%i32) [template]
// CHECK:STDOUT: %interface.9: <witness> = interface_witness (%Convert.14) [template]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %int_0.1, %Convert.14 [template]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.7(%int_32) [template]
// CHECK:STDOUT: %int_0.2: %i32 = int_value 0 [template]
// CHECK:STDOUT: %Undefined.specific_fn: <specific function> = specific_function %Undefined, @Undefined(%i32) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -360,10 +360,10 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc6_23.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc6: init type = call constants.%Int(%.loc6_23.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc6_23.2: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
// CHECK:STDOUT: %.loc6_23.3: type = converted %int.make_type_signed.loc6, %.loc6_23.2 [template = constants.%i32]
// CHECK:STDOUT: %int_32.loc6: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc6: init type = call constants.%Int(%int_32.loc6) [template = constants.%i32]
// CHECK:STDOUT: %.loc6_23.1: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32]
// CHECK:STDOUT: %.loc6_23.2: type = converted %int.make_type_signed.loc6, %.loc6_23.1 [template = constants.%i32]
// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0
// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param
// CHECK:STDOUT: }
@@ -379,19 +379,19 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: fn @CallUndefined() -> %i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Undefined.ref: %Undefined.type = name_ref Undefined, file.%Undefined.decl [template = constants.%Undefined]
// CHECK:STDOUT: %.loc13_20: Core.IntLiteral = int_value 0 [template = constants.%.2]
// CHECK:STDOUT: %.loc13_25.1: Core.IntLiteral = int_value 32 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc13: init type = call constants.%Int(%.loc13_25.1) [template = constants.%i32]
// CHECK:STDOUT: %.loc13_25.2: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32]
// CHECK:STDOUT: %.loc13_25.3: type = converted %int.make_type_signed.loc13, %.loc13_25.2 [template = constants.%i32]
// CHECK:STDOUT: %.loc13_22.1: %Convert.type.2 = interface_witness_access constants.%.26, element0 [template = constants.%Convert.14]
// CHECK:STDOUT: %.loc13_22.2: <bound method> = bound_method %.loc13_20, %.loc13_22.1 [template = constants.%.27]
// CHECK:STDOUT: %.loc13_22.3: <specific function> = specific_function %.loc13_22.2, @Convert.7(constants.%.1) [template = constants.%.28]
// CHECK:STDOUT: %int.convert_checked: init %i32 = call %.loc13_22.3(%.loc13_20) [template = constants.%.29]
// CHECK:STDOUT: %.loc13_22.4: %i32 = value_of_initializer %int.convert_checked [template = constants.%.29]
// CHECK:STDOUT: %.loc13_22.5: %i32 = converted %.loc13_20, %.loc13_22.4 [template = constants.%.29]
// CHECK:STDOUT: %.loc13_10: <specific function> = specific_function %Undefined.ref, @Undefined(constants.%i32) [template = constants.%.30]
// CHECK:STDOUT: %Undefined.call: init %i32 = call %.loc13_10(%.loc13_22.5)
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0.1]
// CHECK:STDOUT: %int_32.loc13: Core.IntLiteral = int_value 32 [template = constants.%int_32]
// CHECK:STDOUT: %int.make_type_signed.loc13: init type = call constants.%Int(%int_32.loc13) [template = constants.%i32]
// CHECK:STDOUT: %.loc13_25.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32]
// CHECK:STDOUT: %.loc13_25.2: type = converted %int.make_type_signed.loc13, %.loc13_25.1 [template = constants.%i32]
// CHECK:STDOUT: %impl.elem0: %Convert.type.2 = interface_witness_access constants.%interface.9, element0 [template = constants.%Convert.14]
// CHECK:STDOUT: %Convert.bound: <bound method> = bound_method %int_0, %impl.elem0 [template = constants.%Convert.bound]
// CHECK:STDOUT: %Convert.specific_fn: <specific function> = specific_function %Convert.bound, @Convert.7(constants.%int_32) [template = constants.%Convert.specific_fn]
// CHECK:STDOUT: %int.convert_checked: init %i32 = call %Convert.specific_fn(%int_0) [template = constants.%int_0.2]
// CHECK:STDOUT: %.loc13_22.1: %i32 = value_of_initializer %int.convert_checked [template = constants.%int_0.2]
// CHECK:STDOUT: %.loc13_22.2: %i32 = converted %int_0, %.loc13_22.1 [template = constants.%int_0.2]
// CHECK:STDOUT: %Undefined.specific_fn: <specific function> = specific_function %Undefined.ref, @Undefined(constants.%i32) [template = constants.%Undefined.specific_fn]
// CHECK:STDOUT: %Undefined.call: init %i32 = call %Undefined.specific_fn(%.loc13_22.2)
// CHECK:STDOUT: %.loc13_29.1: %i32 = value_of_initializer %Undefined.call
// CHECK:STDOUT: %.loc13_29.2: %i32 = converted %Undefined.call, %.loc13_29.1
// CHECK:STDOUT: return %.loc13_29.2