carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-06 07:34:45 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Generate parameter pattern-match IR from pattern IR (#4388)

Browse Source 
Also propagate the pattern IR along with the pattern-match IR, and use
it where appropriate.

Strictly speaking, some parts of the pattern-match IR are allocated
eagerly, while traversing the pattern's parse tree, but they still
aren't actually emitted until we traverse the associated pattern insts.

---------

Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
This commit is contained in:
Geoff Romer
2024-10-16 19:15:29 +00:00
committed by GitHub
co-authored by Jon Ross-Perkins
parent 4a73b36688
commit 9d942f4633
347 changed files with 9148 additions and 5802 deletions
Download Patch File Download Diff File Expand all files Collapse all files
toolchain/check/testdata/function/builtin/call.carbon
Vendored
+7 -5
View File
@@ -51,22 +51,24 @@ var arr: [i32; Add(1, 2)];
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Add.decl: %Add.type = fn_decl @Add [template = constants.%Add] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc11_27: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_27.1: type = value_of_initializer %int.make_type_32.loc11_27 [template = i32]
// CHECK:STDOUT: %.loc11_27.2: type = converted %int.make_type_32.loc11_27, %.loc11_27.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %Add.ref: %Add.type = name_ref Add, %Add.decl [template = constants.%Add]
@@ -82,5 +84,5 @@ var arr: [i32; Add(1, 2)];
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Add(%a: i32, %b: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @Add(%a.param_patt: i32, %b.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
toolchain/check/testdata/function/builtin/definition.carbon
Vendored
+7 -5
View File
@@ -43,26 +43,28 @@ fn Add(a: i32, b: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Add.decl: %Add.type = fn_decl @Add [template = constants.%Add] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc11_27: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_27.1: type = value_of_initializer %int.make_type_32.loc11_27 [template = i32]
// CHECK:STDOUT: %.loc11_27.2: type = converted %int.make_type_32.loc11_27, %.loc11_27.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Add(%a: i32, %b: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @Add(%a.param_patt: i32, %b.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
toolchain/check/testdata/function/builtin/fail_redefined.carbon
Vendored
+39 -27
View File
@@ -76,133 +76,145 @@ fn C(n: i32, m: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %A.decl.loc11: %A.type = fn_decl @A [template = constants.%A] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %m.patt: i32 = binding_pattern m
// CHECK:STDOUT: %m.param_patt: i32 = param_pattern %m.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_9.1: type = value_of_initializer %int.make_type_32.loc11_9 [template = i32]
// CHECK:STDOUT: %.loc11_9.2: type = converted %int.make_type_32.loc11_9, %.loc11_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc11: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc11: i32 = bind_name n, %n.param.loc11
// CHECK:STDOUT: %int.make_type_32.loc11_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_17.1: type = value_of_initializer %int.make_type_32.loc11_17 [template = i32]
// CHECK:STDOUT: %.loc11_17.2: type = converted %int.make_type_32.loc11_17, %.loc11_17.1 [template = i32]
// CHECK:STDOUT: %m.param.loc11: i32 = param m, runtime_param1
// CHECK:STDOUT: %m.loc11: i32 = bind_name m, %m.param.loc11
// CHECK:STDOUT: %int.make_type_32.loc11_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_25.1: type = value_of_initializer %int.make_type_32.loc11_25 [template = i32]
// CHECK:STDOUT: %.loc11_25.2: type = converted %int.make_type_32.loc11_25, %.loc11_25.1 [template = i32]
// CHECK:STDOUT: %return.var.loc11: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc11_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc11: i32 = bind_name n, %param.loc11_6
// CHECK:STDOUT: %param.loc11_14: i32 = param runtime_param1
// CHECK:STDOUT: %m.loc11: i32 = bind_name m, %param.loc11_14
// CHECK:STDOUT: }
// CHECK:STDOUT: %A.decl.loc19: %A.type = fn_decl @A [template = constants.%A] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %m.patt: i32 = binding_pattern m
// CHECK:STDOUT: %m.param_patt: i32 = param_pattern %m.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc19_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc19_9.1: type = value_of_initializer %int.make_type_32.loc19_9 [template = i32]
// CHECK:STDOUT: %.loc19_9.2: type = converted %int.make_type_32.loc19_9, %.loc19_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc19: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc19: i32 = bind_name n, %n.param.loc19
// CHECK:STDOUT: %int.make_type_32.loc19_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc19_17.1: type = value_of_initializer %int.make_type_32.loc19_17 [template = i32]
// CHECK:STDOUT: %.loc19_17.2: type = converted %int.make_type_32.loc19_17, %.loc19_17.1 [template = i32]
// CHECK:STDOUT: %m.param.loc19: i32 = param m, runtime_param1
// CHECK:STDOUT: %m.loc19: i32 = bind_name m, %m.param.loc19
// CHECK:STDOUT: %int.make_type_32.loc19_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc19_25.1: type = value_of_initializer %int.make_type_32.loc19_25 [template = i32]
// CHECK:STDOUT: %.loc19_25.2: type = converted %int.make_type_32.loc19_25, %.loc19_25.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc19_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc19: i32 = bind_name n, %param.loc19_6
// CHECK:STDOUT: %param.loc19_14: i32 = param runtime_param1
// CHECK:STDOUT: %m.loc19: i32 = bind_name m, %param.loc19_14
// CHECK:STDOUT: }
// CHECK:STDOUT: %B.decl.loc21: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %m.patt: i32 = binding_pattern m
// CHECK:STDOUT: %m.param_patt: i32 = param_pattern %m.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc21_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc21_9.1: type = value_of_initializer %int.make_type_32.loc21_9 [template = i32]
// CHECK:STDOUT: %.loc21_9.2: type = converted %int.make_type_32.loc21_9, %.loc21_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc21: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc21: i32 = bind_name n, %n.param.loc21
// CHECK:STDOUT: %int.make_type_32.loc21_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc21_17.1: type = value_of_initializer %int.make_type_32.loc21_17 [template = i32]
// CHECK:STDOUT: %.loc21_17.2: type = converted %int.make_type_32.loc21_17, %.loc21_17.1 [template = i32]
// CHECK:STDOUT: %m.param.loc21: i32 = param m, runtime_param1
// CHECK:STDOUT: %m.loc21: i32 = bind_name m, %m.param.loc21
// CHECK:STDOUT: %int.make_type_32.loc21_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc21_25.1: type = value_of_initializer %int.make_type_32.loc21_25 [template = i32]
// CHECK:STDOUT: %.loc21_25.2: type = converted %int.make_type_32.loc21_25, %.loc21_25.1 [template = i32]
// CHECK:STDOUT: %return.var.loc21: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc21_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc21: i32 = bind_name n, %param.loc21_6
// CHECK:STDOUT: %param.loc21_14: i32 = param runtime_param1
// CHECK:STDOUT: %m.loc21: i32 = bind_name m, %param.loc21_14
// CHECK:STDOUT: }
// CHECK:STDOUT: %B.decl.loc29: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %m.patt: i32 = binding_pattern m
// CHECK:STDOUT: %m.param_patt: i32 = param_pattern %m.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc29_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc29_9.1: type = value_of_initializer %int.make_type_32.loc29_9 [template = i32]
// CHECK:STDOUT: %.loc29_9.2: type = converted %int.make_type_32.loc29_9, %.loc29_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc29: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc29: i32 = bind_name n, %n.param.loc29
// CHECK:STDOUT: %int.make_type_32.loc29_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc29_17.1: type = value_of_initializer %int.make_type_32.loc29_17 [template = i32]
// CHECK:STDOUT: %.loc29_17.2: type = converted %int.make_type_32.loc29_17, %.loc29_17.1 [template = i32]
// CHECK:STDOUT: %m.param.loc29: i32 = param m, runtime_param1
// CHECK:STDOUT: %m.loc29: i32 = bind_name m, %m.param.loc29
// CHECK:STDOUT: %int.make_type_32.loc29_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc29_25.1: type = value_of_initializer %int.make_type_32.loc29_25 [template = i32]
// CHECK:STDOUT: %.loc29_25.2: type = converted %int.make_type_32.loc29_25, %.loc29_25.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc29_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc29: i32 = bind_name n, %param.loc29_6
// CHECK:STDOUT: %param.loc29_14: i32 = param runtime_param1
// CHECK:STDOUT: %m.loc29: i32 = bind_name m, %param.loc29_14
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl.loc31: %C.type = fn_decl @C [template = constants.%C] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %m.patt: i32 = binding_pattern m
// CHECK:STDOUT: %m.param_patt: i32 = param_pattern %m.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc31_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc31_9.1: type = value_of_initializer %int.make_type_32.loc31_9 [template = i32]
// CHECK:STDOUT: %.loc31_9.2: type = converted %int.make_type_32.loc31_9, %.loc31_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc31: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc31: i32 = bind_name n, %n.param.loc31
// CHECK:STDOUT: %int.make_type_32.loc31_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc31_17.1: type = value_of_initializer %int.make_type_32.loc31_17 [template = i32]
// CHECK:STDOUT: %.loc31_17.2: type = converted %int.make_type_32.loc31_17, %.loc31_17.1 [template = i32]
// CHECK:STDOUT: %m.param.loc31: i32 = param m, runtime_param1
// CHECK:STDOUT: %m.loc31: i32 = bind_name m, %m.param.loc31
// CHECK:STDOUT: %int.make_type_32.loc31_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc31_25.1: type = value_of_initializer %int.make_type_32.loc31_25 [template = i32]
// CHECK:STDOUT: %.loc31_25.2: type = converted %int.make_type_32.loc31_25, %.loc31_25.1 [template = i32]
// CHECK:STDOUT: %return.var.loc31: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc31_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc31: i32 = bind_name n, %param.loc31_6
// CHECK:STDOUT: %param.loc31_14: i32 = param runtime_param1
// CHECK:STDOUT: %m.loc31: i32 = bind_name m, %param.loc31_14
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl.loc38: %C.type = fn_decl @C [template = constants.%C] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %m.patt: i32 = binding_pattern m
// CHECK:STDOUT: %m.param_patt: i32 = param_pattern %m.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc38_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc38_9.1: type = value_of_initializer %int.make_type_32.loc38_9 [template = i32]
// CHECK:STDOUT: %.loc38_9.2: type = converted %int.make_type_32.loc38_9, %.loc38_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc38: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc38: i32 = bind_name n, %n.param.loc38
// CHECK:STDOUT: %int.make_type_32.loc38_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc38_17.1: type = value_of_initializer %int.make_type_32.loc38_17 [template = i32]
// CHECK:STDOUT: %.loc38_17.2: type = converted %int.make_type_32.loc38_17, %.loc38_17.1 [template = i32]
// CHECK:STDOUT: %m.param.loc38: i32 = param m, runtime_param1
// CHECK:STDOUT: %m.loc38: i32 = bind_name m, %m.param.loc38
// CHECK:STDOUT: %int.make_type_32.loc38_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc38_25.1: type = value_of_initializer %int.make_type_32.loc38_25 [template = i32]
// CHECK:STDOUT: %.loc38_25.2: type = converted %int.make_type_32.loc38_25, %.loc38_25.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc38_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc38: i32 = bind_name n, %param.loc38_6
// CHECK:STDOUT: %param.loc38_14: i32 = param runtime_param1
// CHECK:STDOUT: %m.loc38: i32 = bind_name m, %param.loc38_14
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @A(%n.loc19: i32, %m.loc19: i32) -> i32 = "int.sadd" {
// CHECK:STDOUT: fn @A(%n.param_patt: i32, %m.param_patt: i32) -> i32 = "int.sadd" {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %n.ref: i32 = name_ref n, %n.loc19
// CHECK:STDOUT: return %n.ref
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%n.loc29: i32, %m.loc29: i32) -> i32 = "int.sadd" {
// CHECK:STDOUT: fn @B(%n.param_patt: i32, %m.param_patt: i32) -> i32 = "int.sadd" {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %n.ref: i32 = name_ref n, %n.loc21
// CHECK:STDOUT: return %n.ref
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%n.loc38: i32, %m.loc38: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @C(%n.param_patt: i32, %m.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
toolchain/check/testdata/function/builtin/method.carbon
Vendored
+14 -10
View File
@@ -89,22 +89,24 @@ var arr: [i32; 1.(I.F)(2)];
// CHECK:STDOUT: %Self: %I.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self]
// CHECK:STDOUT: %F.decl: %F.type.1 = fn_decl @F.1 [template = constants.%F.1] {
// CHECK:STDOUT: %self.patt: @F.1.%Self (%Self) = binding_pattern self
// CHECK:STDOUT: %self.param_patt: @F.1.%Self (%Self) = param_pattern %self.patt, runtime_param0
// CHECK:STDOUT: %other.patt: @F.1.%Self (%Self) = binding_pattern other
// CHECK:STDOUT: %other.param_patt: @F.1.%Self (%Self) = param_pattern %other.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Self.ref.loc12_14: %I.type = name_ref Self, @I.%Self [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc12_14.1: type = facet_type_access %Self.ref.loc12_14 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc12_14.2: type = converted %Self.ref.loc12_14, %.loc12_14.1 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %self.param: @F.1.%Self (%Self) = param self, runtime_param0
// CHECK:STDOUT: %self: @F.1.%Self (%Self) = bind_name self, %self.param
// CHECK:STDOUT: %Self.ref.loc12_27: %I.type = name_ref Self, @I.%Self [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc12_27.1: type = facet_type_access %Self.ref.loc12_27 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc12_27.2: type = converted %Self.ref.loc12_27, %.loc12_27.1 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %other.param: @F.1.%Self (%Self) = param other, runtime_param1
// CHECK:STDOUT: %other: @F.1.%Self (%Self) = bind_name other, %other.param
// CHECK:STDOUT: %Self.ref.loc12_36: %I.type = name_ref Self, @I.%Self [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc12_36.1: type = facet_type_access %Self.ref.loc12_36 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc12_36.2: type = converted %Self.ref.loc12_36, %.loc12_36.1 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %return: ref @F.1.%Self (%Self) = var <return slot>
// CHECK:STDOUT: %param.loc12_8: @F.1.%Self (%Self) = param runtime_param0
// CHECK:STDOUT: %self: @F.1.%Self (%Self) = bind_name self, %param.loc12_8
// CHECK:STDOUT: %param.loc12_20: @F.1.%Self (%Self) = param runtime_param1
// CHECK:STDOUT: %other: @F.1.%Self (%Self) = bind_name other, %param.loc12_20
// CHECK:STDOUT: }
// CHECK:STDOUT: %.loc12: %.2 = assoc_entity element0, %F.decl [template = constants.%.3]
// CHECK:STDOUT:
@@ -117,22 +119,24 @@ var arr: [i32; 1.(I.F)(2)];
// CHECK:STDOUT: impl @impl: %.loc15_6.2 as %I.ref {
// CHECK:STDOUT: %F.decl: %F.type.2 = fn_decl @F.2 [template = constants.%F.2] {
// CHECK:STDOUT: %self.patt: i32 = binding_pattern self
// CHECK:STDOUT: %self.param_patt: i32 = param_pattern %self.patt, runtime_param0
// CHECK:STDOUT: %other.patt: i32 = binding_pattern other
// CHECK:STDOUT: %other.param_patt: i32 = param_pattern %other.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc16_14: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc16_14.1: type = value_of_initializer %int.make_type_32.loc16_14 [template = i32]
// CHECK:STDOUT: %.loc16_14.2: type = converted %int.make_type_32.loc16_14, %.loc16_14.1 [template = i32]
// CHECK:STDOUT: %self.param: i32 = param self, runtime_param0
// CHECK:STDOUT: %self: i32 = bind_name self, %self.param
// CHECK:STDOUT: %int.make_type_32.loc16_26: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc16_26.1: type = value_of_initializer %int.make_type_32.loc16_26 [template = i32]
// CHECK:STDOUT: %.loc16_26.2: type = converted %int.make_type_32.loc16_26, %.loc16_26.1 [template = i32]
// CHECK:STDOUT: %other.param: i32 = param other, runtime_param1
// CHECK:STDOUT: %other: i32 = bind_name other, %other.param
// CHECK:STDOUT: %int.make_type_32.loc16_34: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc16_34.1: type = value_of_initializer %int.make_type_32.loc16_34 [template = i32]
// CHECK:STDOUT: %.loc16_34.2: type = converted %int.make_type_32.loc16_34, %.loc16_34.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc16_8: i32 = param runtime_param0
// CHECK:STDOUT: %self: i32 = bind_name self, %param.loc16_8
// CHECK:STDOUT: %param.loc16_19: i32 = param runtime_param1
// CHECK:STDOUT: %other: i32 = bind_name other, %param.loc16_19
// CHECK:STDOUT: }
// CHECK:STDOUT: %.loc15_15: <witness> = interface_witness (%F.decl) [template = constants.%.4]
// CHECK:STDOUT:
@@ -144,12 +148,12 @@ var arr: [i32; 1.(I.F)(2)];
// CHECK:STDOUT: generic fn @F.1(@I.%Self: %I.type) {
// CHECK:STDOUT: %Self: %I.type = bind_symbolic_name Self, 0 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%self: @F.1.%Self (%Self)](%other: @F.1.%Self (%Self)) -> @F.1.%Self (%Self);
// CHECK:STDOUT: fn[%self.param_patt: @F.1.%Self (%Self)](%other.param_patt: @F.1.%Self (%Self)) -> @F.1.%Self (%Self);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F.2[%self: i32](%other: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @F.2[%self.param_patt: i32](%other.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F.1(constants.%Self) {
// CHECK:STDOUT: %Self => constants.%Self
toolchain/check/testdata/function/builtin/no_prelude/call_from_operator.carbon
Vendored
+18 -14
View File
@@ -59,22 +59,24 @@ var arr: [i32; 1 + 2] = (3, 4, 3 + 4);
// CHECK:STDOUT: %Self: %Add.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self]
// CHECK:STDOUT: %Op.decl: %Op.type = fn_decl @Op [template = constants.%Op] {
// CHECK:STDOUT: %self.patt: @Op.%Self (%Self) = binding_pattern self
// CHECK:STDOUT: %self.param_patt: @Op.%Self (%Self) = param_pattern %self.patt, runtime_param0
// CHECK:STDOUT: %other.patt: @Op.%Self (%Self) = binding_pattern other
// CHECK:STDOUT: %other.param_patt: @Op.%Self (%Self) = param_pattern %other.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Self.ref.loc7_15: %Add.type = name_ref Self, @Add.%Self [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc7_15.1: type = facet_type_access %Self.ref.loc7_15 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc7_15.2: type = converted %Self.ref.loc7_15, %.loc7_15.1 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %self.param: @Op.%Self (%Self) = param self, runtime_param0
// CHECK:STDOUT: %self: @Op.%Self (%Self) = bind_name self, %self.param
// CHECK:STDOUT: %Self.ref.loc7_28: %Add.type = name_ref Self, @Add.%Self [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc7_28.1: type = facet_type_access %Self.ref.loc7_28 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc7_28.2: type = converted %Self.ref.loc7_28, %.loc7_28.1 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %other.param: @Op.%Self (%Self) = param other, runtime_param1
// CHECK:STDOUT: %other: @Op.%Self (%Self) = bind_name other, %other.param
// CHECK:STDOUT: %Self.ref.loc7_37: %Add.type = name_ref Self, @Add.%Self [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc7_37.1: type = facet_type_access %Self.ref.loc7_37 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %.loc7_37.2: type = converted %Self.ref.loc7_37, %.loc7_37.1 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT: %return: ref @Op.%Self (%Self) = var <return slot>
// CHECK:STDOUT: %param.loc7_9: @Op.%Self (%Self) = param runtime_param0
// CHECK:STDOUT: %self: @Op.%Self (%Self) = bind_name self, %param.loc7_9
// CHECK:STDOUT: %param.loc7_21: @Op.%Self (%Self) = param runtime_param1
// CHECK:STDOUT: %other: @Op.%Self (%Self) = bind_name other, %param.loc7_21
// CHECK:STDOUT: }
// CHECK:STDOUT: %.loc7: %.2 = assoc_entity element0, %Op.decl [template = constants.%.3]
// CHECK:STDOUT:
@@ -89,7 +91,7 @@ var arr: [i32; 1 + 2] = (3, 4, 3 + 4);
// CHECK:STDOUT: generic fn @Op(@Add.%Self: %Add.type) {
// CHECK:STDOUT: %Self: %Add.type = bind_symbolic_name Self, 0 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%self: @Op.%Self (%Self)](%other: @Op.%Self (%Self)) -> @Op.%Self (%Self);
// CHECK:STDOUT: fn[%self.param_patt: @Op.%Self (%Self)](%other.param_patt: @Op.%Self (%Self)) -> @Op.%Self (%Self);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Op(constants.%Self) {
@@ -134,9 +136,9 @@ var arr: [i32; 1 + 2] = (3, 4, 3 + 4);
// CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref Core//default, inst+2, loaded [template = constants.%Int32]
// CHECK:STDOUT: %import_ref.2: type = import_ref Core//default, inst+6, loaded [template = constants.%Add.type]
// CHECK:STDOUT: %import_ref.3 = import_ref Core//default, inst+8, unloaded
// CHECK:STDOUT: %import_ref.4: %.5 = import_ref Core//default, inst+31, loaded [template = constants.%.6]
// CHECK:STDOUT: %import_ref.5: %Op.type.2 = import_ref Core//default, inst+26, loaded [template = constants.%Op.2]
// CHECK:STDOUT: %import_ref.6 = import_ref Core//default, inst+26, unloaded
// CHECK:STDOUT: %import_ref.4: %.5 = import_ref Core//default, inst+33, loaded [template = constants.%.6]
// CHECK:STDOUT: %import_ref.5: %Op.type.2 = import_ref Core//default, inst+28, loaded [template = constants.%Op.2]
// CHECK:STDOUT: %import_ref.6 = import_ref Core//default, inst+28, unloaded
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -176,16 +178,18 @@ var arr: [i32; 1 + 2] = (3, 4, 3 + 4);
// CHECK:STDOUT: impl @impl: %.loc6_6.2 as %Add.ref {
// CHECK:STDOUT: %Op.decl: %Op.type.1 = fn_decl @Op.1 [template = constants.%Op.1] {
// CHECK:STDOUT: %self.patt: i32 = binding_pattern self
// CHECK:STDOUT: %self.param_patt: i32 = param_pattern %self.patt, runtime_param0
// CHECK:STDOUT: %other.patt: i32 = binding_pattern other
// CHECK:STDOUT: %other.param_patt: i32 = param_pattern %other.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Self.ref.loc7_15: type = name_ref Self, @impl.%.loc6_6.2 [template = i32]
// CHECK:STDOUT: %self.param: i32 = param self, runtime_param0
// CHECK:STDOUT: %self: i32 = bind_name self, %self.param
// CHECK:STDOUT: %Self.ref.loc7_28: type = name_ref Self, @impl.%.loc6_6.2 [template = i32]
// CHECK:STDOUT: %other.param: i32 = param other, runtime_param1
// CHECK:STDOUT: %other: i32 = bind_name other, %other.param
// CHECK:STDOUT: %Self.ref.loc7_37: type = name_ref Self, @impl.%.loc6_6.2 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc7_9: i32 = param runtime_param0
// CHECK:STDOUT: %self: i32 = bind_name self, %param.loc7_9
// CHECK:STDOUT: %param.loc7_21: i32 = param runtime_param1
// CHECK:STDOUT: %other: i32 = bind_name other, %param.loc7_21
// CHECK:STDOUT: }
// CHECK:STDOUT: %.loc6_22: <witness> = interface_witness (%Op.decl) [template = constants.%.2]
// CHECK:STDOUT:
@@ -196,12 +200,12 @@ var arr: [i32; 1 + 2] = (3, 4, 3 + 4);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Op.1[%self: i32](%other: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @Op.1[%self.param_patt: i32](%other.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Op.2(constants.%Self: %Add.type) {
// CHECK:STDOUT: %Self: %Add.type = bind_symbolic_name Self, 0 [symbolic = %Self (constants.%Self)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%self: @Op.2.%Self (%Self)](%other: @Op.2.%Self (%Self)) -> @Op.2.%Self (%Self);
// CHECK:STDOUT: fn[%self.param_patt: @Op.2.%Self (%Self)](%other.param_patt: @Op.2.%Self (%Self)) -> @Op.2.%Self (%Self);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
toolchain/check/testdata/function/builtin/no_prelude/import.carbon
Vendored
+9 -7
View File
@@ -41,28 +41,30 @@ var arr: [i32; Core.TestAdd(1, 2)] = (1, 2, 3);
// CHECK:STDOUT: }
// CHECK:STDOUT: %TestAdd.decl: %TestAdd.type = fn_decl @TestAdd [template = constants.%TestAdd] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc5_15: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_15.1: type = value_of_initializer %int.make_type_32.loc5_15 [template = i32]
// CHECK:STDOUT: %.loc5_15.2: type = converted %int.make_type_32.loc5_15, %.loc5_15.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc5_23: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_23.1: type = value_of_initializer %int.make_type_32.loc5_23 [template = i32]
// CHECK:STDOUT: %.loc5_23.2: type = converted %int.make_type_32.loc5_23, %.loc5_23.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc5_31: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_31.1: type = value_of_initializer %int.make_type_32.loc5_31 [template = i32]
// CHECK:STDOUT: %.loc5_31.2: type = converted %int.make_type_32.loc5_31, %.loc5_31.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param.loc5_12: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc5_12
// CHECK:STDOUT: %param.loc5_20: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc5_20
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TestAdd(%a: i32, %b: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @TestAdd(%a.param_patt: i32, %b.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
// CHECK:STDOUT: --- use.carbon
// CHECK:STDOUT:
@@ -89,7 +91,7 @@ var arr: [i32; Core.TestAdd(1, 2)] = (1, 2, 3);
// CHECK:STDOUT: import Core//core
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref Core//core, inst+2, loaded [template = constants.%Int32]
// CHECK:STDOUT: %import_ref.2: %TestAdd.type = import_ref Core//core, inst+22, loaded [template = constants.%TestAdd]
// CHECK:STDOUT: %import_ref.2: %TestAdd.type = import_ref Core//core, inst+24, loaded [template = constants.%TestAdd]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -113,7 +115,7 @@ var arr: [i32; Core.TestAdd(1, 2)] = (1, 2, 3);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TestAdd(%a: i32, %b: i32) -> i32 = "int.sadd";
// CHECK:STDOUT: fn @TestAdd(%a.param_patt: i32, %b.param_patt: i32) -> i32 = "int.sadd";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/function/call/fail_param_count.carbon
Vendored
+11 -8
View File
@@ -109,27 +109,30 @@ fn Main() {
// CHECK:STDOUT: %Run0.decl: %Run0.type = fn_decl @Run0 [template = constants.%Run0] {} {}
// CHECK:STDOUT: %Run1.decl: %Run1.type = fn_decl @Run1 [template = constants.%Run1] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc12_12.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc12_12.2: type = converted %int.make_type_32, %.loc12_12.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Run2.decl: %Run2.type = fn_decl @Run2 [template = constants.%Run2] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc13_12: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc13_12.1: type = value_of_initializer %int.make_type_32.loc13_12 [template = i32]
// CHECK:STDOUT: %.loc13_12.2: type = converted %int.make_type_32.loc13_12, %.loc13_12.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc13_20: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc13_20.1: type = value_of_initializer %int.make_type_32.loc13_20 [template = i32]
// CHECK:STDOUT: %.loc13_20.2: type = converted %int.make_type_32.loc13_20, %.loc13_20.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %param.loc13_9: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc13_9
// CHECK:STDOUT: %param.loc13_17: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc13_17
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
@@ -141,12 +144,12 @@ fn Main() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Run1(%a: i32) {
// CHECK:STDOUT: fn @Run1(%a.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Run2(%a: i32, %b: i32) {
// CHECK:STDOUT: fn @Run2(%a.param_patt: i32, %b.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/call/fail_param_type.carbon
Vendored
+25 -18
View File
@@ -11,12 +11,12 @@
fn G(a: i32) {}
fn F() {
// CHECK:STDERR: fail_param_type.carbon:[[@LINE+9]]:3: error: cannot implicitly convert from `f64` to `i32`
// CHECK:STDERR: fail_param_type.carbon:[[@LINE+9]]:5: error: cannot implicitly convert from `f64` to `i32`
// CHECK:STDERR: G(1.0);
// CHECK:STDERR: ^~
// CHECK:STDERR: fail_param_type.carbon:[[@LINE+6]]:3: note: type `f64` does not implement interface `ImplicitAs`
// CHECK:STDERR: ^~~
// CHECK:STDERR: fail_param_type.carbon:[[@LINE+6]]:5: note: type `f64` does not implement interface `ImplicitAs`
// CHECK:STDERR: G(1.0);
// CHECK:STDERR: ^~
// CHECK:STDERR: ^~~
// CHECK:STDERR: fail_param_type.carbon:[[@LINE-9]]:1: note: initializing parameter 1 of function declared here
// CHECK:STDERR: fn G(a: i32) {}
// CHECK:STDERR: ^~~~~~~~~~~~~~
@@ -39,6 +39,7 @@ fn F() {
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic]
// CHECK:STDOUT: %ImplicitAs.type.2: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic]
// CHECK:STDOUT: %Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic]
// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic]
// CHECK:STDOUT: %Self.2: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic]
// CHECK:STDOUT: %Convert.type.1: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic]
// CHECK:STDOUT: %Convert.1: %Convert.type.1 = struct_value () [symbolic]
@@ -66,12 +67,12 @@ fn F() {
// CHECK:STDOUT: import Core//prelude/types/bool
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref Core//prelude/types, inst+4, loaded [template = constants.%Int32]
// CHECK:STDOUT: %import_ref.2: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs]
// CHECK:STDOUT: %import_ref.3 = import_ref Core//prelude/operators/as, inst+45, unloaded
// CHECK:STDOUT: %import_ref.4: @ImplicitAs.%.1 (%.3) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.7)]
// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+56, unloaded
// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded
// CHECK:STDOUT: %import_ref.7 = import_ref Core//prelude/operators/as, inst+56, unloaded
// CHECK:STDOUT: %import_ref.2: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+46, loaded [template = constants.%ImplicitAs]
// CHECK:STDOUT: %import_ref.3 = import_ref Core//prelude/operators/as, inst+52, unloaded
// CHECK:STDOUT: %import_ref.4: @ImplicitAs.%.1 (%.3) = import_ref Core//prelude/operators/as, inst+71, loaded [symbolic = @ImplicitAs.%.2 (constants.%.7)]
// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+64, unloaded
// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+64, unloaded
// CHECK:STDOUT: %import_ref.7 = import_ref Core//prelude/operators/as, inst+64, unloaded
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -83,18 +84,20 @@ fn F() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_9.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc11_9.2: type = converted %int.make_type_32, %.loc11_9.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) {
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)]
// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt (constants.%Dest.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
@@ -114,7 +117,7 @@ fn F() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G(%a: i32) {
// CHECK:STDOUT: fn @G(%a.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -122,11 +125,11 @@ fn F() {
// CHECK:STDOUT: fn @F() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %G.ref: %G.type = name_ref G, file.%G.decl [template = constants.%G]
// CHECK:STDOUT: %.loc23_5: f64 = float_literal 1 [template = constants.%.2]
// CHECK:STDOUT: %.loc23_5.1: f64 = float_literal 1 [template = constants.%.2]
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(i32) [template = constants.%ImplicitAs.type.3]
// CHECK:STDOUT: %.loc23_4.1: %.5 = specific_constant imports.%import_ref.4, @ImplicitAs(i32) [template = constants.%.6]
// CHECK:STDOUT: %Convert.ref: %.5 = name_ref Convert, %.loc23_4.1 [template = constants.%.6]
// CHECK:STDOUT: %.loc23_4.2: i32 = converted %.loc23_5, <error> [template = <error>]
// CHECK:STDOUT: %.loc23_5.2: %.5 = specific_constant imports.%import_ref.4, @ImplicitAs(i32) [template = constants.%.6]
// CHECK:STDOUT: %Convert.ref: %.5 = name_ref Convert, %.loc23_5.2 [template = constants.%.6]
// CHECK:STDOUT: %.loc23_5.3: i32 = converted %.loc23_5.1, <error> [template = <error>]
// CHECK:STDOUT: %G.call: init %.1 = call %G.ref(<invalid>) [template = <error>]
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -136,19 +139,22 @@ fn F() {
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
// CHECK:STDOUT: %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%self: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest);
// CHECK:STDOUT: fn[%self.param_patt: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.1) {
@@ -159,6 +165,7 @@ fn F() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(i32) {
// CHECK:STDOUT: %Dest => i32
// CHECK:STDOUT: %Dest.patt => i32
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3
toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon
Vendored
+15 -9
View File
@@ -39,6 +39,7 @@ fn Run() {
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic]
// CHECK:STDOUT: %ImplicitAs.type.2: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic]
// CHECK:STDOUT: %Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic]
// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic]
// CHECK:STDOUT: %Self.2: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic]
// CHECK:STDOUT: %Convert.type.1: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic]
// CHECK:STDOUT: %Convert.1: %Convert.type.1 = struct_value () [symbolic]
@@ -66,14 +67,14 @@ fn Run() {
// CHECK:STDOUT: import Core//prelude/operators/comparison
// CHECK:STDOUT: import Core//prelude/types/bool
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %Float.type = import_ref Core//prelude/types, inst+35, loaded [template = constants.%Float]
// CHECK:STDOUT: %import_ref.1: %Float.type = import_ref Core//prelude/types, inst+38, loaded [template = constants.%Float]
// CHECK:STDOUT: %import_ref.2: %Int32.type = import_ref Core//prelude/types, inst+4, loaded [template = constants.%Int32]
// CHECK:STDOUT: %import_ref.3: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs]
// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+45, unloaded
// CHECK:STDOUT: %import_ref.5: @ImplicitAs.%.1 (%.4) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.8)]
// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded
// CHECK:STDOUT: %import_ref.7 = import_ref Core//prelude/operators/as, inst+56, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Core//prelude/operators/as, inst+56, unloaded
// CHECK:STDOUT: %import_ref.3: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+46, loaded [template = constants.%ImplicitAs]
// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+52, unloaded
// CHECK:STDOUT: %import_ref.5: @ImplicitAs.%.1 (%.4) = import_ref Core//prelude/operators/as, inst+71, loaded [symbolic = @ImplicitAs.%.2 (constants.%.8)]
// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+64, unloaded
// CHECK:STDOUT: %import_ref.7 = import_ref Core//prelude/operators/as, inst+64, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Core//prelude/operators/as, inst+64, unloaded
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -95,6 +96,7 @@ fn Run() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) {
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)]
// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt (constants.%Dest.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
@@ -112,7 +114,7 @@ fn Run() {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size: i32) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: i32) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo() -> f64 {
// CHECK:STDOUT: !entry:
@@ -146,19 +148,22 @@ fn Run() {
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
// CHECK:STDOUT: %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%self: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest);
// CHECK:STDOUT: fn[%self.param_patt: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.1) {
@@ -169,6 +174,7 @@ fn Run() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(i32) {
// CHECK:STDOUT: %Dest => i32
// CHECK:STDOUT: %Dest.patt => i32
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3
toolchain/check/testdata/function/call/i32.carbon
Vendored
+4 -3
View File
@@ -53,23 +53,24 @@ fn Main() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Echo.decl: %Echo.type = fn_decl @Echo [template = constants.%Echo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_12: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_12.1: type = value_of_initializer %int.make_type_32.loc11_12 [template = i32]
// CHECK:STDOUT: %.loc11_12.2: type = converted %int.make_type_32.loc11_12, %.loc11_12.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_20: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_20.1: type = value_of_initializer %int.make_type_32.loc11_20 [template = i32]
// CHECK:STDOUT: %.loc11_20.2: type = converted %int.make_type_32.loc11_20, %.loc11_20.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Echo(%a: i32) -> i32 {
// CHECK:STDOUT: fn @Echo(%a.param_patt: i32) -> i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %a.ref: i32 = name_ref a, %a
// CHECK:STDOUT: return %a.ref
toolchain/check/testdata/function/call/more_param_ir.carbon
Vendored
+7 -5
View File
@@ -58,25 +58,27 @@ fn Main() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32, %b: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32, %b.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/call/no_prelude/empty_struct.carbon
Vendored
+7 -6
View File
@@ -35,19 +35,20 @@ fn Main() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Echo.decl: %Echo.type = fn_decl @Echo [template = constants.%Echo] {
// CHECK:STDOUT: %a.patt: %.1 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %.1 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc11_13.1: %.1 = struct_literal ()
// CHECK:STDOUT: %.loc11_13.2: type = converted %.loc11_13.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %a.param: %.1 = param a, runtime_param0
// CHECK:STDOUT: %a: %.1 = bind_name a, %a.param
// CHECK:STDOUT: %.loc11_20.1: %.1 = struct_literal ()
// CHECK:STDOUT: %.loc11_20.2: type = converted %.loc11_20.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %return: ref %.1 = var <return slot>
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %a: %.1 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Echo(%a: %.1) -> %.1 {
// CHECK:STDOUT: fn @Echo(%a.param_patt: %.1) -> %.1 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %a.ref: %.1 = name_ref a, %a
// CHECK:STDOUT: return %a.ref
@@ -56,10 +57,10 @@ fn Main() {
// CHECK:STDOUT: fn @Main() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Echo.ref: %Echo.type = name_ref Echo, file.%Echo.decl [template = constants.%Echo]
// CHECK:STDOUT: %.loc16_9: %.1 = struct_literal ()
// CHECK:STDOUT: %.loc16_9.1: %.1 = struct_literal ()
// CHECK:STDOUT: %struct: %.1 = struct_value () [template = constants.%struct]
// CHECK:STDOUT: %.loc16_7: %.1 = converted %.loc16_9, %struct [template = constants.%struct]
// CHECK:STDOUT: %Echo.call: init %.1 = call %Echo.ref(%.loc16_7)
// CHECK:STDOUT: %.loc16_9.2: %.1 = converted %.loc16_9.1, %struct [template = constants.%struct]
// CHECK:STDOUT: %Echo.call: init %.1 = call %Echo.ref(%.loc16_9.2)
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/call/no_prelude/empty_tuple.carbon
Vendored
+7 -6
View File
@@ -34,19 +34,20 @@ fn Main() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Echo.decl: %Echo.type = fn_decl @Echo [template = constants.%Echo] {
// CHECK:STDOUT: %a.patt: %.1 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %.1 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc11_13.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc11_13.2: type = converted %.loc11_13.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %a.param: %.1 = param a, runtime_param0
// CHECK:STDOUT: %a: %.1 = bind_name a, %a.param
// CHECK:STDOUT: %.loc11_20.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc11_20.2: type = converted %.loc11_20.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %return: ref %.1 = var <return slot>
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %a: %.1 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Echo(%a: %.1) -> %.1 {
// CHECK:STDOUT: fn @Echo(%a.param_patt: %.1) -> %.1 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %a.ref: %.1 = name_ref a, %a
// CHECK:STDOUT: return %a.ref
@@ -55,10 +56,10 @@ fn Main() {
// CHECK:STDOUT: fn @Main() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Echo.ref: %Echo.type = name_ref Echo, file.%Echo.decl [template = constants.%Echo]
// CHECK:STDOUT: %.loc16_9: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc16_9.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %tuple: %.1 = tuple_value () [template = constants.%tuple]
// CHECK:STDOUT: %.loc16_7: %.1 = converted %.loc16_9, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %Echo.call: init %.1 = call %Echo.ref(%.loc16_7)
// CHECK:STDOUT: %.loc16_9.2: %.1 = converted %.loc16_9.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %Echo.call: init %.1 = call %Echo.ref(%.loc16_9.2)
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/call/no_prelude/fail_explicit_self_param.carbon
Vendored
+7 -6
View File
@@ -35,24 +35,25 @@ fn Run() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %self.patt: %.1 = binding_pattern self
// CHECK:STDOUT: %self.param_patt: %.1 = param_pattern %self.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc14_13.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc14_13.2: type = converted %.loc14_13.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %self.param: %.1 = param self, runtime_param0
// CHECK:STDOUT: %self: %.1 = bind_name self, %self.param
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %self: %.1 = bind_name self, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Run.decl: %Run.type = fn_decl @Run [template = constants.%Run] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F(%self: %.1);
// CHECK:STDOUT: fn @F(%self.param_patt: %.1);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Run() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %.loc17_6: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc17_6.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %tuple: %.1 = tuple_value () [template = constants.%tuple]
// CHECK:STDOUT: %.loc17_4: %.1 = converted %.loc17_6, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %F.call: init %.1 = call %F.ref(%.loc17_4)
// CHECK:STDOUT: %.loc17_6.2: %.1 = converted %.loc17_6.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %F.call: init %.1 = call %F.ref(%.loc17_6.2)
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/call/no_prelude/fail_runtime_implicit_param.carbon
Vendored
+4 -3
View File
@@ -34,16 +34,17 @@ fn Run() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %s.patt: %.1 = binding_pattern s
// CHECK:STDOUT: %s.param_patt: %.1 = param_pattern %s.patt, runtime_param<invalid>
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc14_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc14_10.2: type = converted %.loc14_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %s.param: %.1 = param s, runtime_param<invalid>
// CHECK:STDOUT: %s: %.1 = bind_name s, %s.param
// CHECK:STDOUT: %param: %.1 = param runtime_param<invalid>
// CHECK:STDOUT: %s: %.1 = bind_name s, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Run.decl: %Run.type = fn_decl @Run [template = constants.%Run] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F[%base.param: <error>]();
// CHECK:STDOUT: fn @F[%s.param_patt: %.1]();
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Run() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/function/call/params_one.carbon
Vendored
+4 -3
View File
@@ -51,19 +51,20 @@ fn Main() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/call/params_one_comma.carbon
Vendored
+4 -3
View File
@@ -52,19 +52,20 @@ fn Main() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/call/params_two.carbon
Vendored
+7 -5
View File
@@ -52,25 +52,27 @@ fn Main() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32, %b: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32, %b.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/call/params_two_comma.carbon
Vendored
+7 -5
View File
@@ -53,25 +53,27 @@ fn Main() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: %Main.decl: %Main.type = fn_decl @Main [template = constants.%Main] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32, %b: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32, %b.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/declaration/fail_param_in_type.carbon
Vendored
+7 -5
View File
@@ -46,22 +46,24 @@ fn F(n: i32, a: [i32; n]*);
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %a.patt: <error> = binding_pattern a
// CHECK:STDOUT: %a.param_patt: <error> = param_pattern %a.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc14_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc14_9.1: type = value_of_initializer %int.make_type_32.loc14_9 [template = i32]
// CHECK:STDOUT: %.loc14_9.2: type = converted %int.make_type_32.loc14_9, %.loc14_9.1 [template = i32]
// CHECK:STDOUT: %n.param: i32 = param n, runtime_param0
// CHECK:STDOUT: %n: i32 = bind_name n, %n.param
// CHECK:STDOUT: %int.make_type_32.loc14_18: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %n.ref: i32 = name_ref n, %n
// CHECK:STDOUT: %.loc14_25: type = ptr_type <error> [template = <error>]
// CHECK:STDOUT: %a.param: <error> = param a, runtime_param1
// CHECK:STDOUT: %a: <error> = bind_name a, %a.param
// CHECK:STDOUT: %param.loc14_6: i32 = param runtime_param0
// CHECK:STDOUT: %n: i32 = bind_name n, %param.loc14_6
// CHECK:STDOUT: %param.loc14_14: <error> = param runtime_param1
// CHECK:STDOUT: %a: <error> = bind_name a, %param.loc14_14
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F(%n: i32, %a: <error>);
// CHECK:STDOUT: fn @F(%n.param_patt: i32, %a.param_patt: <error>);
// CHECK:STDOUT:
toolchain/check/testdata/function/declaration/fail_param_redecl.carbon
Vendored
+7 -5
View File
@@ -49,22 +49,24 @@ fn F(n: i32, n: i32);
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %n.patt.loc17_6: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt.loc17_7: i32 = param_pattern %n.patt.loc17_6, runtime_param0
// CHECK:STDOUT: %n.patt.loc17_14: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt.loc17_15: i32 = param_pattern %n.patt.loc17_14, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc17_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc17_9.1: type = value_of_initializer %int.make_type_32.loc17_9 [template = i32]
// CHECK:STDOUT: %.loc17_9.2: type = converted %int.make_type_32.loc17_9, %.loc17_9.1 [template = i32]
// CHECK:STDOUT: %n.param.loc17_6: i32 = param n, runtime_param0
// CHECK:STDOUT: %n.loc17_6: i32 = bind_name n, %n.param.loc17_6
// CHECK:STDOUT: %int.make_type_32.loc17_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc17_17.1: type = value_of_initializer %int.make_type_32.loc17_17 [template = i32]
// CHECK:STDOUT: %.loc17_17.2: type = converted %int.make_type_32.loc17_17, %.loc17_17.1 [template = i32]
// CHECK:STDOUT: %n.param.loc17_14: i32 = param n, runtime_param1
// CHECK:STDOUT: %n.loc17_14: i32 = bind_name n, %n.param.loc17_14
// CHECK:STDOUT: %param.loc17_6: i32 = param runtime_param0
// CHECK:STDOUT: %n.loc17_6: i32 = bind_name n, %param.loc17_6
// CHECK:STDOUT: %param.loc17_14: i32 = param runtime_param1
// CHECK:STDOUT: %n.loc17_14: i32 = bind_name n, %param.loc17_14
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F(%n.loc17_6: i32, %n.loc17_14: i32);
// CHECK:STDOUT: fn @F(%n.param_patt.loc17_7: i32, %n.param_patt.loc17_15: i32);
// CHECK:STDOUT:
toolchain/check/testdata/function/declaration/import.carbon
Vendored
+92 -88
View File
@@ -304,32 +304,34 @@ import library "extern_api";
// CHECK:STDOUT: %A.decl: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: %B.decl: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc5_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_9.1: type = value_of_initializer %int.make_type_32.loc5_9 [template = i32]
// CHECK:STDOUT: %.loc5_9.2: type = converted %int.make_type_32.loc5_9, %.loc5_9.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc5_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_17.1: type = value_of_initializer %int.make_type_32.loc5_17 [template = i32]
// CHECK:STDOUT: %.loc5_17.2: type = converted %int.make_type_32.loc5_17, %.loc5_17.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: %C.type = fn_decl @C [template = constants.%C] {
// CHECK:STDOUT: %c.patt: %.3 = binding_pattern c
// CHECK:STDOUT: %c.param_patt: %.3 = param_pattern %c.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc6_10: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_14.1: %.2 = tuple_literal (%int.make_type_32.loc6_10)
// CHECK:STDOUT: %.loc6_14.2: type = value_of_initializer %int.make_type_32.loc6_10 [template = i32]
// CHECK:STDOUT: %.loc6_14.3: type = converted %int.make_type_32.loc6_10, %.loc6_14.2 [template = i32]
// CHECK:STDOUT: %.loc6_14.4: type = converted %.loc6_14.1, constants.%.3 [template = constants.%.3]
// CHECK:STDOUT: %c.param: %.3 = param c, runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %c.param
// CHECK:STDOUT: %int.make_type_32.loc6_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_25.1: type = value_of_initializer %int.make_type_32.loc6_25 [template = i32]
// CHECK:STDOUT: %.loc6_25.2: type = converted %int.make_type_32.loc6_25, %.loc6_25.1 [template = i32]
// CHECK:STDOUT: %.loc6_28: type = struct_type {.c: i32} [template = constants.%.4]
// CHECK:STDOUT: %return: ref %.4 = var <return slot>
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %D.decl: %D.type = fn_decl @D [template = constants.%D] {} {}
// CHECK:STDOUT: %NS: <namespace> = namespace [template] {
@@ -342,9 +344,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b: i32) -> i32;
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%c: %.3) -> %.4;
// CHECK:STDOUT: fn @C(%c.param_patt: %.3) -> %.4;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -399,32 +401,34 @@ import library "extern_api";
// CHECK:STDOUT: %A.decl: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: %B.decl: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc5_44: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_44.1: type = value_of_initializer %int.make_type_32.loc5_44 [template = i32]
// CHECK:STDOUT: %.loc5_44.2: type = converted %int.make_type_32.loc5_44, %.loc5_44.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc5_52: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_52.1: type = value_of_initializer %int.make_type_32.loc5_52 [template = i32]
// CHECK:STDOUT: %.loc5_52.2: type = converted %int.make_type_32.loc5_52, %.loc5_52.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: %C.type = fn_decl @C [template = constants.%C] {
// CHECK:STDOUT: %c.patt: %.3 = binding_pattern c
// CHECK:STDOUT: %c.param_patt: %.3 = param_pattern %c.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc6_45: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_49.1: %.2 = tuple_literal (%int.make_type_32.loc6_45)
// CHECK:STDOUT: %.loc6_49.2: type = value_of_initializer %int.make_type_32.loc6_45 [template = i32]
// CHECK:STDOUT: %.loc6_49.3: type = converted %int.make_type_32.loc6_45, %.loc6_49.2 [template = i32]
// CHECK:STDOUT: %.loc6_49.4: type = converted %.loc6_49.1, constants.%.3 [template = constants.%.3]
// CHECK:STDOUT: %c.param: %.3 = param c, runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %c.param
// CHECK:STDOUT: %int.make_type_32.loc6_60: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_60.1: type = value_of_initializer %int.make_type_32.loc6_60 [template = i32]
// CHECK:STDOUT: %.loc6_60.2: type = converted %int.make_type_32.loc6_60, %.loc6_60.1 [template = i32]
// CHECK:STDOUT: %.loc6_63: type = struct_type {.c: i32} [template = constants.%.4]
// CHECK:STDOUT: %return: ref %.4 = var <return slot>
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %D.decl: %D.type = fn_decl @D [template = constants.%D] {} {}
// CHECK:STDOUT: %NS: <namespace> = namespace [template] {
@@ -437,9 +441,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @B(%b: i32) -> i32;
// CHECK:STDOUT: extern fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @C(%c: %.3) -> %.4;
// CHECK:STDOUT: extern fn @C(%c.param_patt: %.3) -> %.4;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -469,14 +473,14 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//api, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//api, inst+22, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//api, inst+43, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//api, inst+46, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//api, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//api, inst+45, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//api, inst+48, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = %import_ref.6
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//api, inst+50, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//api, inst+52, loaded [template = constants.%E]
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.7
// CHECK:STDOUT: import Core//prelude
@@ -536,9 +540,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b: i32) -> i32;
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%c: %.4) -> %.3;
// CHECK:STDOUT: fn @C(%c.param_patt: %.4) -> %.3;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -555,10 +559,10 @@ import library "extern_api";
// CHECK:STDOUT: assign file.%b.var, %B.call
// CHECK:STDOUT: %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
// CHECK:STDOUT: %.loc8_23: i32 = int_literal 1 [template = constants.%.2]
// CHECK:STDOUT: %.loc8_25: %.4 = tuple_literal (%.loc8_23)
// CHECK:STDOUT: %.loc8_25.1: %.4 = tuple_literal (%.loc8_23)
// CHECK:STDOUT: %tuple: %.4 = tuple_value (%.loc8_23) [template = constants.%tuple]
// CHECK:STDOUT: %.loc8_21: %.4 = converted %.loc8_25, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc8_21)
// CHECK:STDOUT: %.loc8_25.2: %.4 = converted %.loc8_25.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc8_25.2)
// CHECK:STDOUT: assign file.%c.var, %C.call
// CHECK:STDOUT: %D.ref: %D.type = name_ref D, imports.%import_ref.4 [template = constants.%D]
// CHECK:STDOUT: %D.call: init %.1 = call %D.ref()
@@ -595,14 +599,14 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//api, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//api, inst+22, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//api, inst+43, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//api, inst+46, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//api, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//api, inst+45, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//api, inst+48, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = file.%E.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//api, inst+50, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//api, inst+52, loaded [template = constants.%E]
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.7
// CHECK:STDOUT: import Core//prelude
@@ -638,12 +642,12 @@ import library "extern_api";
// CHECK:STDOUT: %int.make_type_32.loc23_16: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc23_16.1: type = value_of_initializer %int.make_type_32.loc23_16 [template = i32]
// CHECK:STDOUT: %.loc23_16.2: type = converted %int.make_type_32.loc23_16, %.loc23_16.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param0
// CHECK:STDOUT: %b.loc23: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc23_24: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc23_24.1: type = value_of_initializer %int.make_type_32.loc23_24 [template = i32]
// CHECK:STDOUT: %.loc23_24.2: type = converted %int.make_type_32.loc23_24, %.loc23_24.1 [template = i32]
// CHECK:STDOUT: %return.var: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: %C.type = fn_decl @C [template = constants.%C] {} {
// CHECK:STDOUT: %int.make_type_32.loc32_17: init type = call constants.%Int32() [template = i32]
@@ -651,13 +655,13 @@ import library "extern_api";
// CHECK:STDOUT: %.loc32_21.2: type = value_of_initializer %int.make_type_32.loc32_17 [template = i32]
// CHECK:STDOUT: %.loc32_21.3: type = converted %int.make_type_32.loc32_17, %.loc32_21.2 [template = i32]
// CHECK:STDOUT: %.loc32_21.4: type = converted %.loc32_21.1, constants.%.3 [template = constants.%.3]
// CHECK:STDOUT: %c.param: %.3 = param c, runtime_param0
// CHECK:STDOUT: %c.loc32: %.3 = bind_name c, %c.param
// CHECK:STDOUT: %int.make_type_32.loc32_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc32_32.1: type = value_of_initializer %int.make_type_32.loc32_32 [template = i32]
// CHECK:STDOUT: %.loc32_32.2: type = converted %int.make_type_32.loc32_32, %.loc32_32.1 [template = i32]
// CHECK:STDOUT: %.loc32_35: type = struct_type {.c: i32} [template = constants.%.4]
// CHECK:STDOUT: %return.var: ref %.4 = var <return slot>
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %D.decl: %D.type = fn_decl @D [template = constants.%D] {} {}
// CHECK:STDOUT: %E.decl: %E.type = fn_decl @E [template = constants.%E] {} {}
@@ -690,9 +694,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b.1: i32) -> i32;
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%c.1: %.3) -> %.4;
// CHECK:STDOUT: fn @C(%c.param_patt: %.3) -> %.4;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -709,10 +713,10 @@ import library "extern_api";
// CHECK:STDOUT: assign file.%b.var, %B.call
// CHECK:STDOUT: %C.ref: %C.type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %.loc54_23: i32 = int_literal 1 [template = constants.%.5]
// CHECK:STDOUT: %.loc54_25: %.3 = tuple_literal (%.loc54_23)
// CHECK:STDOUT: %.loc54_25.1: %.3 = tuple_literal (%.loc54_23)
// CHECK:STDOUT: %tuple: %.3 = tuple_value (%.loc54_23) [template = constants.%tuple]
// CHECK:STDOUT: %.loc54_21: %.3 = converted %.loc54_25, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.4 = call %C.ref(%.loc54_21)
// CHECK:STDOUT: %.loc54_25.2: %.3 = converted %.loc54_25.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.4 = call %C.ref(%.loc54_25.2)
// CHECK:STDOUT: assign file.%c.var, %C.call
// CHECK:STDOUT: %D.ref: %D.type = name_ref D, file.%D.decl [template = constants.%D]
// CHECK:STDOUT: %D.call: init %.1 = call %D.ref()
@@ -749,14 +753,14 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//extern_api, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//extern_api, inst+22, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//extern_api, inst+43, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//extern_api, inst+46, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//extern_api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//extern_api, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//extern_api, inst+45, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//extern_api, inst+48, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//extern_api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = file.%E.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//extern_api, inst+50, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//extern_api, inst+52, loaded [template = constants.%E]
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.7
// CHECK:STDOUT: import Core//prelude
@@ -792,12 +796,12 @@ import library "extern_api";
// CHECK:STDOUT: %int.make_type_32.loc7_16: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc7_16.1: type = value_of_initializer %int.make_type_32.loc7_16 [template = i32]
// CHECK:STDOUT: %.loc7_16.2: type = converted %int.make_type_32.loc7_16, %.loc7_16.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param0
// CHECK:STDOUT: %b.loc7: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc7_24: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc7_24.1: type = value_of_initializer %int.make_type_32.loc7_24 [template = i32]
// CHECK:STDOUT: %.loc7_24.2: type = converted %int.make_type_32.loc7_24, %.loc7_24.1 [template = i32]
// CHECK:STDOUT: %return.var: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: %C.type = fn_decl @C [template = constants.%C] {} {
// CHECK:STDOUT: %int.make_type_32.loc8_17: init type = call constants.%Int32() [template = i32]
@@ -805,13 +809,13 @@ import library "extern_api";
// CHECK:STDOUT: %.loc8_21.2: type = value_of_initializer %int.make_type_32.loc8_17 [template = i32]
// CHECK:STDOUT: %.loc8_21.3: type = converted %int.make_type_32.loc8_17, %.loc8_21.2 [template = i32]
// CHECK:STDOUT: %.loc8_21.4: type = converted %.loc8_21.1, constants.%.3 [template = constants.%.3]
// CHECK:STDOUT: %c.param: %.3 = param c, runtime_param0
// CHECK:STDOUT: %c.loc8: %.3 = bind_name c, %c.param
// CHECK:STDOUT: %int.make_type_32.loc8_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc8_32.1: type = value_of_initializer %int.make_type_32.loc8_32 [template = i32]
// CHECK:STDOUT: %.loc8_32.2: type = converted %int.make_type_32.loc8_32, %.loc8_32.1 [template = i32]
// CHECK:STDOUT: %.loc8_35: type = struct_type {.c: i32} [template = constants.%.4]
// CHECK:STDOUT: %return.var: ref %.4 = var <return slot>
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %D.decl: %D.type = fn_decl @D [template = constants.%D] {} {}
// CHECK:STDOUT: %E.decl: %E.type = fn_decl @E [template = constants.%E] {} {}
@@ -844,9 +848,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @B(%b.1: i32) -> i32;
// CHECK:STDOUT: extern fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @C(%c.1: %.3) -> %.4;
// CHECK:STDOUT: extern fn @C(%c.param_patt: %.3) -> %.4;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -863,10 +867,10 @@ import library "extern_api";
// CHECK:STDOUT: assign file.%b.var, %B.call
// CHECK:STDOUT: %C.ref: %C.type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %.loc14_23: i32 = int_literal 1 [template = constants.%.5]
// CHECK:STDOUT: %.loc14_25: %.3 = tuple_literal (%.loc14_23)
// CHECK:STDOUT: %.loc14_25.1: %.3 = tuple_literal (%.loc14_23)
// CHECK:STDOUT: %tuple: %.3 = tuple_value (%.loc14_23) [template = constants.%tuple]
// CHECK:STDOUT: %.loc14_21: %.3 = converted %.loc14_25, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.4 = call %C.ref(%.loc14_21)
// CHECK:STDOUT: %.loc14_25.2: %.3 = converted %.loc14_25.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.4 = call %C.ref(%.loc14_25.2)
// CHECK:STDOUT: assign file.%c.var, %C.call
// CHECK:STDOUT: %D.ref: %D.type = name_ref D, file.%D.decl [template = constants.%D]
// CHECK:STDOUT: %D.call: init %.1 = call %D.ref()
@@ -902,19 +906,19 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//api, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//api, inst+22, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//api, inst+43, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//api, inst+46, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//api, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//api, inst+45, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//api, inst+48, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = %import_ref.6
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//api, inst+50, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//api, inst+52, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.7 = import_ref Main//extern_api, inst+3, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Main//extern_api, inst+22, unloaded
// CHECK:STDOUT: %import_ref.9 = import_ref Main//extern_api, inst+43, unloaded
// CHECK:STDOUT: %import_ref.10 = import_ref Main//extern_api, inst+46, unloaded
// CHECK:STDOUT: %import_ref.11 = import_ref Main//extern_api, inst+50, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Main//extern_api, inst+23, unloaded
// CHECK:STDOUT: %import_ref.9 = import_ref Main//extern_api, inst+45, unloaded
// CHECK:STDOUT: %import_ref.10 = import_ref Main//extern_api, inst+48, unloaded
// CHECK:STDOUT: %import_ref.11 = import_ref Main//extern_api, inst+52, unloaded
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.12
// CHECK:STDOUT: import Core//prelude
@@ -974,9 +978,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b: i32) -> i32;
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%c: %.4) -> %.3;
// CHECK:STDOUT: fn @C(%c.param_patt: %.4) -> %.3;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -993,10 +997,10 @@ import library "extern_api";
// CHECK:STDOUT: assign file.%b.var, %B.call
// CHECK:STDOUT: %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
// CHECK:STDOUT: %.loc54_23: i32 = int_literal 1 [template = constants.%.2]
// CHECK:STDOUT: %.loc54_25: %.4 = tuple_literal (%.loc54_23)
// CHECK:STDOUT: %.loc54_25.1: %.4 = tuple_literal (%.loc54_23)
// CHECK:STDOUT: %tuple: %.4 = tuple_value (%.loc54_23) [template = constants.%tuple]
// CHECK:STDOUT: %.loc54_21: %.4 = converted %.loc54_25, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc54_21)
// CHECK:STDOUT: %.loc54_25.2: %.4 = converted %.loc54_25.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc54_25.2)
// CHECK:STDOUT: assign file.%c.var, %C.call
// CHECK:STDOUT: %D.ref: %D.type = name_ref D, imports.%import_ref.4 [template = constants.%D]
// CHECK:STDOUT: %D.call: init %.1 = call %D.ref()
@@ -1032,19 +1036,19 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//extern_api, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//extern_api, inst+22, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//extern_api, inst+43, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//extern_api, inst+46, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//extern_api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//extern_api, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//extern_api, inst+45, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//extern_api, inst+48, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//extern_api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = %import_ref.6
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//extern_api, inst+50, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.6: %E.type = import_ref Main//extern_api, inst+52, loaded [template = constants.%E]
// CHECK:STDOUT: %import_ref.7 = import_ref Main//api, inst+3, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Main//api, inst+22, unloaded
// CHECK:STDOUT: %import_ref.9 = import_ref Main//api, inst+43, unloaded
// CHECK:STDOUT: %import_ref.10 = import_ref Main//api, inst+46, unloaded
// CHECK:STDOUT: %import_ref.11 = import_ref Main//api, inst+50, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Main//api, inst+23, unloaded
// CHECK:STDOUT: %import_ref.9 = import_ref Main//api, inst+45, unloaded
// CHECK:STDOUT: %import_ref.10 = import_ref Main//api, inst+48, unloaded
// CHECK:STDOUT: %import_ref.11 = import_ref Main//api, inst+52, unloaded
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.12
// CHECK:STDOUT: import Core//prelude
@@ -1104,9 +1108,9 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @B(%b: i32) -> i32;
// CHECK:STDOUT: extern fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @C(%c: %.4) -> %.3;
// CHECK:STDOUT: extern fn @C(%c.param_patt: %.4) -> %.3;
// CHECK:STDOUT:
// CHECK:STDOUT: extern fn @D();
// CHECK:STDOUT:
@@ -1123,10 +1127,10 @@ import library "extern_api";
// CHECK:STDOUT: assign file.%b.var, %B.call
// CHECK:STDOUT: %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
// CHECK:STDOUT: %.loc53_23: i32 = int_literal 1 [template = constants.%.2]
// CHECK:STDOUT: %.loc53_25: %.4 = tuple_literal (%.loc53_23)
// CHECK:STDOUT: %.loc53_25.1: %.4 = tuple_literal (%.loc53_23)
// CHECK:STDOUT: %tuple: %.4 = tuple_value (%.loc53_23) [template = constants.%tuple]
// CHECK:STDOUT: %.loc53_21: %.4 = converted %.loc53_25, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc53_21)
// CHECK:STDOUT: %.loc53_25.2: %.4 = converted %.loc53_25.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc53_25.2)
// CHECK:STDOUT: assign file.%c.var, %C.call
// CHECK:STDOUT: %D.ref: %D.type = name_ref D, imports.%import_ref.4 [template = constants.%D]
// CHECK:STDOUT: %D.call: init %.1 = call %D.ref()
@@ -1142,14 +1146,14 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1 = import_ref Main//api, inst+3, unloaded
// CHECK:STDOUT: %import_ref.2 = import_ref Main//api, inst+22, unloaded
// CHECK:STDOUT: %import_ref.3 = import_ref Main//api, inst+43, unloaded
// CHECK:STDOUT: %import_ref.4 = import_ref Main//api, inst+46, unloaded
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2 = import_ref Main//api, inst+23, unloaded
// CHECK:STDOUT: %import_ref.3 = import_ref Main//api, inst+45, unloaded
// CHECK:STDOUT: %import_ref.4 = import_ref Main//api, inst+48, unloaded
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = %import_ref.6
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6 = import_ref Main//api, inst+50, unloaded
// CHECK:STDOUT: %import_ref.6 = import_ref Main//api, inst+52, unloaded
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/operators
@@ -1179,14 +1183,14 @@ import library "extern_api";
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1 = import_ref Main//extern_api, inst+3, unloaded
// CHECK:STDOUT: %import_ref.2 = import_ref Main//extern_api, inst+22, unloaded
// CHECK:STDOUT: %import_ref.3 = import_ref Main//extern_api, inst+43, unloaded
// CHECK:STDOUT: %import_ref.4 = import_ref Main//extern_api, inst+46, unloaded
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//extern_api, inst+49, loaded
// CHECK:STDOUT: %import_ref.2 = import_ref Main//extern_api, inst+23, unloaded
// CHECK:STDOUT: %import_ref.3 = import_ref Main//extern_api, inst+45, unloaded
// CHECK:STDOUT: %import_ref.4 = import_ref Main//extern_api, inst+48, unloaded
// CHECK:STDOUT: %import_ref.5: <namespace> = import_ref Main//extern_api, inst+51, loaded
// CHECK:STDOUT: %NS: <namespace> = namespace %import_ref.5, [template] {
// CHECK:STDOUT: .E = %import_ref.6
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.6 = import_ref Main//extern_api, inst+50, unloaded
// CHECK:STDOUT: %import_ref.6 = import_ref Main//extern_api, inst+52, unloaded
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/operators
toolchain/check/testdata/function/declaration/no_prelude/extern.carbon
Vendored
+4 -3
View File
@@ -175,10 +175,11 @@ class C {
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {} {}
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {
// CHECK:STDOUT: %self.patt: %C = binding_pattern self
// CHECK:STDOUT: %self.param_patt: %C = param_pattern %self.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Self.ref: type = name_ref Self, constants.%C [template = constants.%C]
// CHECK:STDOUT: %self.param: %C = param self, runtime_param0
// CHECK:STDOUT: %self: %C = bind_name self, %self.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %self: %C = bind_name self, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.loc14: <witness> = complete_type_witness %.2 [template = constants.%.3]
// CHECK:STDOUT:
@@ -190,5 +191,5 @@ class C {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F();
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G[%self: %C]();
// CHECK:STDOUT: fn @G[%self.param_patt: %C]();
// CHECK:STDOUT:
toolchain/check/testdata/function/declaration/no_prelude/fail_redecl.carbon
Vendored
+11 -8
View File
@@ -87,28 +87,31 @@ fn E() {}
// CHECK:STDOUT: %A.decl.loc19: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: %B.decl.loc21: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %x.patt: %.1 = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %.1 = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc21_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc21_10.2: type = converted %.loc21_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %x.param.loc21: %.1 = param x, runtime_param0
// CHECK:STDOUT: %x.loc21: %.1 = bind_name x, %x.param.loc21
// CHECK:STDOUT: %param.loc21: %.1 = param runtime_param0
// CHECK:STDOUT: %x.loc21: %.1 = bind_name x, %param.loc21
// CHECK:STDOUT: }
// CHECK:STDOUT: %B.decl.loc29: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %x.patt: %.1 = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %.1 = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc29_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc29_10.2: type = converted %.loc29_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %x.param.loc29: %.1 = param x, runtime_param0
// CHECK:STDOUT: %x.loc29: %.1 = bind_name x, %x.param.loc29
// CHECK:STDOUT: %param.loc29: %.1 = param runtime_param0
// CHECK:STDOUT: %x.loc29: %.1 = bind_name x, %param.loc29
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: %C.type = fn_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.2] {
// CHECK:STDOUT: %x.patt: %.1 = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %.1 = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc39_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc39_10.2: type = converted %.loc39_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %x.param: %.1 = param x, runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %x.param
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %D.decl.loc41: %D.type = fn_decl @D [template = constants.%D] {} {}
// CHECK:STDOUT: %D.decl.loc49: %D.type = fn_decl @D [template = constants.%D] {} {}
@@ -118,11 +121,11 @@ fn E() {}
// CHECK:STDOUT:
// CHECK:STDOUT: fn @A();
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%x.loc21: %.1);
// CHECK:STDOUT: fn @B(%x.param_patt: %.1);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C();
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.1(%x: %.1);
// CHECK:STDOUT: fn @.1(%x.param_patt: %.1);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @D() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/function/declaration/no_prelude/fail_todo_no_params.carbon
Vendored
+3 -3
View File
@@ -55,7 +55,7 @@ fn A => 0;
// CHECK:STDOUT: %A.decl: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @A();
// CHECK:STDOUT: fn @A;
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_todo_brace_body.carbon
// CHECK:STDOUT:
@@ -72,7 +72,7 @@ fn A => 0;
// CHECK:STDOUT: %A.decl: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @A() {
// CHECK:STDOUT: fn @A {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -92,5 +92,5 @@ fn A => 0;
// CHECK:STDOUT: %A.decl: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @A();
// CHECK:STDOUT: fn @A;
// CHECK:STDOUT:
toolchain/check/testdata/function/declaration/param_same_name.carbon
Vendored
+8 -6
View File
@@ -48,27 +48,29 @@ fn G(a: i32);
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_9.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc11_9.2: type = converted %int.make_type_32, %.loc11_9.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc13_9.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc13_9.2: type = converted %int.make_type_32, %.loc13_9.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F(%a: i32);
// CHECK:STDOUT: fn @F(%a.param_patt: i32);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G(%a: i32);
// CHECK:STDOUT: fn @G(%a.param_patt: i32);
// CHECK:STDOUT:
toolchain/check/testdata/function/definition/import.carbon
Vendored
+25 -23
View File
@@ -156,32 +156,34 @@ fn D() {}
// CHECK:STDOUT: %A.decl: %A.type = fn_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: %B.decl: %B.type = fn_decl @B [template = constants.%B] {
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc5_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_9.1: type = value_of_initializer %int.make_type_32.loc5_9 [template = i32]
// CHECK:STDOUT: %.loc5_9.2: type = converted %int.make_type_32.loc5_9, %.loc5_9.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc5_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc5_17.1: type = value_of_initializer %int.make_type_32.loc5_17 [template = i32]
// CHECK:STDOUT: %.loc5_17.2: type = converted %int.make_type_32.loc5_17, %.loc5_17.1 [template = i32]
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: %C.type = fn_decl @C [template = constants.%C] {
// CHECK:STDOUT: %c.patt: %.3 = binding_pattern c
// CHECK:STDOUT: %c.param_patt: %.3 = param_pattern %c.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc6_10: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_14.1: %.2 = tuple_literal (%int.make_type_32.loc6_10)
// CHECK:STDOUT: %.loc6_14.2: type = value_of_initializer %int.make_type_32.loc6_10 [template = i32]
// CHECK:STDOUT: %.loc6_14.3: type = converted %int.make_type_32.loc6_10, %.loc6_14.2 [template = i32]
// CHECK:STDOUT: %.loc6_14.4: type = converted %.loc6_14.1, constants.%.3 [template = constants.%.3]
// CHECK:STDOUT: %c.param: %.3 = param c, runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %c.param
// CHECK:STDOUT: %int.make_type_32.loc6_25: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_25.1: type = value_of_initializer %int.make_type_32.loc6_25 [template = i32]
// CHECK:STDOUT: %.loc6_25.2: type = converted %int.make_type_32.loc6_25, %.loc6_25.1 [template = i32]
// CHECK:STDOUT: %.loc6_28: type = struct_type {.c: i32} [template = constants.%.4]
// CHECK:STDOUT: %return: ref %.4 = var <return slot>
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %c: %.3 = bind_name c, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %D.decl: %D.type = fn_decl @D [template = constants.%D] {} {}
// CHECK:STDOUT: }
@@ -193,13 +195,13 @@ fn D() {}
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b: i32) -> i32 {
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %b.ref: i32 = name_ref b, %b
// CHECK:STDOUT: return %b.ref
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%c: %.3) -> %.4 {
// CHECK:STDOUT: fn @C(%c.param_patt: %.3) -> %.4 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %c.ref: %.3 = name_ref c, %c
// CHECK:STDOUT: %.loc6_47: i32 = int_literal 0 [template = constants.%.5]
@@ -264,9 +266,9 @@ fn D() {}
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//fns, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//fns, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//fns, inst+46, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4 = import_ref Main//fns, inst+58, unloaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//fns, inst+24, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3: %C.type = import_ref Main//fns, inst+48, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.4 = import_ref Main//fns, inst+60, unloaded
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.5
// CHECK:STDOUT: import Core//prelude
@@ -315,9 +317,9 @@ fn D() {}
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b: i32) -> i32;
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @C(%c: %.4) -> %.3;
// CHECK:STDOUT: fn @C(%c.param_patt: %.4) -> %.3;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
// CHECK:STDOUT: !entry:
@@ -330,10 +332,10 @@ fn D() {}
// CHECK:STDOUT: assign file.%b.var, %B.call
// CHECK:STDOUT: %C.ref: %C.type = name_ref C, imports.%import_ref.3 [template = constants.%C]
// CHECK:STDOUT: %.loc8_23: i32 = int_literal 1 [template = constants.%.2]
// CHECK:STDOUT: %.loc8_25: %.4 = tuple_literal (%.loc8_23)
// CHECK:STDOUT: %.loc8_25.1: %.4 = tuple_literal (%.loc8_23)
// CHECK:STDOUT: %tuple: %.4 = tuple_value (%.loc8_23) [template = constants.%tuple]
// CHECK:STDOUT: %.loc8_21: %.4 = converted %.loc8_25, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc8_21)
// CHECK:STDOUT: %.loc8_25.2: %.4 = converted %.loc8_25.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %C.call: init %.3 = call %C.ref(%.loc8_25.2)
// CHECK:STDOUT: assign file.%c.var, %C.call
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -352,9 +354,9 @@ fn D() {}
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: %A.type = import_ref Main//fns, inst+3, loaded [template = constants.%A]
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//fns, inst+23, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3 = import_ref Main//fns, inst+46, unloaded
// CHECK:STDOUT: %import_ref.4 = import_ref Main//fns, inst+58, unloaded
// CHECK:STDOUT: %import_ref.2: %B.type = import_ref Main//fns, inst+24, loaded [template = constants.%B]
// CHECK:STDOUT: %import_ref.3 = import_ref Main//fns, inst+48, unloaded
// CHECK:STDOUT: %import_ref.4 = import_ref Main//fns, inst+60, unloaded
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .Int32 = %import_ref.5
// CHECK:STDOUT: import Core//prelude
@@ -384,12 +386,12 @@ fn D() {}
// CHECK:STDOUT: %int.make_type_32.loc23_9: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc23_9.1: type = value_of_initializer %int.make_type_32.loc23_9 [template = i32]
// CHECK:STDOUT: %.loc23_9.2: type = converted %int.make_type_32.loc23_9, %.loc23_9.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param0
// CHECK:STDOUT: %b.loc23: i32 = bind_name b, %b.param
// CHECK:STDOUT: %int.make_type_32.loc23_17: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc23_17.1: type = value_of_initializer %int.make_type_32.loc23_17 [template = i32]
// CHECK:STDOUT: %.loc23_17.2: type = converted %int.make_type_32.loc23_17, %.loc23_17.1 [template = i32]
// CHECK:STDOUT: %return.var: ref i32 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %b: i32 = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -400,7 +402,7 @@ fn D() {}
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @B(%b.1: i32) -> i32;
// CHECK:STDOUT: fn @B(%b.param_patt: i32) -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_redecl_then_def.carbon
// CHECK:STDOUT:
@@ -450,9 +452,9 @@ fn D() {}
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1 = import_ref Main//fns, inst+3, unloaded
// CHECK:STDOUT: %import_ref.2 = import_ref Main//fns, inst+23, unloaded
// CHECK:STDOUT: %import_ref.3 = import_ref Main//fns, inst+46, unloaded
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//fns, inst+58, loaded [template = constants.%D]
// CHECK:STDOUT: %import_ref.2 = import_ref Main//fns, inst+24, unloaded
// CHECK:STDOUT: %import_ref.3 = import_ref Main//fns, inst+48, unloaded
// CHECK:STDOUT: %import_ref.4: %D.type = import_ref Main//fns, inst+60, loaded [template = constants.%D]
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/operators
toolchain/check/testdata/function/definition/no_prelude/fail_decl_param_mismatch.carbon
Vendored
+16 -12
View File
@@ -109,34 +109,38 @@ fn K() -> {} { return {}; }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {} {}
// CHECK:STDOUT: %.decl.loc19: %.type.1 = fn_decl @.1 [template = constants.%.2] {
// CHECK:STDOUT: %x.patt: %.1 = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %.1 = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc19_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc19_10.2: type = converted %.loc19_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %x.param: %.1 = param x, runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %x.param
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {
// CHECK:STDOUT: %x.patt: %.1 = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %.1 = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc21_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc21_10.2: type = converted %.loc21_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %x.param: %.1 = param x, runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %x.param
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl.loc29: %.type.2 = fn_decl @.2 [template = constants.%.3] {} {}
// CHECK:STDOUT: %H.decl: %H.type = fn_decl @H [template = constants.%H] {
// CHECK:STDOUT: %x.patt: %.1 = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %.1 = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc31_10.1: %.1 = tuple_literal ()
// CHECK:STDOUT: %.loc31_10.2: type = converted %.loc31_10.1, constants.%.1 [template = constants.%.1]
// CHECK:STDOUT: %x.param: %.1 = param x, runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %x.param
// CHECK:STDOUT: %param: %.1 = param runtime_param0
// CHECK:STDOUT: %x: %.1 = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl.loc36: %.type.3 = fn_decl @.3 [template = constants.%.4] {
// CHECK:STDOUT: %x.patt: <error> = binding_pattern x
// CHECK:STDOUT: %x.param_patt: <error> = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %x.param: <error> = param x, runtime_param0
// CHECK:STDOUT: %x: <error> = bind_name x, %x.param
// CHECK:STDOUT: %param: <error> = param runtime_param0
// CHECK:STDOUT: %x: <error> = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %I.decl: %I.type = fn_decl @I [template = constants.%I] {} {}
// CHECK:STDOUT: %.decl.loc46: %.type.4 = fn_decl @.4 [template = constants.%.5] {} {
@@ -164,21 +168,21 @@ fn K() -> {} { return {}; }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F();
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.1(%x: %.1) {
// CHECK:STDOUT: fn @.1(%x.param_patt: %.1) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G(%x: %.1);
// CHECK:STDOUT: fn @G(%x.param_patt: %.1);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.2() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @H(%x: %.1);
// CHECK:STDOUT: fn @H(%x.param_patt: %.1);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.3(%x: <error>) {
// CHECK:STDOUT: fn @.3(%x.param_patt: <error>) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/definition/no_prelude/syntactic_merge.carbon
Vendored
+105 -75
View File
@@ -82,10 +82,10 @@ alias D = C;
fn Foo(a: C);
// CHECK:STDERR: fail_name_mismatch.carbon:[[@LINE+7]]:8: error: redeclaration differs at parameter 1
// CHECK:STDERR: fn Foo(b: D) {}
// CHECK:STDERR: ^
// CHECK:STDERR: ^~~~
// CHECK:STDERR: fail_name_mismatch.carbon:[[@LINE-4]]:8: note: previous declaration's corresponding parameter here
// CHECK:STDERR: fn Foo(a: C);
// CHECK:STDERR: ^
// CHECK:STDERR: ^~~~
// CHECK:STDERR:
fn Foo(b: D) {}
@@ -194,31 +194,35 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %D: type = bind_alias D, %C.decl [template = constants.%C]
// CHECK:STDOUT: %Foo.decl.loc7: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc7: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param.loc7: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc7: %C = bind_name a, %a.param.loc7
// CHECK:STDOUT: %param.loc7: %C = param runtime_param0
// CHECK:STDOUT: %a.loc7: %C = bind_name a, %param.loc7
// CHECK:STDOUT: }
// CHECK:STDOUT: %Foo.decl.loc8: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc8: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param.loc8: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc8: %C = bind_name a, %a.param.loc8
// CHECK:STDOUT: %param.loc8: %C = param runtime_param0
// CHECK:STDOUT: %a.loc8: %C = bind_name a, %param.loc8
// CHECK:STDOUT: }
// CHECK:STDOUT: %Bar.decl.loc10: %Bar.type = fn_decl @Bar [template = constants.%Bar] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref.loc10: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %a.param.loc10: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc10: %C = bind_name a, %a.param.loc10
// CHECK:STDOUT: %param.loc10: %C = param runtime_param0
// CHECK:STDOUT: %a.loc10: %C = bind_name a, %param.loc10
// CHECK:STDOUT: }
// CHECK:STDOUT: %Bar.decl.loc11: %Bar.type = fn_decl @Bar [template = constants.%Bar] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref.loc11: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %a.param.loc11: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc11: %C = bind_name a, %a.param.loc11
// CHECK:STDOUT: %param.loc11: %C = param runtime_param0
// CHECK:STDOUT: %a.loc11: %C = bind_name a, %param.loc11
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -229,12 +233,12 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a.loc8: %C) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bar(%a.loc11: %C) {
// CHECK:STDOUT: fn @Bar(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -259,17 +263,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %Foo.decl.loc6: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc6: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param.loc6: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc6: %C = bind_name a, %a.param.loc6
// CHECK:STDOUT: %param.loc6: %C = param runtime_param0
// CHECK:STDOUT: %a.loc6: %C = bind_name a, %param.loc6
// CHECK:STDOUT: }
// CHECK:STDOUT: %Foo.decl.loc7: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc7: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param.loc7: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc7: %C = bind_name a, %a.param.loc7
// CHECK:STDOUT: %param.loc7: %C = param runtime_param0
// CHECK:STDOUT: %a.loc7: %C = bind_name a, %param.loc7
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -280,7 +286,7 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo[](%a.loc7: %C) {
// CHECK:STDOUT: fn @Foo[](%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -307,17 +313,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -328,9 +336,9 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C);
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.1(%a: %C) {
// CHECK:STDOUT: fn @.1(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -355,17 +363,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %Foo.decl.loc6: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc6: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param.loc6: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc6: %C = bind_name a, %a.param.loc6
// CHECK:STDOUT: %param.loc6: %C = param runtime_param0
// CHECK:STDOUT: %a.loc6: %C = bind_name a, %param.loc6
// CHECK:STDOUT: }
// CHECK:STDOUT: %Foo.decl.loc7: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc7: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param.loc7: %C = param a, runtime_param0
// CHECK:STDOUT: %a.loc7: %C = bind_name a, %a.param.loc7
// CHECK:STDOUT: %param.loc7: %C = param runtime_param0
// CHECK:STDOUT: %a.loc7: %C = bind_name a, %param.loc7
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -376,7 +386,7 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a.loc7: %C) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -406,17 +416,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %D: type = bind_alias D, %C.decl [template = constants.%C]
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Bar.decl: %Bar.type = fn_decl @Bar [template = constants.%Bar] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -427,9 +439,9 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C);
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bar(%a: %C);
// CHECK:STDOUT: fn @Bar(%a.param_patt: %C);
// CHECK:STDOUT:
// CHECK:STDOUT: --- two_file.impl.carbon
// CHECK:STDOUT:
@@ -448,8 +460,8 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: type = import_ref Main//two_file, inst+1, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.2: type = import_ref Main//two_file, inst+7, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.3: %Foo.type = import_ref Main//two_file, inst+12, loaded [template = constants.%Foo]
// CHECK:STDOUT: %import_ref.4: %Bar.type = import_ref Main//two_file, inst+20, loaded [template = constants.%Bar]
// CHECK:STDOUT: %import_ref.3: %Foo.type = import_ref Main//two_file, inst+13, loaded [template = constants.%Foo]
// CHECK:STDOUT: %import_ref.4: %Bar.type = import_ref Main//two_file, inst+22, loaded [template = constants.%Bar]
// CHECK:STDOUT: %import_ref.5 = import_ref Main//two_file, inst+2, unloaded
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -464,17 +476,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %default.import.loc2_6.2 = import <invalid>
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, imports.%import_ref.1 [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %Bar.decl: %Bar.type = fn_decl @Bar [template = constants.%Bar] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref: type = name_ref D, imports.%import_ref.2 [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -483,12 +497,12 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = imports.%import_ref.5
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bar(%a: %C) {
// CHECK:STDOUT: fn @Bar(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -518,17 +532,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %D: type = bind_alias D, %C.decl [template = constants.%C]
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %b.patt: %C = binding_pattern b
// CHECK:STDOUT: %b.param_patt: %C = param_pattern %b.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %b.param: %C = param b, runtime_param0
// CHECK:STDOUT: %b: %C = bind_name b, %b.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %b: %C = bind_name b, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -539,9 +555,9 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C);
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.1(%b: %C) {
// CHECK:STDOUT: fn @.1(%b.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -571,17 +587,19 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %D: type = bind_alias D, %C.decl [template = constants.%C]
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -592,9 +610,9 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C);
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.1(%a: %C) {
// CHECK:STDOUT: fn @.1(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -606,9 +624,11 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %.1: type = struct_type {} [template]
// CHECK:STDOUT: %.2: <witness> = complete_type_witness %.1 [template]
// CHECK:STDOUT: %a: %C = bind_symbolic_name a, 0 [symbolic]
// CHECK:STDOUT: %a.patt.1: %C = symbolic_binding_pattern a, 0 [symbolic]
// CHECK:STDOUT: %Foo.type: type = fn_type @Foo [template]
// CHECK:STDOUT: %.3: type = tuple_type () [template]
// CHECK:STDOUT: %Foo: %Foo.type = struct_value () [template]
// CHECK:STDOUT: %a.patt.2: %C = symbolic_binding_pattern a, 0 [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.4: %.type = struct_value () [template]
// CHECK:STDOUT: %.5: type = ptr_type %.1 [template]
@@ -624,18 +644,20 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %C.ref: type = name_ref C, %C.decl [template = constants.%C]
// CHECK:STDOUT: %D: type = bind_alias D, %C.decl [template = constants.%C]
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = symbolic_binding_pattern a, 0
// CHECK:STDOUT: %a.patt.loc7_8.1: %C = symbolic_binding_pattern a, 0 [symbolic = %a.patt.loc7_8.2 (constants.%a.patt.1)]
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt.loc7_8.1, runtime_param<invalid> [symbolic = %a.patt.loc7_8.2 (constants.%a.patt.1)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param<invalid>
// CHECK:STDOUT: %a.loc7_8.1: %C = bind_symbolic_name a, 0, %a.param [symbolic = %a.loc7_8.2 (constants.%a)]
// CHECK:STDOUT: %param: %C = param runtime_param<invalid>
// CHECK:STDOUT: %a.loc7_8.1: %C = bind_symbolic_name a, 0, %param [symbolic = %a.loc7_8.2 (constants.%a)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %a.patt: %C = symbolic_binding_pattern a, 0
// CHECK:STDOUT: %a.patt.loc15_8.1: %C = symbolic_binding_pattern a, 0 [symbolic = %a.patt.loc15_8.2 (constants.%a.patt.2)]
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt.loc15_8.1, runtime_param<invalid> [symbolic = %a.patt.loc15_8.2 (constants.%a.patt.2)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param<invalid>
// CHECK:STDOUT: %a.loc15_8.1: %C = bind_symbolic_name a, 0, %a.param [symbolic = %a.loc15_8.2 (constants.%a)]
// CHECK:STDOUT: %param: %C = param runtime_param<invalid>
// CHECK:STDOUT: %a.loc15_8.1: %C = bind_symbolic_name a, 0, %param [symbolic = %a.loc15_8.2 (constants.%a)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -648,16 +670,18 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Foo(%a.loc7_8.1: %C) {
// CHECK:STDOUT: %a.loc7_8.2: %C = bind_symbolic_name a, 0 [symbolic = %a.loc7_8.2 (constants.%a)]
// CHECK:STDOUT: %a.patt.loc7_8.2: %C = symbolic_binding_pattern a, 0 [symbolic = %a.patt.loc7_8.2 (constants.%a.patt.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%a.loc7_8.1: %C]();
// CHECK:STDOUT: fn[%a.param_patt: %C]();
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%a.loc15_8.1: %C) {
// CHECK:STDOUT: %a.loc15_8.2: %C = bind_symbolic_name a, 0 [symbolic = %a.loc15_8.2 (constants.%a)]
// CHECK:STDOUT: %a.patt.loc15_8.2: %C = symbolic_binding_pattern a, 0 [symbolic = %a.patt.loc15_8.2 (constants.%a.patt.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%a.loc15_8.1: %C]() {
// CHECK:STDOUT: fn[%a.param_patt: %C]() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -665,10 +689,12 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Foo(constants.%a) {
// CHECK:STDOUT: %a.loc7_8.2 => constants.%a
// CHECK:STDOUT: %a.patt.loc7_8.2 => constants.%a
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%a) {
// CHECK:STDOUT: %a.loc15_8.2 => constants.%a
// CHECK:STDOUT: %a.patt.loc15_8.2 => constants.%a
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: --- todo_fail_alias_in_return.carbon
@@ -737,10 +763,11 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -751,7 +778,7 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C);
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C);
// CHECK:STDOUT:
// CHECK:STDOUT: --- todo_fail_alias_two_file.impl.carbon
// CHECK:STDOUT:
@@ -767,7 +794,7 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref.1: type = import_ref Main//alias_two_file, inst+1, loaded [template = constants.%C]
// CHECK:STDOUT: %import_ref.2: %Foo.type = import_ref Main//alias_two_file, inst+10, loaded [template = constants.%Foo]
// CHECK:STDOUT: %import_ref.2: %Foo.type = import_ref Main//alias_two_file, inst+11, loaded [template = constants.%Foo]
// CHECK:STDOUT: %import_ref.3 = import_ref Main//alias_two_file, inst+2, unloaded
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -783,10 +810,11 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %D: type = bind_alias D, imports.%import_ref.1 [template = constants.%C]
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %C = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %C = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %D.ref: type = name_ref D, file.%D [template = constants.%C]
// CHECK:STDOUT: %a.param: %C = param a, runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %a.param
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %a: %C = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -795,7 +823,7 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = imports.%import_ref.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %C) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: %C) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -823,20 +851,22 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: %.3 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %.3 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %.loc6: type = const_type %C [template = constants.%.3]
// CHECK:STDOUT: %a.param: %.3 = param a, runtime_param0
// CHECK:STDOUT: %a: %.3 = bind_name a, %a.param
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %a: %.3 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.5] {
// CHECK:STDOUT: %a.patt: %.3 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %.3 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %.loc17_18: type = const_type %C [template = constants.%.3]
// CHECK:STDOUT: %.loc17_11: type = const_type %.3 [template = constants.%.3]
// CHECK:STDOUT: %a.param: %.3 = param a, runtime_param0
// CHECK:STDOUT: %a: %.3 = bind_name a, %a.param
// CHECK:STDOUT: %param: %.3 = param runtime_param0
// CHECK:STDOUT: %a: %.3 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -847,9 +877,9 @@ fn Foo(a: const (const C)) {}
// CHECK:STDOUT: .Self = constants.%C
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: %.3);
// CHECK:STDOUT: fn @Foo(%a.param_patt: %.3);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @.1(%a: %.3) {
// CHECK:STDOUT: fn @.1(%a.param_patt: %.3) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/definition/params_one.carbon
Vendored
+4 -3
View File
@@ -43,18 +43,19 @@ fn Foo(a: i32) {}
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/definition/params_one_comma.carbon
Vendored
+4 -3
View File
@@ -43,18 +43,19 @@ fn Foo(a: i32,) {}
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/definition/params_two.carbon
Vendored
+7 -5
View File
@@ -43,24 +43,26 @@ fn Foo(a: i32, b: i32) {}
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32, %b: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32, %b.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/definition/params_two_comma.carbon
Vendored
+7 -5
View File
@@ -43,24 +43,26 @@ fn Foo(a: i32, b: i32,) {}
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {
// CHECK:STDOUT: %a.patt: i32 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: i32 = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %b.patt: i32 = binding_pattern b
// CHECK:STDOUT: %b.param_patt: i32 = param_pattern %b.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc11_11: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_11.1: type = value_of_initializer %int.make_type_32.loc11_11 [template = i32]
// CHECK:STDOUT: %.loc11_11.2: type = converted %int.make_type_32.loc11_11, %.loc11_11.1 [template = i32]
// CHECK:STDOUT: %a.param: i32 = param a, runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %a.param
// CHECK:STDOUT: %int.make_type_32.loc11_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc11_19.1: type = value_of_initializer %int.make_type_32.loc11_19 [template = i32]
// CHECK:STDOUT: %.loc11_19.2: type = converted %int.make_type_32.loc11_19, %.loc11_19.1 [template = i32]
// CHECK:STDOUT: %b.param: i32 = param b, runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %b.param
// CHECK:STDOUT: %param.loc11_8: i32 = param runtime_param0
// CHECK:STDOUT: %a: i32 = bind_name a, %param.loc11_8
// CHECK:STDOUT: %param.loc11_16: i32 = param runtime_param1
// CHECK:STDOUT: %b: i32 = bind_name b, %param.loc11_16
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo(%a: i32, %b: i32) {
// CHECK:STDOUT: fn @Foo(%a.param_patt: i32, %b.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/function/generic/deduce.carbon
Vendored
+110 -58
View File
@@ -118,6 +118,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ExplicitGenericParam.type: type = fn_type @ExplicitGenericParam [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
@@ -129,6 +130,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: %CallExplicitGenericParam.type: type = fn_type @CallExplicitGenericParam [template]
// CHECK:STDOUT: %CallExplicitGenericParam: %CallExplicitGenericParam.type = struct_value () [template]
// CHECK:STDOUT: %.5: <specific function> = specific_function %ExplicitGenericParam, @ExplicitGenericParam(i32) [template]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.6: type = struct_type {.a: %T} [symbolic]
// CHECK:STDOUT: %.7: type = ptr_type %.6 [symbolic]
// CHECK:STDOUT: %CallExplicitGenericParamWithGenericArg.type: type = fn_type @CallExplicitGenericParamWithGenericArg [template]
@@ -160,13 +162,14 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %ExplicitGenericParam.decl: %ExplicitGenericParam.type = fn_decl @ExplicitGenericParam [template = constants.%ExplicitGenericParam] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_25.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_25.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_25.1, runtime_param<invalid> [symbolic = %T.patt.loc4_25.2 (constants.%T.patt.1)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_25.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_38: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %.loc4_39.1: type = ptr_type %T [symbolic = %.loc4_39.2 (constants.%.1)]
// CHECK:STDOUT: %return: ref @ExplicitGenericParam.%.loc4_39.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_25.1: type = bind_symbolic_name T, 0, %param [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallExplicitGenericParam.decl: %CallExplicitGenericParam.type = fn_decl @CallExplicitGenericParam [template = constants.%CallExplicitGenericParam] {} {
// CHECK:STDOUT: %int.make_type_32.loc6: init type = call constants.%Int32() [template = i32]
@@ -176,25 +179,27 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: %return: ref %.4 = var <return slot>
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallExplicitGenericParamWithGenericArg.decl: %CallExplicitGenericParamWithGenericArg.type = fn_decl @CallExplicitGenericParamWithGenericArg [template = constants.%CallExplicitGenericParamWithGenericArg] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc10_43.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc10_43.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc10_43.1, runtime_param<invalid> [symbolic = %T.patt.loc10_43.2 (constants.%T.patt.2)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc10_43.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc10_43.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc10: type = name_ref T, %T.loc10_43.1 [symbolic = %T.loc10_43.2 (constants.%T)]
// CHECK:STDOUT: %.loc10_62.1: type = struct_type {.a: %T} [symbolic = %.loc10_62.2 (constants.%.6)]
// CHECK:STDOUT: %.loc10_63.1: type = ptr_type %.6 [symbolic = %.loc10_63.2 (constants.%.7)]
// CHECK:STDOUT: %return: ref @CallExplicitGenericParamWithGenericArg.%.loc10_63.2 (%.7) = var <return slot>
// CHECK:STDOUT: %param: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc10_43.1: type = bind_symbolic_name T, 0, %param [symbolic = %T.loc10_43.2 (constants.%T)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ExplicitGenericParam(%T.loc4_25.1: type) {
// CHECK:STDOUT: %T.loc4_25.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_25.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_25.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %.loc4_39.2: type = ptr_type @ExplicitGenericParam.%T.loc4_25.2 (%T) [symbolic = %.loc4_39.2 (constants.%.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc4_50.2: <specific function> = specific_function constants.%ExplicitGenericParam, @ExplicitGenericParam(%T.loc4_25.2) [symbolic = %.loc4_50.2 (constants.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc4_25.1: type) -> @ExplicitGenericParam.%.loc4_39.2 (%.1) {
// CHECK:STDOUT: fn(%T.param_patt: type) -> @ExplicitGenericParam.%.loc4_39.2 (%.1) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ExplicitGenericParam.ref: %ExplicitGenericParam.type = name_ref ExplicitGenericParam, file.%ExplicitGenericParam.decl [template = constants.%ExplicitGenericParam]
// CHECK:STDOUT: %T.ref.loc4_71: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
@@ -223,13 +228,14 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @CallExplicitGenericParamWithGenericArg(%T.loc10_43.1: type) {
// CHECK:STDOUT: %T.loc10_43.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc10_43.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc10_43.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc10_43.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %.loc10_62.2: type = struct_type {.a: @CallExplicitGenericParamWithGenericArg.%T.loc10_43.2 (%T)} [symbolic = %.loc10_62.2 (constants.%.6)]
// CHECK:STDOUT: %.loc10_63.2: type = ptr_type @CallExplicitGenericParamWithGenericArg.%.loc10_62.2 (%.6) [symbolic = %.loc10_63.2 (constants.%.7)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc11_10.2: <specific function> = specific_function constants.%ExplicitGenericParam, @ExplicitGenericParam(%.loc10_62.2) [symbolic = %.loc11_10.2 (constants.%.8)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc10_43.1: type) -> @CallExplicitGenericParamWithGenericArg.%.loc10_63.2 (%.7) {
// CHECK:STDOUT: fn(%T.param_patt: type) -> @CallExplicitGenericParamWithGenericArg.%.loc10_63.2 (%.7) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ExplicitGenericParam.ref: %ExplicitGenericParam.type = name_ref ExplicitGenericParam, file.%ExplicitGenericParam.decl [template = constants.%ExplicitGenericParam]
// CHECK:STDOUT: %T.ref.loc11: type = name_ref T, %T.loc10_43.1 [symbolic = %T.loc10_43.2 (constants.%T)]
@@ -244,6 +250,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ExplicitGenericParam(constants.%T) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%T
// CHECK:STDOUT: %.loc4_39.2 => constants.%.1
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
@@ -252,11 +259,13 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ExplicitGenericParam(@ExplicitGenericParam.%T.loc4_25.2) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%T
// CHECK:STDOUT: %.loc4_39.2 => constants.%.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ExplicitGenericParam(i32) {
// CHECK:STDOUT: %T.loc4_25.2 => i32
// CHECK:STDOUT: %T.patt.loc4_25.2 => i32
// CHECK:STDOUT: %.loc4_39.2 => constants.%.4
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
@@ -265,12 +274,14 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @CallExplicitGenericParamWithGenericArg(constants.%T) {
// CHECK:STDOUT: %T.loc10_43.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc10_43.2 => constants.%T
// CHECK:STDOUT: %.loc10_62.2 => constants.%.6
// CHECK:STDOUT: %.loc10_63.2 => constants.%.7
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ExplicitGenericParam(constants.%.6) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%.6
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%.6
// CHECK:STDOUT: %.loc4_39.2 => constants.%.7
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
@@ -279,6 +290,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ExplicitGenericParam(@CallExplicitGenericParamWithGenericArg.%.loc10_62.2) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%.6
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%.6
// CHECK:STDOUT: %.loc4_39.2 => constants.%.7
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -289,6 +301,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: %.1: type = struct_type {} [template]
// CHECK:STDOUT: %.2: <witness> = complete_type_witness %.1 [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: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %ExplicitAndAlsoDeduced.type: type = fn_type @ExplicitAndAlsoDeduced [template]
// CHECK:STDOUT: %.4: type = tuple_type () [template]
@@ -325,31 +338,34 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %A.decl: type = class_decl @A [template = constants.%A] {} {}
// CHECK:STDOUT: %ExplicitAndAlsoDeduced.decl: %ExplicitAndAlsoDeduced.type = fn_decl @ExplicitAndAlsoDeduced [template = constants.%ExplicitAndAlsoDeduced] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc6_27.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_27.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc6_27.1, runtime_param<invalid> [symbolic = %T.patt.loc6_27.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc6_27.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_27.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc6_40: type = name_ref T, %T.loc6_27.1 [symbolic = %T.loc6_27.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc6_46: type = name_ref T, %T.loc6_27.1 [symbolic = %T.loc6_27.2 (constants.%T)]
// CHECK:STDOUT: %.loc6_47.1: type = ptr_type %T [symbolic = %.loc6_47.2 (constants.%.3)]
// CHECK:STDOUT: %return: ref @ExplicitAndAlsoDeduced.%.loc6_47.2 (%.3) = var <return slot>
// CHECK:STDOUT: %param.loc6_27: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc6_27.1: type = bind_symbolic_name T, 0, %param.loc6_27 [symbolic = %T.loc6_27.2 (constants.%T)]
// CHECK:STDOUT: %param.loc6_37: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) = bind_name x, %param.loc6_37
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallExplicitAndAlsoDeduced.decl: %CallExplicitAndAlsoDeduced.type = fn_decl @CallExplicitAndAlsoDeduced [template = constants.%CallExplicitAndAlsoDeduced] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc9_34: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc9_34.1: type = value_of_initializer %int.make_type_32.loc9_34 [template = i32]
// CHECK:STDOUT: %.loc9_34.2: type = converted %int.make_type_32.loc9_34, %.loc9_34.1 [template = i32]
// CHECK:STDOUT: %n.param: i32 = param n, runtime_param0
// CHECK:STDOUT: %n: i32 = bind_name n, %n.param
// CHECK:STDOUT: %int.make_type_32.loc9_42: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc9_45.1: type = value_of_initializer %int.make_type_32.loc9_42 [template = i32]
// CHECK:STDOUT: %.loc9_45.2: type = converted %int.make_type_32.loc9_42, %.loc9_45.1 [template = i32]
// CHECK:STDOUT: %.loc9_45.3: type = ptr_type i32 [template = constants.%.5]
// CHECK:STDOUT: %return: ref %.5 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %n: i32 = bind_name n, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -362,14 +378,15 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ExplicitAndAlsoDeduced(%T.loc6_27.1: type) {
// CHECK:STDOUT: %T.loc6_27.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc6_27.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc6_27.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_27.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc6_47.2: type = ptr_type @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) [symbolic = %.loc6_47.2 (constants.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc6_27.1: type, %x: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T)) -> @ExplicitAndAlsoDeduced.%.loc6_47.2 (%.3);
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T)) -> @ExplicitAndAlsoDeduced.%.loc6_47.2 (%.3);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallExplicitAndAlsoDeduced(%n: i32) -> %.5 {
// CHECK:STDOUT: fn @CallExplicitAndAlsoDeduced(%n.param_patt: i32) -> %.5 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ExplicitAndAlsoDeduced.ref: %ExplicitAndAlsoDeduced.type = name_ref ExplicitAndAlsoDeduced, file.%ExplicitAndAlsoDeduced.decl [template = constants.%ExplicitAndAlsoDeduced]
// CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [template = constants.%A]
@@ -379,6 +396,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ExplicitAndAlsoDeduced(constants.%T) {
// CHECK:STDOUT: %T.loc6_27.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc6_27.2 => constants.%T
// CHECK:STDOUT: %.loc6_47.2 => constants.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -386,6 +404,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// 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: %ImplicitGenericParam.type: type = fn_type @ImplicitGenericParam [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
@@ -422,42 +441,46 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %ImplicitGenericParam.decl: %ImplicitGenericParam.type = fn_decl @ImplicitGenericParam [template = constants.%ImplicitGenericParam] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_25.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_25.1, runtime_param<invalid> [symbolic = %T.patt.loc4_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @ImplicitGenericParam.%T.loc4_25.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @ImplicitGenericParam.%T.loc4_25.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_25.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_38: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @ImplicitGenericParam.%T.loc4_25.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @ImplicitGenericParam.%T.loc4_25.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc4_44: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %.loc4_45.1: type = ptr_type %T [symbolic = %.loc4_45.2 (constants.%.1)]
// CHECK:STDOUT: %return: ref @ImplicitGenericParam.%.loc4_45.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param.loc4_25: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_25.1: type = bind_symbolic_name T, 0, %param.loc4_25 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_35: @ImplicitGenericParam.%T.loc4_25.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @ImplicitGenericParam.%T.loc4_25.2 (%T) = bind_name x, %param.loc4_35
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallImplicitGenericParam.decl: %CallImplicitGenericParam.type = fn_decl @CallImplicitGenericParam [template = constants.%CallImplicitGenericParam] {
// CHECK:STDOUT: %n.patt: i32 = binding_pattern n
// CHECK:STDOUT: %n.param_patt: i32 = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc6_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_32.1: type = value_of_initializer %int.make_type_32.loc6_32 [template = i32]
// CHECK:STDOUT: %.loc6_32.2: type = converted %int.make_type_32.loc6_32, %.loc6_32.1 [template = i32]
// CHECK:STDOUT: %n.param: i32 = param n, runtime_param0
// CHECK:STDOUT: %n: i32 = bind_name n, %n.param
// CHECK:STDOUT: %int.make_type_32.loc6_40: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc6_43.1: type = value_of_initializer %int.make_type_32.loc6_40 [template = i32]
// CHECK:STDOUT: %.loc6_43.2: type = converted %int.make_type_32.loc6_40, %.loc6_43.1 [template = i32]
// CHECK:STDOUT: %.loc6_43.3: type = ptr_type i32 [template = constants.%.4]
// CHECK:STDOUT: %return: ref %.4 = var <return slot>
// CHECK:STDOUT: %param: i32 = param runtime_param0
// CHECK:STDOUT: %n: i32 = bind_name n, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ImplicitGenericParam(%T.loc4_25.1: type) {
// CHECK:STDOUT: %T.loc4_25.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_25.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc4_45.2: type = ptr_type @ImplicitGenericParam.%T.loc4_25.2 (%T) [symbolic = %.loc4_45.2 (constants.%.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc4_56.2: <specific function> = specific_function constants.%ImplicitGenericParam, @ImplicitGenericParam(%T.loc4_25.2) [symbolic = %.loc4_56.2 (constants.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_25.1: type](%x: @ImplicitGenericParam.%T.loc4_25.2 (%T)) -> @ImplicitGenericParam.%.loc4_45.2 (%.1) {
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @ImplicitGenericParam.%T.loc4_25.2 (%T)) -> @ImplicitGenericParam.%.loc4_45.2 (%.1) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ImplicitGenericParam.ref: %ImplicitGenericParam.type = name_ref ImplicitGenericParam, file.%ImplicitGenericParam.decl [template = constants.%ImplicitGenericParam]
// CHECK:STDOUT: %x.ref: @ImplicitGenericParam.%T.loc4_25.2 (%T) = name_ref x, %x
@@ -471,7 +494,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallImplicitGenericParam(%n: i32) -> %.4 {
// CHECK:STDOUT: fn @CallImplicitGenericParam(%n.param_patt: i32) -> %.4 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ImplicitGenericParam.ref: %ImplicitGenericParam.type = name_ref ImplicitGenericParam, file.%ImplicitGenericParam.decl [template = constants.%ImplicitGenericParam]
// CHECK:STDOUT: %n.ref: i32 = name_ref n, %n
@@ -484,6 +507,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitGenericParam(constants.%T) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%T
// CHECK:STDOUT: %.loc4_45.2 => constants.%.1
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
@@ -492,11 +516,13 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitGenericParam(@ImplicitGenericParam.%T.loc4_25.2) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%T
// CHECK:STDOUT: %.loc4_45.2 => constants.%.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitGenericParam(i32) {
// CHECK:STDOUT: %T.loc4_25.2 => i32
// CHECK:STDOUT: %T.patt.loc4_25.2 => i32
// CHECK:STDOUT: %.loc4_45.2 => constants.%.4
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
@@ -507,6 +533,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// 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: %Int32.type: type = fn_type @Int32 [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
@@ -548,19 +575,21 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %TupleParam.decl: %TupleParam.type = fn_decl @TupleParam [template = constants.%TupleParam] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_15.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_15.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_15.1, runtime_param<invalid> [symbolic = %T.patt.loc4_15.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @TupleParam.%.loc4_35.5 (%.3) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @TupleParam.%.loc4_35.5 (%.3) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_15.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_15.2 (constants.%T)]
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc4_15.1 [symbolic = %T.loc4_15.2 (constants.%T)]
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc4_35.1: %.2 = tuple_literal (%T.ref, %int.make_type_32)
// CHECK:STDOUT: %.loc4_35.2: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc4_35.3: type = converted %int.make_type_32, %.loc4_35.2 [template = i32]
// CHECK:STDOUT: %.loc4_35.4: type = converted %.loc4_35.1, constants.%.3 [symbolic = %.loc4_35.5 (constants.%.3)]
// CHECK:STDOUT: %x.param: @TupleParam.%.loc4_35.5 (%.3) = param x, runtime_param0
// CHECK:STDOUT: %x: @TupleParam.%.loc4_35.5 (%.3) = bind_name x, %x.param
// CHECK:STDOUT: %param.loc4_15: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_15.1: type = bind_symbolic_name T, 0, %param.loc4_15 [symbolic = %T.loc4_15.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_25: @TupleParam.%.loc4_35.5 (%.3) = param runtime_param0
// CHECK:STDOUT: %x: @TupleParam.%.loc4_35.5 (%.3) = bind_name x, %param.loc4_25
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallTupleParam.decl: %CallTupleParam.type = fn_decl @CallTupleParam [template = constants.%CallTupleParam] {} {}
// CHECK:STDOUT: }
@@ -569,11 +598,12 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @TupleParam(%T.loc4_15.1: type) {
// CHECK:STDOUT: %T.loc4_15.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_15.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_15.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_15.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc4_35.5: type = tuple_type (@TupleParam.%T.loc4_15.2 (%T), i32) [symbolic = %.loc4_35.5 (constants.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_15.1: type](%x: @TupleParam.%.loc4_35.5 (%.3)) {
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @TupleParam.%.loc4_35.5 (%.3)) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -584,21 +614,23 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: %TupleParam.ref: %TupleParam.type = name_ref TupleParam, file.%TupleParam.decl [template = constants.%TupleParam]
// CHECK:STDOUT: %.loc7_15: i32 = int_literal 1 [template = constants.%.5]
// CHECK:STDOUT: %.loc7_18: i32 = int_literal 2 [template = constants.%.6]
// CHECK:STDOUT: %.loc7_19: %.7 = tuple_literal (%.loc7_15, %.loc7_18)
// CHECK:STDOUT: %.loc7_19.1: %.7 = tuple_literal (%.loc7_15, %.loc7_18)
// CHECK:STDOUT: %.loc7_3: <specific function> = specific_function %TupleParam.ref, @TupleParam(i32) [template = constants.%.8]
// CHECK:STDOUT: %tuple: %.7 = tuple_value (%.loc7_15, %.loc7_18) [template = constants.%tuple]
// CHECK:STDOUT: %.loc7_13: %.7 = converted %.loc7_19, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %TupleParam.call: init %.1 = call %.loc7_3(%.loc7_13)
// CHECK:STDOUT: %.loc7_19.2: %.7 = converted %.loc7_19.1, %tuple [template = constants.%tuple]
// CHECK:STDOUT: %TupleParam.call: init %.1 = call %.loc7_3(%.loc7_19.2)
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @TupleParam(constants.%T) {
// CHECK:STDOUT: %T.loc4_15.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_15.2 => constants.%T
// CHECK:STDOUT: %.loc4_35.5 => constants.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @TupleParam(i32) {
// CHECK:STDOUT: %T.loc4_15.2 => i32
// CHECK:STDOUT: %T.patt.loc4_15.2 => i32
// CHECK:STDOUT: %.loc4_35.5 => constants.%.7
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
@@ -608,6 +640,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// 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: %Int32.type: type = fn_type @Int32 [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
@@ -645,18 +678,20 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %StructParam.decl: %StructParam.type = fn_decl @StructParam [template = constants.%StructParam] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_16.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_16.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_16.1, runtime_param<invalid> [symbolic = %T.patt.loc4_16.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @StructParam.%.loc4_44.2 (%.2) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @StructParam.%.loc4_44.2 (%.2) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_16.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_16.2 (constants.%T)]
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc4_16.1 [symbolic = %T.loc4_16.2 (constants.%T)]
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc4_41.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc4_41.2: type = converted %int.make_type_32, %.loc4_41.1 [template = i32]
// CHECK:STDOUT: %.loc4_44.1: type = struct_type {.a: %T, .b: i32} [symbolic = %.loc4_44.2 (constants.%.2)]
// CHECK:STDOUT: %x.param: @StructParam.%.loc4_44.2 (%.2) = param x, runtime_param0
// CHECK:STDOUT: %x: @StructParam.%.loc4_44.2 (%.2) = bind_name x, %x.param
// CHECK:STDOUT: %param.loc4_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_16.1: type = bind_symbolic_name T, 0, %param.loc4_16 [symbolic = %T.loc4_16.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_26: @StructParam.%.loc4_44.2 (%.2) = param runtime_param0
// CHECK:STDOUT: %x: @StructParam.%.loc4_44.2 (%.2) = bind_name x, %param.loc4_26
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallStructParam.decl: %CallStructParam.type = fn_decl @CallStructParam [template = constants.%CallStructParam] {} {}
// CHECK:STDOUT: }
@@ -665,11 +700,12 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @StructParam(%T.loc4_16.1: type) {
// CHECK:STDOUT: %T.loc4_16.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_16.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_16.2 (constants.%T.patt)]
// CHECK:STDOUT: %.loc4_44.2: type = struct_type {.a: @StructParam.%T.loc4_16.2 (%T), .b: i32} [symbolic = %.loc4_44.2 (constants.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_16.1: type](%x: @StructParam.%.loc4_44.2 (%.2)) {
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @StructParam.%.loc4_44.2 (%.2)) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -686,6 +722,7 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @StructParam(constants.%T) {
// CHECK:STDOUT: %T.loc4_16.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_16.2 => constants.%T
// CHECK:STDOUT: %.loc4_44.2 => constants.%.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -693,7 +730,9 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// 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: %U: type = bind_symbolic_name U, 1 [symbolic]
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %ImplicitNotDeducible.type: type = fn_type @ImplicitNotDeducible [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %ImplicitNotDeducible: %ImplicitNotDeducible.type = struct_value () [template]
@@ -723,28 +762,33 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %ImplicitNotDeducible.decl: %ImplicitNotDeducible.type = fn_decl @ImplicitNotDeducible [template = constants.%ImplicitNotDeducible] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1
// CHECK:STDOUT: %T.patt.loc6_25.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc6_25.1, runtime_param<invalid> [symbolic = %T.patt.loc6_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.patt.loc6_35.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc6_35.2 (constants.%U.patt)]
// CHECK:STDOUT: %U.param_patt: type = param_pattern %U.patt.loc6_35.1, runtime_param<invalid> [symbolic = %U.patt.loc6_35.2 (constants.%U.patt)]
// CHECK:STDOUT: %x.patt: @ImplicitNotDeducible.%T.loc6_25.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @ImplicitNotDeducible.%T.loc6_25.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc6_25.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_25.2 (constants.%T)]
// CHECK:STDOUT: %U.param: type = param U, runtime_param<invalid>
// CHECK:STDOUT: %U.loc6_35.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc6_35.2 (constants.%U)]
// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc6_25.1 [symbolic = %T.loc6_25.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @ImplicitNotDeducible.%T.loc6_25.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @ImplicitNotDeducible.%T.loc6_25.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %U.ref: type = name_ref U, %U.loc6_35.1 [symbolic = %U.loc6_35.2 (constants.%U)]
// CHECK:STDOUT: %return: ref @ImplicitNotDeducible.%U.loc6_35.2 (%U) = var <return slot>
// CHECK:STDOUT: %param.loc6_25: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc6_25.1: type = bind_symbolic_name T, 0, %param.loc6_25 [symbolic = %T.loc6_25.2 (constants.%T)]
// CHECK:STDOUT: %param.loc6_35: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc6_35.1: type = bind_symbolic_name U, 1, %param.loc6_35 [symbolic = %U.loc6_35.2 (constants.%U)]
// CHECK:STDOUT: %param.loc6_45: @ImplicitNotDeducible.%T.loc6_25.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @ImplicitNotDeducible.%T.loc6_25.2 (%T) = bind_name x, %param.loc6_45
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallImplicitNotDeducible.decl: %CallImplicitNotDeducible.type = fn_decl @CallImplicitNotDeducible [template = constants.%CallImplicitNotDeducible] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ImplicitNotDeducible(%T.loc6_25.1: type, %U.loc6_35.1: type) {
// CHECK:STDOUT: %T.loc6_25.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc6_25.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc6_25.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.loc6_35.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc6_35.2 (constants.%U)]
// CHECK:STDOUT: %U.patt.loc6_35.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc6_35.2 (constants.%U.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc6_25.1: type, %U.loc6_35.1: type](%x: @ImplicitNotDeducible.%T.loc6_25.2 (%T)) -> @ImplicitNotDeducible.%U.loc6_35.2 (%U);
// CHECK:STDOUT: fn[%T.param_patt: type, %U.param_patt: type](%x.param_patt: @ImplicitNotDeducible.%T.loc6_25.2 (%T)) -> @ImplicitNotDeducible.%U.loc6_35.2 (%U);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallImplicitNotDeducible() {
@@ -756,13 +800,16 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitNotDeducible(constants.%T, constants.%U) {
// CHECK:STDOUT: %T.loc6_25.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc6_25.2 => constants.%T
// CHECK:STDOUT: %U.loc6_35.2 => constants.%U
// CHECK:STDOUT: %U.patt.loc6_35.2 => constants.%U
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_deduce_inconsistent.carbon
// CHECK:STDOUT:
// 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: %ImplicitNotDeducible.type: type = fn_type @ImplicitNotDeducible [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %ImplicitNotDeducible: %ImplicitNotDeducible.type = struct_value () [template]
@@ -794,28 +841,32 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %ImplicitNotDeducible.decl: %ImplicitNotDeducible.type = fn_decl @ImplicitNotDeducible [template = constants.%ImplicitNotDeducible] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_25.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_25.1, runtime_param<invalid> [symbolic = %T.patt.loc4_25.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: %y.patt: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = binding_pattern y
// CHECK:STDOUT: %y.param_patt: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = param_pattern %y.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_25.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_38: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc4_44: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %y.param: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = param y, runtime_param1
// CHECK:STDOUT: %y: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = bind_name y, %y.param
// CHECK:STDOUT: %T.ref.loc4_50: type = name_ref T, %T.loc4_25.1 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @ImplicitNotDeducible.%T.loc4_25.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc4_25: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_25.1: type = bind_symbolic_name T, 0, %param.loc4_25 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_35: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = bind_name x, %param.loc4_35
// CHECK:STDOUT: %param.loc4_41: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = param runtime_param1
// CHECK:STDOUT: %y: @ImplicitNotDeducible.%T.loc4_25.2 (%T) = bind_name y, %param.loc4_41
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallImplicitNotDeducible.decl: %CallImplicitNotDeducible.type = fn_decl @CallImplicitNotDeducible [template = constants.%CallImplicitNotDeducible] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ImplicitNotDeducible(%T.loc4_25.1: type) {
// CHECK:STDOUT: %T.loc4_25.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_25.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_25.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_25.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_25.1: type](%x: @ImplicitNotDeducible.%T.loc4_25.2 (%T), %y: @ImplicitNotDeducible.%T.loc4_25.2 (%T)) -> @ImplicitNotDeducible.%T.loc4_25.2 (%T);
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @ImplicitNotDeducible.%T.loc4_25.2 (%T), %y.param_patt: @ImplicitNotDeducible.%T.loc4_25.2 (%T)) -> @ImplicitNotDeducible.%T.loc4_25.2 (%T);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallImplicitNotDeducible() {
@@ -829,5 +880,6 @@ fn CallImplicitNotDeducible() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitNotDeducible(constants.%T) {
// CHECK:STDOUT: %T.loc4_25.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_25.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon
Vendored
+11 -6
View File
@@ -20,6 +20,7 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %N: i32 = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: i32 = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: }
@@ -46,22 +47,24 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %N.patt: i32 = symbolic_binding_pattern N, 0
// CHECK:STDOUT: %N.patt.loc14_6.1: i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc14_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: i32 = param_pattern %N.patt.loc14_6.1, runtime_param<invalid> [symbolic = %N.patt.loc14_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %a.patt: <error> = binding_pattern a
// CHECK:STDOUT: %a.param_patt: <error> = param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32.loc14_10: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc14_10.1: type = value_of_initializer %int.make_type_32.loc14_10 [template = i32]
// CHECK:STDOUT: %.loc14_10.2: type = converted %int.make_type_32.loc14_10, %.loc14_10.1 [template = i32]
// CHECK:STDOUT: %N.param: i32 = param N, runtime_param<invalid>
// CHECK:STDOUT: %N.loc14_6.1: i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc14_6.2 (constants.%N)]
// CHECK:STDOUT: %int.make_type_32.loc14_19: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %N.ref: i32 = name_ref N, %N.loc14_6.1 [symbolic = %N.loc14_6.2 (constants.%N)]
// CHECK:STDOUT: %.loc14_19.1: type = value_of_initializer %int.make_type_32.loc14_19 [template = i32]
// CHECK:STDOUT: %.loc14_19.2: type = converted %int.make_type_32.loc14_19, %.loc14_19.1 [template = i32]
// CHECK:STDOUT: %.loc14_25: type = array_type %N.ref, i32 [template = <error>]
// CHECK:STDOUT: %.loc14_26: type = ptr_type <error> [template = <error>]
// CHECK:STDOUT: %a.param: <error> = param a, runtime_param0
// CHECK:STDOUT: %a: <error> = bind_name a, %a.param
// CHECK:STDOUT: %param.loc14_6: i32 = param runtime_param<invalid>
// CHECK:STDOUT: %N.loc14_6.1: i32 = bind_symbolic_name N, 0, %param.loc14_6 [symbolic = %N.loc14_6.2 (constants.%N)]
// CHECK:STDOUT: %param.loc14_15: <error> = param runtime_param0
// CHECK:STDOUT: %a: <error> = bind_name a, %param.loc14_15
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -69,11 +72,13 @@ fn F(N:! i32, a: [i32; N]*);
// CHECK:STDOUT:
// 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)]
// CHECK:STDOUT: %N.patt.loc14_6.2: i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc14_6.2 (constants.%N.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%N.loc14_6.1: i32, %a: <error>);
// CHECK:STDOUT: fn(%N.param_patt: i32, %a.param_patt: <error>);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%N) {
// CHECK:STDOUT: %N.loc14_6.2 => constants.%N
// CHECK:STDOUT: %N.patt.loc14_6.2 => constants.%N
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/call.carbon
Vendored
+82 -42
View File
@@ -56,12 +56,15 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Function.type: type = fn_type @Function [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Function: %Function.type = struct_value () [template]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %CallGeneric.type: type = fn_type @CallGeneric [template]
// CHECK:STDOUT: %CallGeneric: %CallGeneric.type = struct_value () [template]
// CHECK:STDOUT: %.2: <specific function> = specific_function %Function, @Function(%T) [symbolic]
// CHECK:STDOUT: %T.patt.3: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.3: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %CallGenericPtr.type: type = fn_type @CallGenericPtr [template]
// CHECK:STDOUT: %CallGenericPtr: %CallGenericPtr.type = struct_value () [template]
@@ -84,52 +87,59 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: .CallSpecific = %CallSpecific.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %Function.decl: %Function.type = fn_decl @Function [template = constants.%Function] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_13.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_13.1, runtime_param<invalid> [symbolic = %T.patt.loc4_13.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %x.patt: @Function.%T.loc4_13.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @Function.%T.loc4_13.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_13.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_26: type = name_ref T, %T.loc4_13.1 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @Function.%T.loc4_13.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @Function.%T.loc4_13.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc4_32: type = name_ref T, %T.loc4_13.1 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @Function.%T.loc4_13.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc4_13: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_13.1: type = bind_symbolic_name T, 0, %param.loc4_13 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_23: @Function.%T.loc4_13.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @Function.%T.loc4_13.2 (%T) = bind_name x, %param.loc4_23
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallGeneric.decl: %CallGeneric.type = fn_decl @CallGeneric [template = constants.%CallGeneric] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc8_16.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc8_16.1, runtime_param<invalid> [symbolic = %T.patt.loc8_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %x.patt: @CallGeneric.%T.loc8_16.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGeneric.%T.loc8_16.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc8_16.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc8_29: type = name_ref T, %T.loc8_16.1 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @CallGeneric.%T.loc8_16.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @CallGeneric.%T.loc8_16.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc8_35: type = name_ref T, %T.loc8_16.1 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @CallGeneric.%T.loc8_16.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc8_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc8_16.1: type = bind_symbolic_name T, 0, %param.loc8_16 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %param.loc8_26: @CallGeneric.%T.loc8_16.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @CallGeneric.%T.loc8_16.2 (%T) = bind_name x, %param.loc8_26
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallGenericPtr.decl: %CallGenericPtr.type = fn_decl @CallGenericPtr [template = constants.%CallGenericPtr] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc12_19.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc12_19.2 (constants.%T.patt.3)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc12_19.1, runtime_param<invalid> [symbolic = %T.patt.loc12_19.2 (constants.%T.patt.3)]
// CHECK:STDOUT: %x.patt: @CallGenericPtr.%.loc12_33.2 (%.3) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.3) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %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.%.3)]
// CHECK:STDOUT: %x.param: @CallGenericPtr.%.loc12_33.2 (%.3) = param x, runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%.loc12_33.2 (%.3) = bind_name x, %x.param
// 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.%.3)]
// CHECK:STDOUT: %return: ref @CallGenericPtr.%.loc12_33.2 (%.3) = var <return slot>
// CHECK:STDOUT: %param.loc12_19: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc12_19.1: type = bind_symbolic_name T, 0, %param.loc12_19 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %param.loc12_29: @CallGenericPtr.%.loc12_33.2 (%.3) = param runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%.loc12_33.2 (%.3) = bind_name x, %param.loc12_29
// 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] {
// CHECK:STDOUT: %x.patt: %C = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %C = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc18_20: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %x.param: %C = param x, runtime_param0
// CHECK:STDOUT: %x: %C = bind_name x, %x.param
// CHECK:STDOUT: %C.ref.loc18_26: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %return: ref %C = var <return slot>
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %x: %C = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -142,10 +152,11 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Function(%T.loc4_13.1: type) {
// CHECK:STDOUT: %T.loc4_13.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc4_13.1: type, %x: @Function.%T.loc4_13.2 (%T)) -> @Function.%T.loc4_13.2 (%T) {
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @Function.%T.loc4_13.2 (%T)) -> @Function.%T.loc4_13.2 (%T) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %x.ref: @Function.%T.loc4_13.2 (%T) = name_ref x, %x
// CHECK:STDOUT: return %x.ref
@@ -154,11 +165,12 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @CallGeneric(%T.loc8_16.1: type) {
// CHECK:STDOUT: %T.loc8_16.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc8_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt.2)]
// 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.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc8_16.1: type, %x: @CallGeneric.%T.loc8_16.2 (%T)) -> @CallGeneric.%T.loc8_16.2 (%T) {
// 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)]
@@ -173,12 +185,13 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// 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.3)]
// CHECK:STDOUT: %.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %.loc12_33.2 (constants.%.3)]
// 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.%.4)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc12_19.1: type, %x: @CallGenericPtr.%.loc12_33.2 (%.3)) -> @CallGenericPtr.%.loc12_33.2 (%.3) {
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.3)) -> @CallGenericPtr.%.loc12_33.2 (%.3) {
// 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)]
@@ -192,7 +205,7 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallSpecific(%x: %C) -> %return: %C {
// CHECK:STDOUT: fn @CallSpecific(%x.param_patt: %C) -> %return: %C {
// CHECK:STDOUT: !entry:
// 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]
@@ -205,35 +218,42 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%T) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @CallGeneric(constants.%T) {
// CHECK:STDOUT: %T.loc8_16.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc8_16.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(@CallGeneric.%T.loc8_16.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// 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.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%.3) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.3
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.3
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(@CallGenericPtr.%.loc12_33.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.3
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%C) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%C
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%C
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
@@ -242,12 +262,15 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Function.type: type = fn_type @Function [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Function: %Function.type = struct_value () [template]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %CallGeneric.type: type = fn_type @CallGeneric [template]
// CHECK:STDOUT: %CallGeneric: %CallGeneric.type = struct_value () [template]
// CHECK:STDOUT: %.2: <specific function> = specific_function %Function, @Function(%T) [symbolic]
// CHECK:STDOUT: %T.patt.3: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.3: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %CallGenericPtr.type: type = fn_type @CallGenericPtr [template]
// CHECK:STDOUT: %CallGenericPtr: %CallGenericPtr.type = struct_value () [template]
@@ -270,52 +293,59 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: .CallSpecific = %CallSpecific.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %Function.decl: %Function.type = fn_decl @Function [template = constants.%Function] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_13.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_13.1, runtime_param<invalid> [symbolic = %T.patt.loc4_13.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %x.patt: @Function.%T.loc4_13.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @Function.%T.loc4_13.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_13.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_26: type = name_ref T, %T.loc4_13.1 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @Function.%T.loc4_13.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @Function.%T.loc4_13.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc4_32: type = name_ref T, %T.loc4_13.1 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @Function.%T.loc4_13.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc4_13: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_13.1: type = bind_symbolic_name T, 0, %param.loc4_13 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_23: @Function.%T.loc4_13.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @Function.%T.loc4_13.2 (%T) = bind_name x, %param.loc4_23
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallGeneric.decl: %CallGeneric.type = fn_decl @CallGeneric [template = constants.%CallGeneric] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc8_16.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc8_16.1, runtime_param<invalid> [symbolic = %T.patt.loc8_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %x.patt: @CallGeneric.%T.loc8_16.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGeneric.%T.loc8_16.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc8_16.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc8_29: type = name_ref T, %T.loc8_16.1 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @CallGeneric.%T.loc8_16.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @CallGeneric.%T.loc8_16.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc8_35: type = name_ref T, %T.loc8_16.1 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @CallGeneric.%T.loc8_16.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc8_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc8_16.1: type = bind_symbolic_name T, 0, %param.loc8_16 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %param.loc8_26: @CallGeneric.%T.loc8_16.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @CallGeneric.%T.loc8_16.2 (%T) = bind_name x, %param.loc8_26
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallGenericPtr.decl: %CallGenericPtr.type = fn_decl @CallGenericPtr [template = constants.%CallGenericPtr] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc12_19.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc12_19.2 (constants.%T.patt.3)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc12_19.1, runtime_param<invalid> [symbolic = %T.patt.loc12_19.2 (constants.%T.patt.3)]
// CHECK:STDOUT: %x.patt: @CallGenericPtr.%.loc12_33.2 (%.3) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.3) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %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.%.3)]
// CHECK:STDOUT: %x.param: @CallGenericPtr.%.loc12_33.2 (%.3) = param x, runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%.loc12_33.2 (%.3) = bind_name x, %x.param
// 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.%.3)]
// CHECK:STDOUT: %return: ref @CallGenericPtr.%.loc12_33.2 (%.3) = var <return slot>
// CHECK:STDOUT: %param.loc12_19: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc12_19.1: type = bind_symbolic_name T, 0, %param.loc12_19 [symbolic = %T.loc12_19.2 (constants.%T)]
// CHECK:STDOUT: %param.loc12_29: @CallGenericPtr.%.loc12_33.2 (%.3) = param runtime_param0
// CHECK:STDOUT: %x: @CallGenericPtr.%.loc12_33.2 (%.3) = bind_name x, %param.loc12_29
// 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] {
// CHECK:STDOUT: %x.patt: %C = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %C = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref.loc18_20: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %x.param: %C = param x, runtime_param0
// CHECK:STDOUT: %x: %C = bind_name x, %x.param
// CHECK:STDOUT: %C.ref.loc18_26: type = name_ref C, file.%C.decl [template = constants.%C]
// CHECK:STDOUT: %return: ref %C = var <return slot>
// CHECK:STDOUT: %param: %C = param runtime_param0
// CHECK:STDOUT: %x: %C = bind_name x, %param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -328,10 +358,11 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Function(%T.loc4_13.1: type) {
// CHECK:STDOUT: %T.loc4_13.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_13.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_13.1: type](%x: @Function.%T.loc4_13.2 (%T)) -> @Function.%T.loc4_13.2 (%T) {
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @Function.%T.loc4_13.2 (%T)) -> @Function.%T.loc4_13.2 (%T) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %x.ref: @Function.%T.loc4_13.2 (%T) = name_ref x, %x
// CHECK:STDOUT: return %x.ref
@@ -340,11 +371,12 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @CallGeneric(%T.loc8_16.1: type) {
// CHECK:STDOUT: %T.loc8_16.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc8_16.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc8_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt.2)]
// 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.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc8_16.1: type, %x: @CallGeneric.%T.loc8_16.2 (%T)) -> @CallGeneric.%T.loc8_16.2 (%T) {
// 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
@@ -358,12 +390,13 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// 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.3)]
// CHECK:STDOUT: %.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %.loc12_33.2 (constants.%.3)]
// 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.%.4)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc12_19.1: type, %x: @CallGenericPtr.%.loc12_33.2 (%.3)) -> @CallGenericPtr.%.loc12_33.2 (%.3) {
// CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%.loc12_33.2 (%.3)) -> @CallGenericPtr.%.loc12_33.2 (%.3) {
// 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 (%.3) = name_ref x, %x
@@ -375,7 +408,7 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallSpecific(%x: %C) -> %return: %C {
// CHECK:STDOUT: fn @CallSpecific(%x.param_patt: %C) -> %return: %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
@@ -387,35 +420,42 @@ fn CallSpecific(x: C) -> C {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%T) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @CallGeneric(constants.%T) {
// CHECK:STDOUT: %T.loc8_16.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc8_16.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(@CallGeneric.%T.loc8_16.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// 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.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%.3) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.3
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.3
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(@CallGenericPtr.%.loc12_33.2) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%.3
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Function(constants.%C) {
// CHECK:STDOUT: %T.loc4_13.2 => constants.%C
// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%C
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
toolchain/check/testdata/function/generic/no_prelude/fail_type_param_mismatch.carbon
Vendored
+15 -7
View File
@@ -20,7 +20,9 @@ fn F(T:! type, U:! type) {
// CHECK:STDOUT:
// 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: %U: type = bind_symbolic_name U, 1 [symbolic]
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
@@ -32,24 +34,28 @@ fn F(T:! type, U:! type) {
// CHECK:STDOUT: .F = %F.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1
// 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 = param_pattern %T.patt.loc11_6.1, runtime_param<invalid> [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %U.patt.loc11_16.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc11_16.2 (constants.%U.patt)]
// CHECK:STDOUT: %U.param_patt: type = param_pattern %U.patt.loc11_16.1, runtime_param<invalid> [symbolic = %U.patt.loc11_16.2 (constants.%U.patt)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %U.param: type = param U, runtime_param<invalid>
// CHECK:STDOUT: %U.loc11_16.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc11_16.2 (constants.%U)]
// CHECK:STDOUT: %param.loc11_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_6.1: type = bind_symbolic_name T, 0, %param.loc11_6 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %param.loc11_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc11_16.1: type = bind_symbolic_name U, 1, %param.loc11_16 [symbolic = %U.loc11_16.2 (constants.%U)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%T.loc11_6.1: type, %U.loc11_16.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: %U.loc11_16.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc11_16.2 (constants.%U)]
// 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.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc11_6.1: type, %U.loc11_16.1: type) {
// 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.%.2)]
@@ -67,6 +73,8 @@ fn F(T:! type, U:! type) {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%T, constants.%U) {
// CHECK:STDOUT: %T.loc11_6.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc11_6.2 => constants.%T
// CHECK:STDOUT: %U.loc11_16.2 => constants.%U
// CHECK:STDOUT: %U.patt.loc11_16.2 => constants.%U
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/forward_decl.carbon
Vendored
+8 -4
View File
@@ -14,6 +14,7 @@ fn F(T:! type);
// CHECK:STDOUT:
// 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: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
@@ -24,20 +25,23 @@ fn F(T:! type);
// CHECK:STDOUT: .F = %F.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// 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 = param_pattern %T.patt.loc11_6.1, runtime_param<invalid> [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %param: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_6.1: type = bind_symbolic_name T, 0, %param [symbolic = %T.loc11_6.2 (constants.%T)]
// 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:
// CHECK:STDOUT: fn(%T.loc11_6.1: type);
// CHECK:STDOUT: fn(%T.param_patt: type);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// 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: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/indirect_generic_type.carbon
Vendored
+11 -6
View File
@@ -16,6 +16,7 @@ fn F(T:! type, p: T**) -> T* {
// CHECK:STDOUT:
// 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: %F.type: type = fn_type @F [template]
@@ -28,30 +29,33 @@ fn F(T:! type, p: T**) -> T* {
// CHECK:STDOUT: .F = %F.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// 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 = 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) = param_pattern %p.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %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: %p.param: @F.%.loc11_21.2 (%.2) = param p, runtime_param0
// CHECK:STDOUT: %p: @F.%.loc11_21.2 (%.2) = bind_name p, %p.param
// 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: %return: ref @F.%.loc11_20.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param.loc11_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_6.1: type = bind_symbolic_name T, 0, %param.loc11_6 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %param.loc11_16: @F.%.loc11_21.2 (%.2) = param runtime_param0
// CHECK:STDOUT: %p: @F.%.loc11_21.2 (%.2) = bind_name p, %param.loc11_16
// 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:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc11_6.1: type, %p: @F.%.loc11_21.2 (%.2)) -> @F.%.loc11_20.2 (%.1) {
// CHECK:STDOUT: fn(%T.param_patt: type, %p.param_patt: @F.%.loc11_21.2 (%.2)) -> @F.%.loc11_20.2 (%.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
@@ -62,6 +66,7 @@ fn F(T:! type, p: T**) -> T* {
// CHECK:STDOUT:
// 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: }
toolchain/check/testdata/function/generic/no_prelude/type_param.carbon
Vendored
+8 -4
View File
@@ -17,6 +17,7 @@ fn F(T:! type) {
// CHECK:STDOUT:
// 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: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
@@ -28,20 +29,22 @@ fn F(T:! type) {
// CHECK:STDOUT: .F = %F.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// 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 = param_pattern %T.patt.loc11_6.1, runtime_param<invalid> [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %param: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_6.1: type = bind_symbolic_name T, 0, %param [symbolic = %T.loc11_6.2 (constants.%T)]
// 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:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %.loc12_11.2 (constants.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc11_6.1: type) {
// 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.%.2)]
@@ -59,5 +62,6 @@ fn F(T:! type) {
// CHECK:STDOUT:
// 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: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/no_prelude/type_param_scope.carbon
Vendored
+11 -6
View File
@@ -17,6 +17,7 @@ fn F(T:! type, n: T) -> T {
// CHECK:STDOUT:
// 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: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
@@ -27,25 +28,28 @@ fn F(T:! type, n: T) -> T {
// CHECK:STDOUT: .F = %F.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// 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 = param_pattern %T.patt.loc11_6.1, runtime_param<invalid> [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)]
// CHECK:STDOUT: %n.patt: @F.%T.loc11_6.2 (%T) = binding_pattern n
// CHECK:STDOUT: %n.param_patt: @F.%T.loc11_6.2 (%T) = param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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: %T.ref.loc11_19: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %n.param: @F.%T.loc11_6.2 (%T) = param n, runtime_param0
// CHECK:STDOUT: %n: @F.%T.loc11_6.2 (%T) = bind_name n, %n.param
// CHECK:STDOUT: %T.ref.loc11_25: type = name_ref T, %T.loc11_6.1 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @F.%T.loc11_6.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc11_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_6.1: type = bind_symbolic_name T, 0, %param.loc11_6 [symbolic = %T.loc11_6.2 (constants.%T)]
// CHECK:STDOUT: %param.loc11_16: @F.%T.loc11_6.2 (%T) = param runtime_param0
// CHECK:STDOUT: %n: @F.%T.loc11_6.2 (%T) = bind_name n, %param.loc11_16
// 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:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc11_6.1: type, %n: @F.%T.loc11_6.2 (%T)) -> @F.%T.loc11_6.2 (%T) {
// CHECK:STDOUT: fn(%T.param_patt: type, %n.param_patt: @F.%T.loc11_6.2 (%T)) -> @F.%T.loc11_6.2 (%T) {
// 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: %n.ref: @F.%T.loc11_6.2 (%T) = name_ref n, %n
@@ -57,5 +61,6 @@ fn F(T:! type, n: T) -> T {
// CHECK:STDOUT:
// 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: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/redeclare.carbon
Vendored
+108 -53
View File
@@ -50,10 +50,10 @@ fn F(T:! type, U:! type) -> T*;
// CHECK:STDERR: fail_reorder.carbon:[[@LINE+7]]:6: error: redeclaration differs at parameter 1
// CHECK:STDERR: fn F(U:! type, T:! type) -> T* {
// CHECK:STDERR: ^
// CHECK:STDERR: ^~~~~~~~
// CHECK:STDERR: fail_reorder.carbon:[[@LINE-5]]:6: note: previous declaration's corresponding parameter here
// CHECK:STDERR: fn F(T:! type, U:! type) -> T*;
// CHECK:STDERR: ^
// CHECK:STDERR: ^~~~~~~~
// CHECK:STDERR:
fn F(U:! type, T:! type) -> T* {
// CHECK:STDERR: fail_reorder.carbon:[[@LINE+7]]:10: error: 1 argument(s) passed to function expecting 2 argument(s).
@@ -74,10 +74,10 @@ fn F(T:! type, U:! type) -> T*;
// CHECK:STDERR: fail_rename.carbon:[[@LINE+7]]:6: error: redeclaration differs at parameter 1
// CHECK:STDERR: fn F(U:! type, T:! type) -> U* {
// CHECK:STDERR: ^
// CHECK:STDERR: ^~~~~~~~
// CHECK:STDERR: fail_rename.carbon:[[@LINE-5]]:6: note: previous declaration's corresponding parameter here
// CHECK:STDERR: fn F(T:! type, U:! type) -> T*;
// CHECK:STDERR: ^
// CHECK:STDERR: ^~~~~~~~
// CHECK:STDERR:
fn F(U:! type, T:! type) -> U* {
// CHECK:STDERR: fail_rename.carbon:[[@LINE+6]]:10: error: 1 argument(s) passed to function expecting 2 argument(s).
@@ -93,10 +93,12 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.1: type = ptr_type %T [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %.3: <specific function> = specific_function %F, @F(%T) [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -120,33 +122,36 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl.loc4: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc6: type = symbolic_binding_pattern T, 0 [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc6, runtime_param<invalid> [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param.loc4: type = param T, 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: %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: %return.var.loc4: ref @F.%.loc4_20.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param.loc4: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %param.loc4 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %F.decl.loc6: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc6: type = symbolic_binding_pattern T, 0 [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc6, runtime_param<invalid> [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param.loc6: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc6: type = bind_symbolic_name T, 0, %T.param.loc6 [symbolic = constants.%T]
// CHECK:STDOUT: %T.ref.loc6: type = name_ref T, %T.loc6 [symbolic = constants.%T]
// CHECK:STDOUT: %.loc6: type = ptr_type %T [symbolic = constants.%.1]
// CHECK:STDOUT: %return: ref %.1 = var <return slot>
// CHECK:STDOUT: %param.loc6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc6: type = bind_symbolic_name T, 0, %param.loc6 [symbolic = constants.%T]
// 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.1)]
// CHECK:STDOUT: %.loc4_20.2: type = ptr_type @F.%T.loc4_6.2 (%T) [symbolic = %.loc4_20.2 (constants.%.1)]
// 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.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc6: type) -> %.1 {
// CHECK:STDOUT: fn(%T.param_patt: type) -> %.1 {
// 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)]
@@ -160,6 +165,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// 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:
// CHECK:STDOUT: !definition:
@@ -168,6 +174,7 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(@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: }
// CHECK:STDOUT:
@@ -175,11 +182,15 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %U: 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 [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %U.patt.2: type = symbolic_binding_pattern U, 1 [symbolic]
// CHECK:STDOUT: %.3: type = ptr_type %U [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.4: %.type = struct_value () [template]
@@ -205,47 +216,55 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1
// CHECK:STDOUT: %T.patt.loc4_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %T.param_patt: type = 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 = param_pattern %U.patt.loc4_16.1, runtime_param<invalid> [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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 = param U, 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: %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: %return: ref @F.%.loc4_30.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param.loc4_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %param.loc4_6 [symbolic = %T.loc4_6.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc4_16.1: type = bind_symbolic_name U, 1, %param.loc4_16 [symbolic = %U.loc4_16.2 (constants.%U)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1
// CHECK:STDOUT: %T.patt.loc13_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc13_6.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc13_6.1, runtime_param<invalid> [symbolic = %T.patt.loc13_6.2 (constants.%T.patt.2)]
// CHECK:STDOUT: %U.patt.loc13_16.1: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc13_16.2 (constants.%U.patt.2)]
// CHECK:STDOUT: %U.param_patt: type = param_pattern %U.patt.loc13_16.1, runtime_param<invalid> [symbolic = %U.patt.loc13_16.2 (constants.%U.patt.2)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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 = param U, 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: %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.%.3)]
// CHECK:STDOUT: %return: ref @.1.%.loc13_30.2 (%.3) = var <return slot>
// CHECK:STDOUT: %param.loc13_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc13_6.1: type = bind_symbolic_name T, 0, %param.loc13_6 [symbolic = %T.loc13_6.2 (constants.%T)]
// CHECK:STDOUT: %param.loc13_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc13_16.1: type = bind_symbolic_name U, 1, %param.loc13_16 [symbolic = %U.loc13_16.2 (constants.%U)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%T.loc4_6.1: type, %U.loc4_16.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_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)]
// 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) [symbolic = %.loc4_30.2 (constants.%.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc4_6.1: type, %U.loc4_16.1: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%T.loc13_6.1: type, %U.loc13_16.1: type) {
// CHECK:STDOUT: %T.loc13_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc13_6.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc13_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc13_6.2 (constants.%T.patt.2)]
// 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.2)]
// CHECK:STDOUT: %.loc13_30.2: type = ptr_type @.1.%U.loc13_16.2 (%U) [symbolic = %.loc13_30.2 (constants.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%T.loc13_6.1: type, %U.loc13_16.1: type) -> @.1.%.loc13_30.2 (%.3) {
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @.1.%.loc13_30.2 (%.3) {
// 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)]
@@ -255,13 +274,17 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%T, constants.%U) {
// CHECK:STDOUT: %T.loc4_6.2 => constants.%T
// 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: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%T, constants.%U) {
// CHECK:STDOUT: %T.loc13_6.2 => constants.%T
// 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.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -269,13 +292,17 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T.1: type = bind_symbolic_name T, 0 [symbolic]
// 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: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.2: type = tuple_type () [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: %.3: type = ptr_type %T.2 [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.4: %.type = struct_value () [template]
@@ -301,47 +328,55 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1
// CHECK:STDOUT: %T.patt.loc4_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %T.param_patt: type = 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 = param_pattern %U.patt.loc4_16.1, runtime_param<invalid> [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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 = param U, 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: %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: %return: ref @F.%.loc4_30.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param.loc4_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %param.loc4_6 [symbolic = %T.loc4_6.2 (constants.%T.1)]
// CHECK:STDOUT: %param.loc4_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc4_16.1: type = bind_symbolic_name U, 1, %param.loc4_16 [symbolic = %U.loc4_16.2 (constants.%U.1)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 0
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 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 = 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 = param_pattern %T.patt.loc13_16.1, runtime_param<invalid> [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %U.param: type = param U, 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 = param T, 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: %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.%.3)]
// CHECK:STDOUT: %return: ref @.1.%.loc13_30.2 (%.3) = var <return slot>
// CHECK:STDOUT: %param.loc13_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc13_6.1: type = bind_symbolic_name U, 0, %param.loc13_6 [symbolic = %U.loc13_6.2 (constants.%U.2)]
// CHECK:STDOUT: %param.loc13_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc13_16.1: type = bind_symbolic_name T, 1, %param.loc13_16 [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%T.loc4_6.1: type, %U.loc4_16.1: type) {
// CHECK:STDOUT: %T.loc4_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_6.2 (constants.%T.1)]
// 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:
// CHECK:STDOUT: fn(%T.loc4_6.1: type, %U.loc4_16.1: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%U.loc13_6.1: type, %T.loc13_16.1: type) {
// CHECK:STDOUT: %U.loc13_6.2: type = bind_symbolic_name U, 0 [symbolic = %U.loc13_6.2 (constants.%U.2)]
// 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.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%U.loc13_6.1: type, %T.loc13_16.1: type) -> @.1.%.loc13_30.2 (%.3) {
// CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%.loc13_30.2 (%.3) {
// 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)]
@@ -351,13 +386,17 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%T.1, constants.%U.1) {
// CHECK:STDOUT: %T.loc4_6.2 => constants.%T.1
// 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: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%U.2, constants.%T.2) {
// CHECK:STDOUT: %U.loc13_6.2 => constants.%U.2
// 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.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -365,13 +404,17 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T.1: type = bind_symbolic_name T, 0 [symbolic]
// 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: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %.2: type = tuple_type () [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: %.3: type = ptr_type %U.2 [symbolic]
// CHECK:STDOUT: %.type: type = fn_type @.1 [template]
// CHECK:STDOUT: %.4: %.type = struct_value () [template]
@@ -397,47 +440,55 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 1
// CHECK:STDOUT: %T.patt.loc4_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_6.2 (constants.%T.patt.1)]
// CHECK:STDOUT: %T.param_patt: type = 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 = param_pattern %U.patt.loc4_16.1, runtime_param<invalid> [symbolic = %U.patt.loc4_16.2 (constants.%U.patt.1)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, 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 = param U, 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: %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: %return: ref @F.%.loc4_30.2 (%.1) = var <return slot>
// CHECK:STDOUT: %param.loc4_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_6.1: type = bind_symbolic_name T, 0, %param.loc4_6 [symbolic = %T.loc4_6.2 (constants.%T.1)]
// CHECK:STDOUT: %param.loc4_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc4_16.1: type = bind_symbolic_name U, 1, %param.loc4_16 [symbolic = %U.loc4_16.2 (constants.%U.1)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %.decl: %.type = fn_decl @.1 [template = constants.%.4] {
// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 0
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 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 = 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 = param_pattern %T.patt.loc13_16.1, runtime_param<invalid> [symbolic = %T.patt.loc13_16.2 (constants.%T.patt.2)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %U.param: type = param U, 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 = param T, 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: %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.%.3)]
// CHECK:STDOUT: %return: ref @.1.%.loc13_30.2 (%.3) = var <return slot>
// CHECK:STDOUT: %param.loc13_6: type = param runtime_param<invalid>
// CHECK:STDOUT: %U.loc13_6.1: type = bind_symbolic_name U, 0, %param.loc13_6 [symbolic = %U.loc13_6.2 (constants.%U.2)]
// CHECK:STDOUT: %param.loc13_16: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc13_16.1: type = bind_symbolic_name T, 1, %param.loc13_16 [symbolic = %T.loc13_16.2 (constants.%T.2)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%T.loc4_6.1: type, %U.loc4_16.1: type) {
// CHECK:STDOUT: %T.loc4_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_6.2 (constants.%T.1)]
// 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:
// CHECK:STDOUT: fn(%T.loc4_6.1: type, %U.loc4_16.1: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @F.%.loc4_30.2 (%.1);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @.1(%U.loc13_6.1: type, %T.loc13_16.1: type) {
// CHECK:STDOUT: %U.loc13_6.2: type = bind_symbolic_name U, 0 [symbolic = %U.loc13_6.2 (constants.%U.2)]
// 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.%.3)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%U.loc13_6.1: type, %T.loc13_16.1: type) -> @.1.%.loc13_30.2 (%.3) {
// CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%.loc13_30.2 (%.3) {
// 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)]
@@ -447,13 +498,17 @@ fn F(U:! type, T:! type) -> U* {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%T.1, constants.%U.1) {
// CHECK:STDOUT: %T.loc4_6.2 => constants.%T.1
// 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: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @.1(constants.%U.2, constants.%T.2) {
// CHECK:STDOUT: %U.loc13_6.2 => constants.%U.2
// 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.%.3
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/function/generic/resolve_used.carbon
Vendored
+11 -6
View File
@@ -34,6 +34,7 @@ fn CallNegative() {
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %N: i32 = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: i32 = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %ErrorIfNIsZero.type: type = fn_type @ErrorIfNIsZero [template]
// CHECK:STDOUT: %ErrorIfNIsZero: %ErrorIfNIsZero.type = struct_value () [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
@@ -59,7 +60,7 @@ fn CallNegative() {
// CHECK:STDOUT: import Core//prelude/types/bool
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref Core//prelude/types, inst+4, loaded [template = constants.%Int32]
// CHECK:STDOUT: %import_ref.2: %Int.type = import_ref Core//prelude/types, inst+15, loaded [template = constants.%Int]
// CHECK:STDOUT: %import_ref.2: %Int.type = import_ref Core//prelude/types, inst+16, loaded [template = constants.%Int]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -70,13 +71,14 @@ fn CallNegative() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %ErrorIfNIsZero.decl: %ErrorIfNIsZero.type = fn_decl @ErrorIfNIsZero [template = constants.%ErrorIfNIsZero] {
// CHECK:STDOUT: %N.patt: i32 = symbolic_binding_pattern N, 0
// CHECK:STDOUT: %N.patt.loc4_19.1: i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: i32 = param_pattern %N.patt.loc4_19.1, runtime_param<invalid> [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc4_23.1: type = value_of_initializer %int.make_type_32 [template = i32]
// CHECK:STDOUT: %.loc4_23.2: type = converted %int.make_type_32, %.loc4_23.1 [template = i32]
// CHECK:STDOUT: %N.param: i32 = param N, runtime_param<invalid>
// CHECK:STDOUT: %N.loc4_19.1: i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc4_19.2 (constants.%N)]
// CHECK:STDOUT: %param: i32 = param runtime_param<invalid>
// CHECK:STDOUT: %N.loc4_19.1: i32 = bind_symbolic_name N, 0, %param [symbolic = %N.loc4_19.2 (constants.%N)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallNegative.decl: %CallNegative.type = fn_decl @CallNegative [template = constants.%CallNegative] {} {}
// CHECK:STDOUT: }
@@ -85,11 +87,12 @@ fn CallNegative() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ErrorIfNIsZero(%N.loc4_19.1: i32) {
// CHECK:STDOUT: %N.loc4_19.2: i32 = bind_symbolic_name N, 0 [symbolic = %N.loc4_19.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc4_19.2: i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc12_18: type = int_type signed, %N.loc4_19.2 [symbolic = %.loc12_18 (constants.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%N.loc4_19.1: i32) {
// CHECK:STDOUT: fn(%N.param_patt: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Core.ref: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %Int.ref: %Int.type = name_ref Int, imports.%import_ref.2 [template = constants.%Int]
@@ -103,7 +106,7 @@ fn CallNegative() {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int(%size: i32) -> type = "int.make_type_signed";
// CHECK:STDOUT: fn @Int(%size.param_patt: i32) -> type = "int.make_type_signed";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallNegative() {
// CHECK:STDOUT: !entry:
@@ -116,10 +119,12 @@ fn CallNegative() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ErrorIfNIsZero(constants.%N) {
// CHECK:STDOUT: %N.loc4_19.2 => constants.%N
// CHECK:STDOUT: %N.patt.loc4_19.2 => constants.%N
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ErrorIfNIsZero(constants.%.3) {
// CHECK:STDOUT: %N.loc4_19.2 => constants.%.3
// CHECK:STDOUT: %N.patt.loc4_19.2 => constants.%.3
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc12_18 => <error>
toolchain/check/testdata/function/generic/return_slot.carbon
Vendored
+12 -3
View File
@@ -24,6 +24,7 @@ fn G() {
// CHECK:STDOUT:
// 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: %Wrap.type: type = generic_class_type @Wrap [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Wrap.1: %Wrap.type = struct_value () [template]
@@ -85,10 +86,11 @@ fn G() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Wrap.decl: %Wrap.type = class_decl @Wrap [template = constants.%Wrap.1] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// 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 = param_pattern %T.patt.loc11_12.1, runtime_param<invalid> [symbolic = %T.patt.loc11_12.2 (constants.%T.patt)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_12.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc11_12.2 (constants.%T)]
// CHECK:STDOUT: %param: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc11_12.1: type = bind_symbolic_name T, 0, %param [symbolic = %T.loc11_12.2 (constants.%T)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {}
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {} {}
@@ -96,6 +98,7 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: generic class @Wrap(%T.loc11_12.1: type) {
// CHECK:STDOUT: %T.loc11_12.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc11_12.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc11_12.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_12.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type: type = fn_type @Make, @Wrap(%T.loc11_12.2) [symbolic = %Make.type (constants.%Make.type.1)]
@@ -197,6 +200,7 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(constants.%T) {
// CHECK:STDOUT: %T.loc11_12.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc11_12.2 => constants.%T
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.1
@@ -214,10 +218,12 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(@Wrap.%T.loc11_12.2) {
// CHECK:STDOUT: %T.loc11_12.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc11_12.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(@Make.%T) {
// CHECK:STDOUT: %T.loc11_12.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc11_12.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Make(@Make.%T) {
@@ -226,6 +232,7 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(i32) {
// CHECK:STDOUT: %T.loc11_12.2 => i32
// CHECK:STDOUT: %T.patt.loc11_12.2 => i32
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.2
@@ -243,6 +250,7 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(constants.%.1) {
// CHECK:STDOUT: %T.loc11_12.2 => constants.%.1
// CHECK:STDOUT: %T.patt.loc11_12.2 => constants.%.1
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.3
@@ -260,6 +268,7 @@ fn G() {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Wrap(constants.%C) {
// CHECK:STDOUT: %T.loc11_12.2 => constants.%C
// CHECK:STDOUT: %T.patt.loc11_12.2 => constants.%C
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Make.type => constants.%Make.type.4
toolchain/check/testdata/function/generic/undefined.carbon
Vendored
+44 -23
View File
@@ -54,6 +54,7 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// 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: %Defined.type: type = fn_type @Defined [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Defined: %Defined.type = struct_value () [template]
@@ -88,16 +89,18 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Defined.decl: %Defined.type = fn_decl @Defined [template = constants.%Defined] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_12.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_12.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_12.1, runtime_param<invalid> [symbolic = %T.patt.loc4_12.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @Defined.%T.loc4_12.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @Defined.%T.loc4_12.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_12.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_25: type = name_ref T, %T.loc4_12.1 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @Defined.%T.loc4_12.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @Defined.%T.loc4_12.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc4_31: type = name_ref T, %T.loc4_12.1 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @Defined.%T.loc4_12.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc4_12: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_12.1: type = bind_symbolic_name T, 0, %param.loc4_12 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_22: @Defined.%T.loc4_12.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @Defined.%T.loc4_12.2 (%T) = bind_name x, %param.loc4_22
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallDefined.decl: %CallDefined.type = fn_decl @CallDefined [template = constants.%CallDefined] {} {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
@@ -109,10 +112,11 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Defined(%T.loc4_12.1: type) {
// CHECK:STDOUT: %T.loc4_12.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_12.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_12.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_12.1: type](%x: @Defined.%T.loc4_12.2 (%T)) -> @Defined.%T.loc4_12.2 (%T) {
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @Defined.%T.loc4_12.2 (%T)) -> @Defined.%T.loc4_12.2 (%T) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %x.ref: @Defined.%T.loc4_12.2 (%T) = name_ref x, %x
// CHECK:STDOUT: return %x.ref
@@ -134,10 +138,12 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Defined(constants.%T) {
// CHECK:STDOUT: %T.loc4_12.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_12.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Defined(i32) {
// CHECK:STDOUT: %T.loc4_12.2 => i32
// CHECK:STDOUT: %T.patt.loc4_12.2 => i32
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
@@ -146,6 +152,7 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic]
// CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: %Defined.type: type = fn_type @Defined [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Defined: %Defined.type = struct_value () [template]
@@ -155,6 +162,7 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %CallDefined: %CallDefined.type = struct_value () [template]
// CHECK:STDOUT: %.2: i32 = int_literal 0 [template]
// CHECK:STDOUT: %.3: <specific function> = specific_function %Defined, @Defined(i32) [template]
// CHECK:STDOUT: %T.patt.2: type = symbolic_binding_pattern T, 0 [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -180,16 +188,18 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Defined.decl.loc4: %Defined.type = fn_decl @Defined [template = constants.%Defined] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc10: type = symbolic_binding_pattern T, 0 [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc10, runtime_param<invalid> [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: %x.patt: %T = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %T = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param.loc4: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_12.1: type = bind_symbolic_name T, 0, %T.param.loc4 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_25: type = name_ref T, %T.loc4_12.1 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %x.param.loc4: @Defined.%T.loc4_12.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x.loc4: @Defined.%T.loc4_12.2 (%T) = bind_name x, %x.param.loc4
// CHECK:STDOUT: %T.ref.loc4_31: type = name_ref T, %T.loc4_12.1 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %return.var.loc4: ref @Defined.%T.loc4_12.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc4_12: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_12.1: type = bind_symbolic_name T, 0, %param.loc4_12 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_22: @Defined.%T.loc4_12.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x.loc4: @Defined.%T.loc4_12.2 (%T) = bind_name x, %param.loc4_22
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallDefined.decl: %CallDefined.type = fn_decl @CallDefined [template = constants.%CallDefined] {} {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
@@ -198,25 +208,28 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: %return: ref i32 = var <return slot>
// CHECK:STDOUT: }
// CHECK:STDOUT: %Defined.decl.loc10: %Defined.type = fn_decl @Defined [template = constants.%Defined] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc10: type = symbolic_binding_pattern T, 0 [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc10, runtime_param<invalid> [symbolic = constants.%T.patt.2]
// CHECK:STDOUT: %x.patt: %T = binding_pattern x
// CHECK:STDOUT: %x.param_patt: %T = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param.loc10: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc10: type = bind_symbolic_name T, 0, %T.param.loc10 [symbolic = constants.%T]
// CHECK:STDOUT: %T.ref.loc10_25: type = name_ref T, %T.loc10 [symbolic = constants.%T]
// CHECK:STDOUT: %x.param.loc10: %T = param x, runtime_param0
// CHECK:STDOUT: %x.loc10: %T = bind_name x, %x.param.loc10
// CHECK:STDOUT: %T.ref.loc10_31: type = name_ref T, %T.loc10 [symbolic = constants.%T]
// CHECK:STDOUT: %return: ref %T = var <return slot>
// CHECK:STDOUT: %param.loc10_12: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc10: type = bind_symbolic_name T, 0, %param.loc10_12 [symbolic = constants.%T]
// CHECK:STDOUT: %param.loc10_22: %T = param runtime_param0
// CHECK:STDOUT: %x.loc10: %T = bind_name x, %param.loc10_22
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Defined(%T.loc4_12.1: type) {
// CHECK:STDOUT: %T.loc4_12.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_12.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4 (constants.%T.patt.1)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc10: type](%x.loc10: %T) -> %T {
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: %T) -> %T {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %x.ref: @Defined.%T.loc4_12.2 (%T) = name_ref x, %x.loc10
// CHECK:STDOUT: return %x.ref
@@ -238,10 +251,12 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Defined(constants.%T) {
// CHECK:STDOUT: %T.loc4_12.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Defined(i32) {
// CHECK:STDOUT: %T.loc4_12.2 => i32
// CHECK:STDOUT: %T.patt.loc4 => i32
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
@@ -250,6 +265,7 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// 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: %Undefined.type: type = fn_type @Undefined [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Undefined: %Undefined.type = struct_value () [template]
@@ -284,16 +300,18 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Undefined.decl: %Undefined.type = fn_decl @Undefined [template = constants.%Undefined] {
// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0
// CHECK:STDOUT: %T.patt.loc4_14.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_14.2 (constants.%T.patt)]
// CHECK:STDOUT: %T.param_patt: type = param_pattern %T.patt.loc4_14.1, runtime_param<invalid> [symbolic = %T.patt.loc4_14.2 (constants.%T.patt)]
// CHECK:STDOUT: %x.patt: @Undefined.%T.loc4_14.2 (%T) = binding_pattern x
// CHECK:STDOUT: %x.param_patt: @Undefined.%T.loc4_14.2 (%T) = param_pattern %x.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %T.param: type = param T, runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_14.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc4_14.2 (constants.%T)]
// CHECK:STDOUT: %T.ref.loc4_27: type = name_ref T, %T.loc4_14.1 [symbolic = %T.loc4_14.2 (constants.%T)]
// CHECK:STDOUT: %x.param: @Undefined.%T.loc4_14.2 (%T) = param x, runtime_param0
// CHECK:STDOUT: %x: @Undefined.%T.loc4_14.2 (%T) = bind_name x, %x.param
// CHECK:STDOUT: %T.ref.loc4_33: type = name_ref T, %T.loc4_14.1 [symbolic = %T.loc4_14.2 (constants.%T)]
// CHECK:STDOUT: %return: ref @Undefined.%T.loc4_14.2 (%T) = var <return slot>
// CHECK:STDOUT: %param.loc4_14: type = param runtime_param<invalid>
// CHECK:STDOUT: %T.loc4_14.1: type = bind_symbolic_name T, 0, %param.loc4_14 [symbolic = %T.loc4_14.2 (constants.%T)]
// CHECK:STDOUT: %param.loc4_24: @Undefined.%T.loc4_14.2 (%T) = param runtime_param0
// CHECK:STDOUT: %x: @Undefined.%T.loc4_14.2 (%T) = bind_name x, %param.loc4_24
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallUndefined.decl: %CallUndefined.type = fn_decl @CallUndefined [template = constants.%CallUndefined] {} {
// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32]
@@ -305,8 +323,9 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Undefined(%T.loc4_14.1: type) {
// CHECK:STDOUT: %T.loc4_14.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc4_14.2 (constants.%T)]
// CHECK:STDOUT: %T.patt.loc4_14.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_14.2 (constants.%T.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%T.loc4_14.1: type](%x: @Undefined.%T.loc4_14.2 (%T)) -> @Undefined.%T.loc4_14.2 (%T);
// CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @Undefined.%T.loc4_14.2 (%T)) -> @Undefined.%T.loc4_14.2 (%T);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
@@ -324,9 +343,11 @@ fn CallUndefined() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Undefined(constants.%T) {
// CHECK:STDOUT: %T.loc4_14.2 => constants.%T
// CHECK:STDOUT: %T.patt.loc4_14.2 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Undefined(i32) {
// CHECK:STDOUT: %T.loc4_14.2 => i32
// CHECK:STDOUT: %T.patt.loc4_14.2 => i32
// CHECK:STDOUT: }
// CHECK:STDOUT: