diff --git a/toolchain/check/testdata/builtins/float/add.carbon b/toolchain/check/testdata/builtins/float/add.carbon index 794e1fd90c17b..ad666ec1684a7 100644 --- a/toolchain/check/testdata/builtins/float/add.carbon +++ b/toolchain/check/testdata/builtins/float/add.carbon @@ -12,7 +12,7 @@ fn Add(a: f64, b: f64) -> f64 = "float.add"; -fn RuntimeCall(a: f64, b: f64) -> f64 { +fn RuntimeCallIsValid(a: f64, b: f64) -> f64 { return Add(a, b); } @@ -38,15 +38,15 @@ fn TooMany(a: f64, b: f64, c: f64) -> f64 = "float.add"; fn BadReturnType(a: f64, b: f64) -> bool = "float.add"; fn JustRight(a: f64, b: f64) -> f64 = "float.add"; -fn RuntimeCallTooFew(a: f64) -> f64 { +fn RuntimeCallIsValidTooFew(a: f64) -> f64 { return TooFew(a); } -fn RuntimeCallTooMany(a: f64, b: f64, c: f64) -> f64 { +fn RuntimeCallIsValidTooMany(a: f64, b: f64, c: f64) -> f64 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { +fn RuntimeCallIsValidBadReturnType(a: f64, b: f64) -> bool { return BadReturnType(a, b); } @@ -58,8 +58,8 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %Float: %Float.type = struct_value () [template] // CHECK:STDOUT: %Add.type: type = fn_type @Add [template] // CHECK:STDOUT: %Add: %Add.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: %float.1: f64 = float_literal 2.2000000000000002 [template] // CHECK:STDOUT: %float.2: f64 = float_literal 2.3000000000000003 [template] // CHECK:STDOUT: %float.3: f64 = float_literal 4.5 [template] @@ -77,7 +77,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Add = %Add.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: .x = %x // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core @@ -112,7 +112,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -120,24 +120,24 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc4_35: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%int_64.loc4_35) [template = f64] -// CHECK:STDOUT: %.loc4_35.1: type = value_of_initializer %float.make_type.loc4_35 [template = f64] -// CHECK:STDOUT: %.loc4_35.2: type = converted %float.make_type.loc4_35, %.loc4_35.1 [template = f64] +// CHECK:STDOUT: %int_64.loc4_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_42: init type = call constants.%Float(%int_64.loc4_42) [template = f64] +// CHECK:STDOUT: %.loc4_42.1: type = value_of_initializer %float.make_type.loc4_42 [template = f64] +// CHECK:STDOUT: %.loc4_42.2: type = converted %float.make_type.loc4_42, %.loc4_42.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc4_19.1: type = splice_block %.loc4_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%int_64.loc4_19) [template = f64] -// CHECK:STDOUT: %.loc4_19.2: type = value_of_initializer %float.make_type.loc4_19 [template = f64] -// CHECK:STDOUT: %.loc4_19.3: type = converted %float.make_type.loc4_19, %.loc4_19.2 [template = f64] +// CHECK:STDOUT: %.loc4_26.1: type = splice_block %.loc4_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_26: init type = call constants.%Float(%int_64.loc4_26) [template = f64] +// CHECK:STDOUT: %.loc4_26.2: type = value_of_initializer %float.make_type.loc4_26 [template = f64] +// CHECK:STDOUT: %.loc4_26.3: type = converted %float.make_type.loc4_26, %.loc4_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc4_27.1: type = splice_block %.loc4_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%int_64.loc4_27) [template = f64] -// CHECK:STDOUT: %.loc4_27.2: type = value_of_initializer %float.make_type.loc4_27 [template = f64] -// CHECK:STDOUT: %.loc4_27.3: type = converted %float.make_type.loc4_27, %.loc4_27.2 [template = f64] +// CHECK:STDOUT: %.loc4_34.1: type = splice_block %.loc4_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_34: init type = call constants.%Float(%int_64.loc4_34) [template = f64] +// CHECK:STDOUT: %.loc4_34.2: type = value_of_initializer %float.make_type.loc4_34 [template = f64] +// CHECK:STDOUT: %.loc4_34.3: type = converted %float.make_type.loc4_34, %.loc4_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 @@ -149,7 +149,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @Add(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.add"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Add.ref: %Add.type = name_ref Add, file.%Add.decl [template = constants.%Add] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -186,12 +186,12 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %BadReturnType: %BadReturnType.type = struct_value () [template] // CHECK:STDOUT: %JustRight.type: type = fn_type @JustRight [template] // CHECK:STDOUT: %JustRight: %JustRight.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template] -// CHECK:STDOUT: %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template] -// CHECK:STDOUT: %RuntimeCallTooMany: %RuntimeCallTooMany.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType.type: type = fn_type @RuntimeCallBadReturnType [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType: %RuntimeCallBadReturnType.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.type: type = fn_type @RuntimeCallIsValidTooFew [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew: %RuntimeCallIsValidTooFew.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.type: type = fn_type @RuntimeCallIsValidTooMany [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany: %RuntimeCallIsValidTooMany.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.type: type = fn_type @RuntimeCallIsValidBadReturnType [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType: %RuntimeCallIsValidBadReturnType.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -210,9 +210,9 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .TooMany = %TooMany.decl // CHECK:STDOUT: .BadReturnType = %BadReturnType.decl // CHECK:STDOUT: .JustRight = %JustRight.decl -// CHECK:STDOUT: .RuntimeCallTooFew = %RuntimeCallTooFew.decl -// CHECK:STDOUT: .RuntimeCallTooMany = %RuntimeCallTooMany.decl -// CHECK:STDOUT: .RuntimeCallBadReturnType = %RuntimeCallBadReturnType.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooFew = %RuntimeCallIsValidTooFew.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooMany = %RuntimeCallIsValidTooMany.decl +// CHECK:STDOUT: .RuntimeCallIsValidBadReturnType = %RuntimeCallIsValidBadReturnType.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %TooFew.decl: %TooFew.type = fn_decl @TooFew [template = constants.%TooFew] { @@ -338,28 +338,28 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooFew.decl: %RuntimeCallTooFew.type = fn_decl @RuntimeCallTooFew [template = constants.%RuntimeCallTooFew] { +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.decl: %RuntimeCallIsValidTooFew.type = fn_decl @RuntimeCallIsValidTooFew [template = constants.%RuntimeCallIsValidTooFew] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc20_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%int_64.loc20_33) [template = f64] -// CHECK:STDOUT: %.loc20_33.1: type = value_of_initializer %float.make_type.loc20_33 [template = f64] -// CHECK:STDOUT: %.loc20_33.2: type = converted %float.make_type.loc20_33, %.loc20_33.1 [template = f64] +// CHECK:STDOUT: %int_64.loc20_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_40: init type = call constants.%Float(%int_64.loc20_40) [template = f64] +// CHECK:STDOUT: %.loc20_40.1: type = value_of_initializer %float.make_type.loc20_40 [template = f64] +// CHECK:STDOUT: %.loc20_40.2: type = converted %float.make_type.loc20_40, %.loc20_40.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc20_25.1: type = splice_block %.loc20_25.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc20_25: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%int_64.loc20_25) [template = f64] -// CHECK:STDOUT: %.loc20_25.2: type = value_of_initializer %float.make_type.loc20_25 [template = f64] -// CHECK:STDOUT: %.loc20_25.3: type = converted %float.make_type.loc20_25, %.loc20_25.2 [template = f64] +// CHECK:STDOUT: %.loc20_32.1: type = splice_block %.loc20_32.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc20_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_32: init type = call constants.%Float(%int_64.loc20_32) [template = f64] +// CHECK:STDOUT: %.loc20_32.2: type = value_of_initializer %float.make_type.loc20_32 [template = f64] +// CHECK:STDOUT: %.loc20_32.3: type = converted %float.make_type.loc20_32, %.loc20_32.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooMany.decl: %RuntimeCallTooMany.type = fn_decl @RuntimeCallTooMany [template = constants.%RuntimeCallTooMany] { +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.decl: %RuntimeCallIsValidTooMany.type = fn_decl @RuntimeCallIsValidTooMany [template = constants.%RuntimeCallIsValidTooMany] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -369,38 +369,38 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param3 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc24_50: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%int_64.loc24_50) [template = f64] -// CHECK:STDOUT: %.loc24_50.1: type = value_of_initializer %float.make_type.loc24_50 [template = f64] -// CHECK:STDOUT: %.loc24_50.2: type = converted %float.make_type.loc24_50, %.loc24_50.1 [template = f64] +// CHECK:STDOUT: %int_64.loc24_57: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_57: init type = call constants.%Float(%int_64.loc24_57) [template = f64] +// CHECK:STDOUT: %.loc24_57.1: type = value_of_initializer %float.make_type.loc24_57 [template = f64] +// CHECK:STDOUT: %.loc24_57.2: type = converted %float.make_type.loc24_57, %.loc24_57.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc24_26.1: type = splice_block %.loc24_26.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%int_64.loc24_26) [template = f64] -// CHECK:STDOUT: %.loc24_26.2: type = value_of_initializer %float.make_type.loc24_26 [template = f64] -// CHECK:STDOUT: %.loc24_26.3: type = converted %float.make_type.loc24_26, %.loc24_26.2 [template = f64] +// CHECK:STDOUT: %.loc24_33.1: type = splice_block %.loc24_33.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_33: init type = call constants.%Float(%int_64.loc24_33) [template = f64] +// CHECK:STDOUT: %.loc24_33.2: type = value_of_initializer %float.make_type.loc24_33 [template = f64] +// CHECK:STDOUT: %.loc24_33.3: type = converted %float.make_type.loc24_33, %.loc24_33.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc24_34.1: type = splice_block %.loc24_34.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%int_64.loc24_34) [template = f64] -// CHECK:STDOUT: %.loc24_34.2: type = value_of_initializer %float.make_type.loc24_34 [template = f64] -// CHECK:STDOUT: %.loc24_34.3: type = converted %float.make_type.loc24_34, %.loc24_34.2 [template = f64] +// CHECK:STDOUT: %.loc24_41.1: type = splice_block %.loc24_41.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_41: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_41: init type = call constants.%Float(%int_64.loc24_41) [template = f64] +// CHECK:STDOUT: %.loc24_41.2: type = value_of_initializer %float.make_type.loc24_41 [template = f64] +// CHECK:STDOUT: %.loc24_41.3: type = converted %float.make_type.loc24_41, %.loc24_41.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %c.param: f64 = value_param runtime_param2 -// CHECK:STDOUT: %.loc24_42.1: type = splice_block %.loc24_42.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%int_64.loc24_42) [template = f64] -// CHECK:STDOUT: %.loc24_42.2: type = value_of_initializer %float.make_type.loc24_42 [template = f64] -// CHECK:STDOUT: %.loc24_42.3: type = converted %float.make_type.loc24_42, %.loc24_42.2 [template = f64] +// CHECK:STDOUT: %.loc24_49.1: type = splice_block %.loc24_49.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_49: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_49: init type = call constants.%Float(%int_64.loc24_49) [template = f64] +// CHECK:STDOUT: %.loc24_49.2: type = value_of_initializer %float.make_type.loc24_49 [template = f64] +// CHECK:STDOUT: %.loc24_49.3: type = converted %float.make_type.loc24_49, %.loc24_49.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %c: f64 = bind_name c, %c.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param3 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallBadReturnType.decl: %RuntimeCallBadReturnType.type = fn_decl @RuntimeCallBadReturnType [template = constants.%RuntimeCallBadReturnType] { +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.decl: %RuntimeCallIsValidBadReturnType.type = fn_decl @RuntimeCallIsValidBadReturnType [template = constants.%RuntimeCallIsValidBadReturnType] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -409,22 +409,22 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc28_48.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc28_48.2: type = converted %bool.make_type, %.loc28_48.1 [template = bool] +// CHECK:STDOUT: %.loc28_55.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc28_55.2: type = converted %bool.make_type, %.loc28_55.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc28_32.1: type = splice_block %.loc28_32.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%int_64.loc28_32) [template = f64] -// CHECK:STDOUT: %.loc28_32.2: type = value_of_initializer %float.make_type.loc28_32 [template = f64] -// CHECK:STDOUT: %.loc28_32.3: type = converted %float.make_type.loc28_32, %.loc28_32.2 [template = f64] +// CHECK:STDOUT: %.loc28_39.1: type = splice_block %.loc28_39.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_39: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_39: init type = call constants.%Float(%int_64.loc28_39) [template = f64] +// CHECK:STDOUT: %.loc28_39.2: type = value_of_initializer %float.make_type.loc28_39 [template = f64] +// CHECK:STDOUT: %.loc28_39.3: type = converted %float.make_type.loc28_39, %.loc28_39.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc28_40.1: type = splice_block %.loc28_40.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%int_64.loc28_40) [template = f64] -// CHECK:STDOUT: %.loc28_40.2: type = value_of_initializer %float.make_type.loc28_40 [template = f64] -// CHECK:STDOUT: %.loc28_40.3: type = converted %float.make_type.loc28_40, %.loc28_40.2 [template = f64] +// CHECK:STDOUT: %.loc28_47.1: type = splice_block %.loc28_47.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_47: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_47: init type = call constants.%Float(%int_64.loc28_47) [template = f64] +// CHECK:STDOUT: %.loc28_47.2: type = value_of_initializer %float.make_type.loc28_47 [template = f64] +// CHECK:STDOUT: %.loc28_47.3: type = converted %float.make_type.loc28_47, %.loc28_47.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -440,7 +440,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @JustRight(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.add"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooFew(%a.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooFew(%a.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooFew.ref: %TooFew.type = name_ref TooFew, file.%TooFew.decl [template = constants.%TooFew] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -450,7 +450,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc21_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooMany.ref: %TooMany.type = name_ref TooMany, file.%TooMany.decl [template = constants.%TooMany] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -462,7 +462,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc25_26.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValidBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, file.%BadReturnType.decl [template = constants.%BadReturnType] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/div.carbon b/toolchain/check/testdata/builtins/float/div.carbon index b0689dad6808d..791c9a610dd16 100644 --- a/toolchain/check/testdata/builtins/float/div.carbon +++ b/toolchain/check/testdata/builtins/float/div.carbon @@ -12,7 +12,7 @@ fn Div(a: f64, b: f64) -> f64 = "float.div"; -fn RuntimeCall(a: f64, b: f64) -> f64 { +fn RuntimeCallIsValid(a: f64, b: f64) -> f64 { return Div(a, b); } @@ -40,15 +40,15 @@ fn TooMany(a: f64, b: f64, c: f64) -> f64 = "float.div"; fn BadReturnType(a: f64, b: f64) -> bool = "float.div"; fn JustRight(a: f64, b: f64) -> f64 = "float.div"; -fn RuntimeCallTooFew(a: f64) -> f64 { +fn RuntimeCallIsValidTooFew(a: f64) -> f64 { return TooFew(a); } -fn RuntimeCallTooMany(a: f64, b: f64, c: f64) -> f64 { +fn RuntimeCallIsValidTooMany(a: f64, b: f64, c: f64) -> f64 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { +fn RuntimeCallIsValidBadReturnType(a: f64, b: f64) -> bool { return BadReturnType(a, b); } @@ -60,8 +60,8 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %Float: %Float.type = struct_value () [template] // CHECK:STDOUT: %Div.type: type = fn_type @Div [template] // CHECK:STDOUT: %Div: %Div.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: %float.1: f64 = float_literal 10 [template] // CHECK:STDOUT: %float.2: f64 = float_literal 2.5 [template] // CHECK:STDOUT: %float.3: f64 = float_literal 4 [template] @@ -83,7 +83,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Div = %Div.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: .a = %a // CHECK:STDOUT: .b = @__global_init.%b // CHECK:STDOUT: .c = @__global_init.%c @@ -120,7 +120,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -128,24 +128,24 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc4_35: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%int_64.loc4_35) [template = f64] -// CHECK:STDOUT: %.loc4_35.1: type = value_of_initializer %float.make_type.loc4_35 [template = f64] -// CHECK:STDOUT: %.loc4_35.2: type = converted %float.make_type.loc4_35, %.loc4_35.1 [template = f64] +// CHECK:STDOUT: %int_64.loc4_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_42: init type = call constants.%Float(%int_64.loc4_42) [template = f64] +// CHECK:STDOUT: %.loc4_42.1: type = value_of_initializer %float.make_type.loc4_42 [template = f64] +// CHECK:STDOUT: %.loc4_42.2: type = converted %float.make_type.loc4_42, %.loc4_42.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc4_19.1: type = splice_block %.loc4_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%int_64.loc4_19) [template = f64] -// CHECK:STDOUT: %.loc4_19.2: type = value_of_initializer %float.make_type.loc4_19 [template = f64] -// CHECK:STDOUT: %.loc4_19.3: type = converted %float.make_type.loc4_19, %.loc4_19.2 [template = f64] +// CHECK:STDOUT: %.loc4_26.1: type = splice_block %.loc4_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_26: init type = call constants.%Float(%int_64.loc4_26) [template = f64] +// CHECK:STDOUT: %.loc4_26.2: type = value_of_initializer %float.make_type.loc4_26 [template = f64] +// CHECK:STDOUT: %.loc4_26.3: type = converted %float.make_type.loc4_26, %.loc4_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc4_27.1: type = splice_block %.loc4_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%int_64.loc4_27) [template = f64] -// CHECK:STDOUT: %.loc4_27.2: type = value_of_initializer %float.make_type.loc4_27 [template = f64] -// CHECK:STDOUT: %.loc4_27.3: type = converted %float.make_type.loc4_27, %.loc4_27.2 [template = f64] +// CHECK:STDOUT: %.loc4_34.1: type = splice_block %.loc4_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_34: init type = call constants.%Float(%int_64.loc4_34) [template = f64] +// CHECK:STDOUT: %.loc4_34.2: type = value_of_initializer %float.make_type.loc4_34 [template = f64] +// CHECK:STDOUT: %.loc4_34.3: type = converted %float.make_type.loc4_34, %.loc4_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 @@ -157,7 +157,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @Div(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.div"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Div.ref: %Div.type = name_ref Div, file.%Div.decl [template = constants.%Div] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -208,12 +208,12 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %BadReturnType: %BadReturnType.type = struct_value () [template] // CHECK:STDOUT: %JustRight.type: type = fn_type @JustRight [template] // CHECK:STDOUT: %JustRight: %JustRight.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template] -// CHECK:STDOUT: %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template] -// CHECK:STDOUT: %RuntimeCallTooMany: %RuntimeCallTooMany.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType.type: type = fn_type @RuntimeCallBadReturnType [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType: %RuntimeCallBadReturnType.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.type: type = fn_type @RuntimeCallIsValidTooFew [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew: %RuntimeCallIsValidTooFew.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.type: type = fn_type @RuntimeCallIsValidTooMany [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany: %RuntimeCallIsValidTooMany.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.type: type = fn_type @RuntimeCallIsValidBadReturnType [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType: %RuntimeCallIsValidBadReturnType.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -232,9 +232,9 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .TooMany = %TooMany.decl // CHECK:STDOUT: .BadReturnType = %BadReturnType.decl // CHECK:STDOUT: .JustRight = %JustRight.decl -// CHECK:STDOUT: .RuntimeCallTooFew = %RuntimeCallTooFew.decl -// CHECK:STDOUT: .RuntimeCallTooMany = %RuntimeCallTooMany.decl -// CHECK:STDOUT: .RuntimeCallBadReturnType = %RuntimeCallBadReturnType.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooFew = %RuntimeCallIsValidTooFew.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooMany = %RuntimeCallIsValidTooMany.decl +// CHECK:STDOUT: .RuntimeCallIsValidBadReturnType = %RuntimeCallIsValidBadReturnType.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %TooFew.decl: %TooFew.type = fn_decl @TooFew [template = constants.%TooFew] { @@ -360,28 +360,28 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooFew.decl: %RuntimeCallTooFew.type = fn_decl @RuntimeCallTooFew [template = constants.%RuntimeCallTooFew] { +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.decl: %RuntimeCallIsValidTooFew.type = fn_decl @RuntimeCallIsValidTooFew [template = constants.%RuntimeCallIsValidTooFew] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc20_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%int_64.loc20_33) [template = f64] -// CHECK:STDOUT: %.loc20_33.1: type = value_of_initializer %float.make_type.loc20_33 [template = f64] -// CHECK:STDOUT: %.loc20_33.2: type = converted %float.make_type.loc20_33, %.loc20_33.1 [template = f64] +// CHECK:STDOUT: %int_64.loc20_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_40: init type = call constants.%Float(%int_64.loc20_40) [template = f64] +// CHECK:STDOUT: %.loc20_40.1: type = value_of_initializer %float.make_type.loc20_40 [template = f64] +// CHECK:STDOUT: %.loc20_40.2: type = converted %float.make_type.loc20_40, %.loc20_40.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc20_25.1: type = splice_block %.loc20_25.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc20_25: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%int_64.loc20_25) [template = f64] -// CHECK:STDOUT: %.loc20_25.2: type = value_of_initializer %float.make_type.loc20_25 [template = f64] -// CHECK:STDOUT: %.loc20_25.3: type = converted %float.make_type.loc20_25, %.loc20_25.2 [template = f64] +// CHECK:STDOUT: %.loc20_32.1: type = splice_block %.loc20_32.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc20_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_32: init type = call constants.%Float(%int_64.loc20_32) [template = f64] +// CHECK:STDOUT: %.loc20_32.2: type = value_of_initializer %float.make_type.loc20_32 [template = f64] +// CHECK:STDOUT: %.loc20_32.3: type = converted %float.make_type.loc20_32, %.loc20_32.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooMany.decl: %RuntimeCallTooMany.type = fn_decl @RuntimeCallTooMany [template = constants.%RuntimeCallTooMany] { +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.decl: %RuntimeCallIsValidTooMany.type = fn_decl @RuntimeCallIsValidTooMany [template = constants.%RuntimeCallIsValidTooMany] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -391,38 +391,38 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param3 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc24_50: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%int_64.loc24_50) [template = f64] -// CHECK:STDOUT: %.loc24_50.1: type = value_of_initializer %float.make_type.loc24_50 [template = f64] -// CHECK:STDOUT: %.loc24_50.2: type = converted %float.make_type.loc24_50, %.loc24_50.1 [template = f64] +// CHECK:STDOUT: %int_64.loc24_57: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_57: init type = call constants.%Float(%int_64.loc24_57) [template = f64] +// CHECK:STDOUT: %.loc24_57.1: type = value_of_initializer %float.make_type.loc24_57 [template = f64] +// CHECK:STDOUT: %.loc24_57.2: type = converted %float.make_type.loc24_57, %.loc24_57.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc24_26.1: type = splice_block %.loc24_26.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%int_64.loc24_26) [template = f64] -// CHECK:STDOUT: %.loc24_26.2: type = value_of_initializer %float.make_type.loc24_26 [template = f64] -// CHECK:STDOUT: %.loc24_26.3: type = converted %float.make_type.loc24_26, %.loc24_26.2 [template = f64] +// CHECK:STDOUT: %.loc24_33.1: type = splice_block %.loc24_33.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_33: init type = call constants.%Float(%int_64.loc24_33) [template = f64] +// CHECK:STDOUT: %.loc24_33.2: type = value_of_initializer %float.make_type.loc24_33 [template = f64] +// CHECK:STDOUT: %.loc24_33.3: type = converted %float.make_type.loc24_33, %.loc24_33.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc24_34.1: type = splice_block %.loc24_34.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%int_64.loc24_34) [template = f64] -// CHECK:STDOUT: %.loc24_34.2: type = value_of_initializer %float.make_type.loc24_34 [template = f64] -// CHECK:STDOUT: %.loc24_34.3: type = converted %float.make_type.loc24_34, %.loc24_34.2 [template = f64] +// CHECK:STDOUT: %.loc24_41.1: type = splice_block %.loc24_41.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_41: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_41: init type = call constants.%Float(%int_64.loc24_41) [template = f64] +// CHECK:STDOUT: %.loc24_41.2: type = value_of_initializer %float.make_type.loc24_41 [template = f64] +// CHECK:STDOUT: %.loc24_41.3: type = converted %float.make_type.loc24_41, %.loc24_41.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %c.param: f64 = value_param runtime_param2 -// CHECK:STDOUT: %.loc24_42.1: type = splice_block %.loc24_42.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%int_64.loc24_42) [template = f64] -// CHECK:STDOUT: %.loc24_42.2: type = value_of_initializer %float.make_type.loc24_42 [template = f64] -// CHECK:STDOUT: %.loc24_42.3: type = converted %float.make_type.loc24_42, %.loc24_42.2 [template = f64] +// CHECK:STDOUT: %.loc24_49.1: type = splice_block %.loc24_49.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_49: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_49: init type = call constants.%Float(%int_64.loc24_49) [template = f64] +// CHECK:STDOUT: %.loc24_49.2: type = value_of_initializer %float.make_type.loc24_49 [template = f64] +// CHECK:STDOUT: %.loc24_49.3: type = converted %float.make_type.loc24_49, %.loc24_49.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %c: f64 = bind_name c, %c.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param3 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallBadReturnType.decl: %RuntimeCallBadReturnType.type = fn_decl @RuntimeCallBadReturnType [template = constants.%RuntimeCallBadReturnType] { +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.decl: %RuntimeCallIsValidBadReturnType.type = fn_decl @RuntimeCallIsValidBadReturnType [template = constants.%RuntimeCallIsValidBadReturnType] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -431,22 +431,22 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc28_48.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc28_48.2: type = converted %bool.make_type, %.loc28_48.1 [template = bool] +// CHECK:STDOUT: %.loc28_55.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc28_55.2: type = converted %bool.make_type, %.loc28_55.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc28_32.1: type = splice_block %.loc28_32.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%int_64.loc28_32) [template = f64] -// CHECK:STDOUT: %.loc28_32.2: type = value_of_initializer %float.make_type.loc28_32 [template = f64] -// CHECK:STDOUT: %.loc28_32.3: type = converted %float.make_type.loc28_32, %.loc28_32.2 [template = f64] +// CHECK:STDOUT: %.loc28_39.1: type = splice_block %.loc28_39.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_39: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_39: init type = call constants.%Float(%int_64.loc28_39) [template = f64] +// CHECK:STDOUT: %.loc28_39.2: type = value_of_initializer %float.make_type.loc28_39 [template = f64] +// CHECK:STDOUT: %.loc28_39.3: type = converted %float.make_type.loc28_39, %.loc28_39.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc28_40.1: type = splice_block %.loc28_40.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%int_64.loc28_40) [template = f64] -// CHECK:STDOUT: %.loc28_40.2: type = value_of_initializer %float.make_type.loc28_40 [template = f64] -// CHECK:STDOUT: %.loc28_40.3: type = converted %float.make_type.loc28_40, %.loc28_40.2 [template = f64] +// CHECK:STDOUT: %.loc28_47.1: type = splice_block %.loc28_47.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_47: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_47: init type = call constants.%Float(%int_64.loc28_47) [template = f64] +// CHECK:STDOUT: %.loc28_47.2: type = value_of_initializer %float.make_type.loc28_47 [template = f64] +// CHECK:STDOUT: %.loc28_47.3: type = converted %float.make_type.loc28_47, %.loc28_47.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -462,7 +462,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @JustRight(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.div"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooFew(%a.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooFew(%a.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooFew.ref: %TooFew.type = name_ref TooFew, file.%TooFew.decl [template = constants.%TooFew] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -472,7 +472,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc21_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooMany.ref: %TooMany.type = name_ref TooMany, file.%TooMany.decl [template = constants.%TooMany] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -484,7 +484,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc25_26.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValidBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, file.%BadReturnType.decl [template = constants.%BadReturnType] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/eq.carbon b/toolchain/check/testdata/builtins/float/eq.carbon index be58640e98c5c..bc8ab7a3a0b03 100644 --- a/toolchain/check/testdata/builtins/float/eq.carbon +++ b/toolchain/check/testdata/builtins/float/eq.carbon @@ -20,7 +20,7 @@ fn F(true_: True, false_: False) { false_ as (if Eq(1.0, 2.0) then True else False); } -fn RuntimeCall(a: f64, b: f64) -> bool { +fn RuntimeCallIsValid(a: f64, b: f64) -> bool { return Eq(a, b); } @@ -53,8 +53,8 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq"; // CHECK:STDOUT: %true: bool = bool_literal true [template] // CHECK:STDOUT: %float.2: f64 = float_literal 2 [template] // CHECK:STDOUT: %false: bool = bool_literal false [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,7 +73,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq"; // CHECK:STDOUT: .True = %True.decl // CHECK:STDOUT: .False = %False.decl // CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Eq.decl: %Eq.type = fn_decl @Eq [template = constants.%Eq] { @@ -121,7 +121,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq"; // CHECK:STDOUT: %False.ref.loc7: type = name_ref False, file.%False.decl [template = constants.%False] // CHECK:STDOUT: %false_: %False = bind_name false_, %false_.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -130,22 +130,22 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq"; // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc12_35.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc12_35.2: type = converted %bool.make_type, %.loc12_35.1 [template = bool] +// CHECK:STDOUT: %.loc12_42.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc12_42.2: type = converted %bool.make_type, %.loc12_42.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc12_19.1: type = splice_block %.loc12_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc12_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc12_19: init type = call constants.%Float(%int_64.loc12_19) [template = f64] -// CHECK:STDOUT: %.loc12_19.2: type = value_of_initializer %float.make_type.loc12_19 [template = f64] -// CHECK:STDOUT: %.loc12_19.3: type = converted %float.make_type.loc12_19, %.loc12_19.2 [template = f64] +// CHECK:STDOUT: %.loc12_26.1: type = splice_block %.loc12_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc12_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc12_26: init type = call constants.%Float(%int_64.loc12_26) [template = f64] +// CHECK:STDOUT: %.loc12_26.2: type = value_of_initializer %float.make_type.loc12_26 [template = f64] +// CHECK:STDOUT: %.loc12_26.3: type = converted %float.make_type.loc12_26, %.loc12_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc12_27.1: type = splice_block %.loc12_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc12_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc12_27: init type = call constants.%Float(%int_64.loc12_27) [template = f64] -// CHECK:STDOUT: %.loc12_27.2: type = value_of_initializer %float.make_type.loc12_27 [template = f64] -// CHECK:STDOUT: %.loc12_27.3: type = converted %float.make_type.loc12_27, %.loc12_27.2 [template = f64] +// CHECK:STDOUT: %.loc12_34.1: type = splice_block %.loc12_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc12_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc12_34: init type = call constants.%Float(%int_64.loc12_34) [template = f64] +// CHECK:STDOUT: %.loc12_34.2: type = value_of_initializer %float.make_type.loc12_34 [template = f64] +// CHECK:STDOUT: %.loc12_34.3: type = converted %float.make_type.loc12_34, %.loc12_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -214,7 +214,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq"; // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Eq.ref: %Eq.type = name_ref Eq, file.%Eq.decl [template = constants.%Eq] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/greater.carbon b/toolchain/check/testdata/builtins/float/greater.carbon index 320082ce15665..c1eb849504c6c 100644 --- a/toolchain/check/testdata/builtins/float/greater.carbon +++ b/toolchain/check/testdata/builtins/float/greater.carbon @@ -24,7 +24,7 @@ fn F(true_: True, false_: False) { true_ as (if Greater(0.0, Negate(1.0)) then True else False); } -fn RuntimeCall(a: f64, b: f64) -> bool { +fn RuntimeCallIsValid(a: f64, b: f64) -> bool { return Greater(a, b); } @@ -52,8 +52,8 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %float.3: f64 = float_literal 0 [template] // CHECK:STDOUT: %true: bool = bool_literal true [template] // CHECK:STDOUT: %float.4: f64 = float_literal -1 [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,7 +73,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: .True = %True.decl // CHECK:STDOUT: .False = %False.decl // CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Greater.decl: %Greater.type = fn_decl @Greater [template = constants.%Greater] { @@ -142,7 +142,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %False.ref.loc8: type = name_ref False, file.%False.decl [template = constants.%False] // CHECK:STDOUT: %false_: %False = bind_name false_, %false_.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -151,22 +151,22 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc16_35.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc16_35.2: type = converted %bool.make_type, %.loc16_35.1 [template = bool] +// CHECK:STDOUT: %.loc16_42.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc16_42.2: type = converted %bool.make_type, %.loc16_42.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc16_19.1: type = splice_block %.loc16_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%int_64.loc16_19) [template = f64] -// CHECK:STDOUT: %.loc16_19.2: type = value_of_initializer %float.make_type.loc16_19 [template = f64] -// CHECK:STDOUT: %.loc16_19.3: type = converted %float.make_type.loc16_19, %.loc16_19.2 [template = f64] +// CHECK:STDOUT: %.loc16_26.1: type = splice_block %.loc16_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_26: init type = call constants.%Float(%int_64.loc16_26) [template = f64] +// CHECK:STDOUT: %.loc16_26.2: type = value_of_initializer %float.make_type.loc16_26 [template = f64] +// CHECK:STDOUT: %.loc16_26.3: type = converted %float.make_type.loc16_26, %.loc16_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc16_27.1: type = splice_block %.loc16_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%int_64.loc16_27) [template = f64] -// CHECK:STDOUT: %.loc16_27.2: type = value_of_initializer %float.make_type.loc16_27 [template = f64] -// CHECK:STDOUT: %.loc16_27.3: type = converted %float.make_type.loc16_27, %.loc16_27.2 [template = f64] +// CHECK:STDOUT: %.loc16_34.1: type = splice_block %.loc16_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_34: init type = call constants.%Float(%int_64.loc16_34) [template = f64] +// CHECK:STDOUT: %.loc16_34.2: type = value_of_initializer %float.make_type.loc16_34 [template = f64] +// CHECK:STDOUT: %.loc16_34.3: type = converted %float.make_type.loc16_34, %.loc16_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -302,7 +302,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Greater.ref: %Greater.type = name_ref Greater, file.%Greater.decl [template = constants.%Greater] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/greater_eq.carbon b/toolchain/check/testdata/builtins/float/greater_eq.carbon index 9217e14d2669a..948627bfdb417 100644 --- a/toolchain/check/testdata/builtins/float/greater_eq.carbon +++ b/toolchain/check/testdata/builtins/float/greater_eq.carbon @@ -24,7 +24,7 @@ fn F(true_: True, false_: False) { true_ as (if GreaterEq(0.0, Negate(1.0)) then True else False); } -fn RuntimeCall(a: f64, b: f64) -> bool { +fn RuntimeCallIsValid(a: f64, b: f64) -> bool { return GreaterEq(a, b); } @@ -52,8 +52,8 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %true: bool = bool_literal true [template] // CHECK:STDOUT: %float.3: f64 = float_literal 0 [template] // CHECK:STDOUT: %float.4: f64 = float_literal -1 [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,7 +73,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: .True = %True.decl // CHECK:STDOUT: .False = %False.decl // CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %GreaterEq.decl: %GreaterEq.type = fn_decl @GreaterEq [template = constants.%GreaterEq] { @@ -142,7 +142,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %False.ref.loc8: type = name_ref False, file.%False.decl [template = constants.%False] // CHECK:STDOUT: %false_: %False = bind_name false_, %false_.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -151,22 +151,22 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc16_35.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc16_35.2: type = converted %bool.make_type, %.loc16_35.1 [template = bool] +// CHECK:STDOUT: %.loc16_42.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc16_42.2: type = converted %bool.make_type, %.loc16_42.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc16_19.1: type = splice_block %.loc16_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%int_64.loc16_19) [template = f64] -// CHECK:STDOUT: %.loc16_19.2: type = value_of_initializer %float.make_type.loc16_19 [template = f64] -// CHECK:STDOUT: %.loc16_19.3: type = converted %float.make_type.loc16_19, %.loc16_19.2 [template = f64] +// CHECK:STDOUT: %.loc16_26.1: type = splice_block %.loc16_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_26: init type = call constants.%Float(%int_64.loc16_26) [template = f64] +// CHECK:STDOUT: %.loc16_26.2: type = value_of_initializer %float.make_type.loc16_26 [template = f64] +// CHECK:STDOUT: %.loc16_26.3: type = converted %float.make_type.loc16_26, %.loc16_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc16_27.1: type = splice_block %.loc16_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%int_64.loc16_27) [template = f64] -// CHECK:STDOUT: %.loc16_27.2: type = value_of_initializer %float.make_type.loc16_27 [template = f64] -// CHECK:STDOUT: %.loc16_27.3: type = converted %float.make_type.loc16_27, %.loc16_27.2 [template = f64] +// CHECK:STDOUT: %.loc16_34.1: type = splice_block %.loc16_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_34: init type = call constants.%Float(%int_64.loc16_34) [template = f64] +// CHECK:STDOUT: %.loc16_34.2: type = value_of_initializer %float.make_type.loc16_34 [template = f64] +// CHECK:STDOUT: %.loc16_34.3: type = converted %float.make_type.loc16_34, %.loc16_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -302,7 +302,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %GreaterEq.ref: %GreaterEq.type = name_ref GreaterEq, file.%GreaterEq.decl [template = constants.%GreaterEq] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/less.carbon b/toolchain/check/testdata/builtins/float/less.carbon index 4c01a6cca77ae..413596f128107 100644 --- a/toolchain/check/testdata/builtins/float/less.carbon +++ b/toolchain/check/testdata/builtins/float/less.carbon @@ -24,7 +24,7 @@ fn F(true_: True, false_: False) { false_ as (if Less(0.0, Negate(1.0)) then True else False); } -fn RuntimeCall(a: f64, b: f64) -> bool { +fn RuntimeCallIsValid(a: f64, b: f64) -> bool { return Less(a, b); } @@ -52,8 +52,8 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %false: bool = bool_literal false [template] // CHECK:STDOUT: %float.3: f64 = float_literal 0 [template] // CHECK:STDOUT: %float.4: f64 = float_literal -1 [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,7 +73,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: .True = %True.decl // CHECK:STDOUT: .False = %False.decl // CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Less.decl: %Less.type = fn_decl @Less [template = constants.%Less] { @@ -142,7 +142,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %False.ref.loc8: type = name_ref False, file.%False.decl [template = constants.%False] // CHECK:STDOUT: %false_: %False = bind_name false_, %false_.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -151,22 +151,22 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc16_35.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc16_35.2: type = converted %bool.make_type, %.loc16_35.1 [template = bool] +// CHECK:STDOUT: %.loc16_42.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc16_42.2: type = converted %bool.make_type, %.loc16_42.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc16_19.1: type = splice_block %.loc16_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%int_64.loc16_19) [template = f64] -// CHECK:STDOUT: %.loc16_19.2: type = value_of_initializer %float.make_type.loc16_19 [template = f64] -// CHECK:STDOUT: %.loc16_19.3: type = converted %float.make_type.loc16_19, %.loc16_19.2 [template = f64] +// CHECK:STDOUT: %.loc16_26.1: type = splice_block %.loc16_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_26: init type = call constants.%Float(%int_64.loc16_26) [template = f64] +// CHECK:STDOUT: %.loc16_26.2: type = value_of_initializer %float.make_type.loc16_26 [template = f64] +// CHECK:STDOUT: %.loc16_26.3: type = converted %float.make_type.loc16_26, %.loc16_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc16_27.1: type = splice_block %.loc16_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%int_64.loc16_27) [template = f64] -// CHECK:STDOUT: %.loc16_27.2: type = value_of_initializer %float.make_type.loc16_27 [template = f64] -// CHECK:STDOUT: %.loc16_27.3: type = converted %float.make_type.loc16_27, %.loc16_27.2 [template = f64] +// CHECK:STDOUT: %.loc16_34.1: type = splice_block %.loc16_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_34: init type = call constants.%Float(%int_64.loc16_34) [template = f64] +// CHECK:STDOUT: %.loc16_34.2: type = value_of_initializer %float.make_type.loc16_34 [template = f64] +// CHECK:STDOUT: %.loc16_34.3: type = converted %float.make_type.loc16_34, %.loc16_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -302,7 +302,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Less.ref: %Less.type = name_ref Less, file.%Less.decl [template = constants.%Less] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/less_eq.carbon b/toolchain/check/testdata/builtins/float/less_eq.carbon index bfc6829dfc7b6..fbfa262c3da8c 100644 --- a/toolchain/check/testdata/builtins/float/less_eq.carbon +++ b/toolchain/check/testdata/builtins/float/less_eq.carbon @@ -24,7 +24,7 @@ fn F(true_: True, false_: False) { false_ as (if LessEq(0.0, Negate(1.0)) then True else False); } -fn RuntimeCall(a: f64, b: f64) -> bool { +fn RuntimeCallIsValid(a: f64, b: f64) -> bool { return LessEq(a, b); } @@ -52,8 +52,8 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %float.3: f64 = float_literal 0 [template] // CHECK:STDOUT: %false: bool = bool_literal false [template] // CHECK:STDOUT: %float.4: f64 = float_literal -1 [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,7 +73,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: .True = %True.decl // CHECK:STDOUT: .False = %False.decl // CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %LessEq.decl: %LessEq.type = fn_decl @LessEq [template = constants.%LessEq] { @@ -142,7 +142,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %False.ref.loc8: type = name_ref False, file.%False.decl [template = constants.%False] // CHECK:STDOUT: %false_: %False = bind_name false_, %false_.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -151,22 +151,22 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc16_35.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc16_35.2: type = converted %bool.make_type, %.loc16_35.1 [template = bool] +// CHECK:STDOUT: %.loc16_42.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc16_42.2: type = converted %bool.make_type, %.loc16_42.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc16_19.1: type = splice_block %.loc16_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%int_64.loc16_19) [template = f64] -// CHECK:STDOUT: %.loc16_19.2: type = value_of_initializer %float.make_type.loc16_19 [template = f64] -// CHECK:STDOUT: %.loc16_19.3: type = converted %float.make_type.loc16_19, %.loc16_19.2 [template = f64] +// CHECK:STDOUT: %.loc16_26.1: type = splice_block %.loc16_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_26: init type = call constants.%Float(%int_64.loc16_26) [template = f64] +// CHECK:STDOUT: %.loc16_26.2: type = value_of_initializer %float.make_type.loc16_26 [template = f64] +// CHECK:STDOUT: %.loc16_26.3: type = converted %float.make_type.loc16_26, %.loc16_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc16_27.1: type = splice_block %.loc16_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc16_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%int_64.loc16_27) [template = f64] -// CHECK:STDOUT: %.loc16_27.2: type = value_of_initializer %float.make_type.loc16_27 [template = f64] -// CHECK:STDOUT: %.loc16_27.3: type = converted %float.make_type.loc16_27, %.loc16_27.2 [template = f64] +// CHECK:STDOUT: %.loc16_34.1: type = splice_block %.loc16_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc16_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc16_34: init type = call constants.%Float(%int_64.loc16_34) [template = f64] +// CHECK:STDOUT: %.loc16_34.2: type = value_of_initializer %float.make_type.loc16_34 [template = f64] +// CHECK:STDOUT: %.loc16_34.3: type = converted %float.make_type.loc16_34, %.loc16_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -302,7 +302,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool { // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %LessEq.ref: %LessEq.type = name_ref LessEq, file.%LessEq.decl [template = constants.%LessEq] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/mul.carbon b/toolchain/check/testdata/builtins/float/mul.carbon index 03dc958966f7c..d1a42c514827c 100644 --- a/toolchain/check/testdata/builtins/float/mul.carbon +++ b/toolchain/check/testdata/builtins/float/mul.carbon @@ -12,7 +12,7 @@ fn Mul(a: f64, b: f64) -> f64 = "float.mul"; -fn RuntimeCall(a: f64, b: f64) -> f64 { +fn RuntimeCallIsValid(a: f64, b: f64) -> f64 { return Mul(a, b); } @@ -38,15 +38,15 @@ fn TooMany(a: f64, b: f64, c: f64) -> f64 = "float.mul"; fn BadReturnType(a: f64, b: f64) -> bool = "float.mul"; fn JustRight(a: f64, b: f64) -> f64 = "float.mul"; -fn RuntimeCallTooFew(a: f64) -> f64 { +fn RuntimeCallIsValidTooFew(a: f64) -> f64 { return TooFew(a); } -fn RuntimeCallTooMany(a: f64, b: f64, c: f64) -> f64 { +fn RuntimeCallIsValidTooMany(a: f64, b: f64, c: f64) -> f64 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { +fn RuntimeCallIsValidBadReturnType(a: f64, b: f64) -> bool { return BadReturnType(a, b); } @@ -58,8 +58,8 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %Float: %Float.type = struct_value () [template] // CHECK:STDOUT: %Mul.type: type = fn_type @Mul [template] // CHECK:STDOUT: %Mul: %Mul.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: %float.1: f64 = float_literal 2 [template] // CHECK:STDOUT: %float.2: f64 = float_literal 0.5 [template] // CHECK:STDOUT: %float.3: f64 = float_literal 1 [template] @@ -77,7 +77,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Mul = %Mul.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: .x = %x // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core @@ -112,7 +112,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -120,24 +120,24 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc4_35: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%int_64.loc4_35) [template = f64] -// CHECK:STDOUT: %.loc4_35.1: type = value_of_initializer %float.make_type.loc4_35 [template = f64] -// CHECK:STDOUT: %.loc4_35.2: type = converted %float.make_type.loc4_35, %.loc4_35.1 [template = f64] +// CHECK:STDOUT: %int_64.loc4_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_42: init type = call constants.%Float(%int_64.loc4_42) [template = f64] +// CHECK:STDOUT: %.loc4_42.1: type = value_of_initializer %float.make_type.loc4_42 [template = f64] +// CHECK:STDOUT: %.loc4_42.2: type = converted %float.make_type.loc4_42, %.loc4_42.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc4_19.1: type = splice_block %.loc4_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%int_64.loc4_19) [template = f64] -// CHECK:STDOUT: %.loc4_19.2: type = value_of_initializer %float.make_type.loc4_19 [template = f64] -// CHECK:STDOUT: %.loc4_19.3: type = converted %float.make_type.loc4_19, %.loc4_19.2 [template = f64] +// CHECK:STDOUT: %.loc4_26.1: type = splice_block %.loc4_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_26: init type = call constants.%Float(%int_64.loc4_26) [template = f64] +// CHECK:STDOUT: %.loc4_26.2: type = value_of_initializer %float.make_type.loc4_26 [template = f64] +// CHECK:STDOUT: %.loc4_26.3: type = converted %float.make_type.loc4_26, %.loc4_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc4_27.1: type = splice_block %.loc4_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%int_64.loc4_27) [template = f64] -// CHECK:STDOUT: %.loc4_27.2: type = value_of_initializer %float.make_type.loc4_27 [template = f64] -// CHECK:STDOUT: %.loc4_27.3: type = converted %float.make_type.loc4_27, %.loc4_27.2 [template = f64] +// CHECK:STDOUT: %.loc4_34.1: type = splice_block %.loc4_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_34: init type = call constants.%Float(%int_64.loc4_34) [template = f64] +// CHECK:STDOUT: %.loc4_34.2: type = value_of_initializer %float.make_type.loc4_34 [template = f64] +// CHECK:STDOUT: %.loc4_34.3: type = converted %float.make_type.loc4_34, %.loc4_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 @@ -149,7 +149,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @Mul(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.mul"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Mul.ref: %Mul.type = name_ref Mul, file.%Mul.decl [template = constants.%Mul] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -186,12 +186,12 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %BadReturnType: %BadReturnType.type = struct_value () [template] // CHECK:STDOUT: %JustRight.type: type = fn_type @JustRight [template] // CHECK:STDOUT: %JustRight: %JustRight.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template] -// CHECK:STDOUT: %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template] -// CHECK:STDOUT: %RuntimeCallTooMany: %RuntimeCallTooMany.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType.type: type = fn_type @RuntimeCallBadReturnType [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType: %RuntimeCallBadReturnType.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.type: type = fn_type @RuntimeCallIsValidTooFew [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew: %RuntimeCallIsValidTooFew.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.type: type = fn_type @RuntimeCallIsValidTooMany [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany: %RuntimeCallIsValidTooMany.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.type: type = fn_type @RuntimeCallIsValidBadReturnType [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType: %RuntimeCallIsValidBadReturnType.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -210,9 +210,9 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .TooMany = %TooMany.decl // CHECK:STDOUT: .BadReturnType = %BadReturnType.decl // CHECK:STDOUT: .JustRight = %JustRight.decl -// CHECK:STDOUT: .RuntimeCallTooFew = %RuntimeCallTooFew.decl -// CHECK:STDOUT: .RuntimeCallTooMany = %RuntimeCallTooMany.decl -// CHECK:STDOUT: .RuntimeCallBadReturnType = %RuntimeCallBadReturnType.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooFew = %RuntimeCallIsValidTooFew.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooMany = %RuntimeCallIsValidTooMany.decl +// CHECK:STDOUT: .RuntimeCallIsValidBadReturnType = %RuntimeCallIsValidBadReturnType.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %TooFew.decl: %TooFew.type = fn_decl @TooFew [template = constants.%TooFew] { @@ -338,28 +338,28 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooFew.decl: %RuntimeCallTooFew.type = fn_decl @RuntimeCallTooFew [template = constants.%RuntimeCallTooFew] { +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.decl: %RuntimeCallIsValidTooFew.type = fn_decl @RuntimeCallIsValidTooFew [template = constants.%RuntimeCallIsValidTooFew] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc20_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%int_64.loc20_33) [template = f64] -// CHECK:STDOUT: %.loc20_33.1: type = value_of_initializer %float.make_type.loc20_33 [template = f64] -// CHECK:STDOUT: %.loc20_33.2: type = converted %float.make_type.loc20_33, %.loc20_33.1 [template = f64] +// CHECK:STDOUT: %int_64.loc20_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_40: init type = call constants.%Float(%int_64.loc20_40) [template = f64] +// CHECK:STDOUT: %.loc20_40.1: type = value_of_initializer %float.make_type.loc20_40 [template = f64] +// CHECK:STDOUT: %.loc20_40.2: type = converted %float.make_type.loc20_40, %.loc20_40.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc20_25.1: type = splice_block %.loc20_25.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc20_25: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%int_64.loc20_25) [template = f64] -// CHECK:STDOUT: %.loc20_25.2: type = value_of_initializer %float.make_type.loc20_25 [template = f64] -// CHECK:STDOUT: %.loc20_25.3: type = converted %float.make_type.loc20_25, %.loc20_25.2 [template = f64] +// CHECK:STDOUT: %.loc20_32.1: type = splice_block %.loc20_32.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc20_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_32: init type = call constants.%Float(%int_64.loc20_32) [template = f64] +// CHECK:STDOUT: %.loc20_32.2: type = value_of_initializer %float.make_type.loc20_32 [template = f64] +// CHECK:STDOUT: %.loc20_32.3: type = converted %float.make_type.loc20_32, %.loc20_32.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooMany.decl: %RuntimeCallTooMany.type = fn_decl @RuntimeCallTooMany [template = constants.%RuntimeCallTooMany] { +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.decl: %RuntimeCallIsValidTooMany.type = fn_decl @RuntimeCallIsValidTooMany [template = constants.%RuntimeCallIsValidTooMany] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -369,38 +369,38 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param3 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc24_50: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%int_64.loc24_50) [template = f64] -// CHECK:STDOUT: %.loc24_50.1: type = value_of_initializer %float.make_type.loc24_50 [template = f64] -// CHECK:STDOUT: %.loc24_50.2: type = converted %float.make_type.loc24_50, %.loc24_50.1 [template = f64] +// CHECK:STDOUT: %int_64.loc24_57: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_57: init type = call constants.%Float(%int_64.loc24_57) [template = f64] +// CHECK:STDOUT: %.loc24_57.1: type = value_of_initializer %float.make_type.loc24_57 [template = f64] +// CHECK:STDOUT: %.loc24_57.2: type = converted %float.make_type.loc24_57, %.loc24_57.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc24_26.1: type = splice_block %.loc24_26.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%int_64.loc24_26) [template = f64] -// CHECK:STDOUT: %.loc24_26.2: type = value_of_initializer %float.make_type.loc24_26 [template = f64] -// CHECK:STDOUT: %.loc24_26.3: type = converted %float.make_type.loc24_26, %.loc24_26.2 [template = f64] +// CHECK:STDOUT: %.loc24_33.1: type = splice_block %.loc24_33.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_33: init type = call constants.%Float(%int_64.loc24_33) [template = f64] +// CHECK:STDOUT: %.loc24_33.2: type = value_of_initializer %float.make_type.loc24_33 [template = f64] +// CHECK:STDOUT: %.loc24_33.3: type = converted %float.make_type.loc24_33, %.loc24_33.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc24_34.1: type = splice_block %.loc24_34.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%int_64.loc24_34) [template = f64] -// CHECK:STDOUT: %.loc24_34.2: type = value_of_initializer %float.make_type.loc24_34 [template = f64] -// CHECK:STDOUT: %.loc24_34.3: type = converted %float.make_type.loc24_34, %.loc24_34.2 [template = f64] +// CHECK:STDOUT: %.loc24_41.1: type = splice_block %.loc24_41.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_41: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_41: init type = call constants.%Float(%int_64.loc24_41) [template = f64] +// CHECK:STDOUT: %.loc24_41.2: type = value_of_initializer %float.make_type.loc24_41 [template = f64] +// CHECK:STDOUT: %.loc24_41.3: type = converted %float.make_type.loc24_41, %.loc24_41.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %c.param: f64 = value_param runtime_param2 -// CHECK:STDOUT: %.loc24_42.1: type = splice_block %.loc24_42.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%int_64.loc24_42) [template = f64] -// CHECK:STDOUT: %.loc24_42.2: type = value_of_initializer %float.make_type.loc24_42 [template = f64] -// CHECK:STDOUT: %.loc24_42.3: type = converted %float.make_type.loc24_42, %.loc24_42.2 [template = f64] +// CHECK:STDOUT: %.loc24_49.1: type = splice_block %.loc24_49.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_49: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_49: init type = call constants.%Float(%int_64.loc24_49) [template = f64] +// CHECK:STDOUT: %.loc24_49.2: type = value_of_initializer %float.make_type.loc24_49 [template = f64] +// CHECK:STDOUT: %.loc24_49.3: type = converted %float.make_type.loc24_49, %.loc24_49.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %c: f64 = bind_name c, %c.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param3 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallBadReturnType.decl: %RuntimeCallBadReturnType.type = fn_decl @RuntimeCallBadReturnType [template = constants.%RuntimeCallBadReturnType] { +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.decl: %RuntimeCallIsValidBadReturnType.type = fn_decl @RuntimeCallIsValidBadReturnType [template = constants.%RuntimeCallIsValidBadReturnType] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -409,22 +409,22 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc28_48.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc28_48.2: type = converted %bool.make_type, %.loc28_48.1 [template = bool] +// CHECK:STDOUT: %.loc28_55.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc28_55.2: type = converted %bool.make_type, %.loc28_55.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc28_32.1: type = splice_block %.loc28_32.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%int_64.loc28_32) [template = f64] -// CHECK:STDOUT: %.loc28_32.2: type = value_of_initializer %float.make_type.loc28_32 [template = f64] -// CHECK:STDOUT: %.loc28_32.3: type = converted %float.make_type.loc28_32, %.loc28_32.2 [template = f64] +// CHECK:STDOUT: %.loc28_39.1: type = splice_block %.loc28_39.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_39: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_39: init type = call constants.%Float(%int_64.loc28_39) [template = f64] +// CHECK:STDOUT: %.loc28_39.2: type = value_of_initializer %float.make_type.loc28_39 [template = f64] +// CHECK:STDOUT: %.loc28_39.3: type = converted %float.make_type.loc28_39, %.loc28_39.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc28_40.1: type = splice_block %.loc28_40.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%int_64.loc28_40) [template = f64] -// CHECK:STDOUT: %.loc28_40.2: type = value_of_initializer %float.make_type.loc28_40 [template = f64] -// CHECK:STDOUT: %.loc28_40.3: type = converted %float.make_type.loc28_40, %.loc28_40.2 [template = f64] +// CHECK:STDOUT: %.loc28_47.1: type = splice_block %.loc28_47.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_47: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_47: init type = call constants.%Float(%int_64.loc28_47) [template = f64] +// CHECK:STDOUT: %.loc28_47.2: type = value_of_initializer %float.make_type.loc28_47 [template = f64] +// CHECK:STDOUT: %.loc28_47.3: type = converted %float.make_type.loc28_47, %.loc28_47.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -440,7 +440,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @JustRight(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.mul"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooFew(%a.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooFew(%a.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooFew.ref: %TooFew.type = name_ref TooFew, file.%TooFew.decl [template = constants.%TooFew] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -450,7 +450,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc21_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooMany.ref: %TooMany.type = name_ref TooMany, file.%TooMany.decl [template = constants.%TooMany] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -462,7 +462,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc25_26.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValidBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, file.%BadReturnType.decl [template = constants.%BadReturnType] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/negate.carbon b/toolchain/check/testdata/builtins/float/negate.carbon index 65db87190d176..3d48c413aacce 100644 --- a/toolchain/check/testdata/builtins/float/negate.carbon +++ b/toolchain/check/testdata/builtins/float/negate.carbon @@ -12,7 +12,7 @@ fn Negate(a: f64) -> f64 = "float.negate"; -fn RuntimeCall(a: f64, b: f64) -> f64 { +fn RuntimeCallIsValid(a: f64, b: f64) -> f64 { return Negate(a); } @@ -39,7 +39,7 @@ fn TooMany(a: f64, b: f64) -> f64 = "float.negate"; fn BadReturnType(a: f64) -> bool = "float.negate"; fn JustRight(a: f64) -> f64 = "float.negate"; -fn RuntimeCallTooFew(a: f64) -> f64 { +fn RuntimeCallIsValidTooFew(a: f64) -> f64 { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 1 argument passed to function expecting 0 arguments [CallArgCountMismatch] // CHECK:STDERR: return TooFew(a); // CHECK:STDERR: ^~~~~~~~~ @@ -50,7 +50,7 @@ fn RuntimeCallTooFew(a: f64) -> f64 { return TooFew(a); } -fn RuntimeCallTooMany(a: f64, b: f64, c: f64) -> f64 { +fn RuntimeCallIsValidTooMany(a: f64, b: f64, c: f64) -> f64 { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 3 arguments passed to function expecting 2 arguments [CallArgCountMismatch] // CHECK:STDERR: return TooMany(a, b, c); // CHECK:STDERR: ^~~~~~~~~~~~~~~~ @@ -61,7 +61,7 @@ fn RuntimeCallTooMany(a: f64, b: f64, c: f64) -> f64 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { +fn RuntimeCallIsValidBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+6]]:10: error: 2 arguments passed to function expecting 1 argument [CallArgCountMismatch] // CHECK:STDERR: return BadReturnType(a, b); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~ @@ -79,8 +79,8 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %Float: %Float.type = struct_value () [template] // CHECK:STDOUT: %Negate.type: type = fn_type @Negate [template] // CHECK:STDOUT: %Negate: %Negate.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: %float.1: f64 = float_literal 1.5 [template] // CHECK:STDOUT: %float.2: f64 = float_literal -1.5 [template] // CHECK:STDOUT: } @@ -97,7 +97,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Negate = %Negate.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: .a = @__global_init.%a // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core @@ -122,7 +122,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -130,24 +130,24 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc4_35: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%int_64.loc4_35) [template = f64] -// CHECK:STDOUT: %.loc4_35.1: type = value_of_initializer %float.make_type.loc4_35 [template = f64] -// CHECK:STDOUT: %.loc4_35.2: type = converted %float.make_type.loc4_35, %.loc4_35.1 [template = f64] +// CHECK:STDOUT: %int_64.loc4_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_42: init type = call constants.%Float(%int_64.loc4_42) [template = f64] +// CHECK:STDOUT: %.loc4_42.1: type = value_of_initializer %float.make_type.loc4_42 [template = f64] +// CHECK:STDOUT: %.loc4_42.2: type = converted %float.make_type.loc4_42, %.loc4_42.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc4_19.1: type = splice_block %.loc4_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%int_64.loc4_19) [template = f64] -// CHECK:STDOUT: %.loc4_19.2: type = value_of_initializer %float.make_type.loc4_19 [template = f64] -// CHECK:STDOUT: %.loc4_19.3: type = converted %float.make_type.loc4_19, %.loc4_19.2 [template = f64] +// CHECK:STDOUT: %.loc4_26.1: type = splice_block %.loc4_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_26: init type = call constants.%Float(%int_64.loc4_26) [template = f64] +// CHECK:STDOUT: %.loc4_26.2: type = value_of_initializer %float.make_type.loc4_26 [template = f64] +// CHECK:STDOUT: %.loc4_26.3: type = converted %float.make_type.loc4_26, %.loc4_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc4_27.1: type = splice_block %.loc4_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%int_64.loc4_27) [template = f64] -// CHECK:STDOUT: %.loc4_27.2: type = value_of_initializer %float.make_type.loc4_27 [template = f64] -// CHECK:STDOUT: %.loc4_27.3: type = converted %float.make_type.loc4_27, %.loc4_27.2 [template = f64] +// CHECK:STDOUT: %.loc4_34.1: type = splice_block %.loc4_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_34: init type = call constants.%Float(%int_64.loc4_34) [template = f64] +// CHECK:STDOUT: %.loc4_34.2: type = value_of_initializer %float.make_type.loc4_34 [template = f64] +// CHECK:STDOUT: %.loc4_34.3: type = converted %float.make_type.loc4_34, %.loc4_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 @@ -157,7 +157,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @Negate(%a.param_patt: f64) -> f64 = "float.negate"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Negate.ref: %Negate.type = name_ref Negate, file.%Negate.decl [template = constants.%Negate] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -194,12 +194,12 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %BadReturnType: %BadReturnType.type = struct_value () [template] // CHECK:STDOUT: %JustRight.type: type = fn_type @JustRight [template] // CHECK:STDOUT: %JustRight: %JustRight.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template] -// CHECK:STDOUT: %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template] -// CHECK:STDOUT: %RuntimeCallTooMany: %RuntimeCallTooMany.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType.type: type = fn_type @RuntimeCallBadReturnType [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType: %RuntimeCallBadReturnType.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.type: type = fn_type @RuntimeCallIsValidTooFew [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew: %RuntimeCallIsValidTooFew.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.type: type = fn_type @RuntimeCallIsValidTooMany [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany: %RuntimeCallIsValidTooMany.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.type: type = fn_type @RuntimeCallIsValidBadReturnType [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType: %RuntimeCallIsValidBadReturnType.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -218,9 +218,9 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .TooMany = %TooMany.decl // CHECK:STDOUT: .BadReturnType = %BadReturnType.decl // CHECK:STDOUT: .JustRight = %JustRight.decl -// CHECK:STDOUT: .RuntimeCallTooFew = %RuntimeCallTooFew.decl -// CHECK:STDOUT: .RuntimeCallTooMany = %RuntimeCallTooMany.decl -// CHECK:STDOUT: .RuntimeCallBadReturnType = %RuntimeCallBadReturnType.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooFew = %RuntimeCallIsValidTooFew.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooMany = %RuntimeCallIsValidTooMany.decl +// CHECK:STDOUT: .RuntimeCallIsValidBadReturnType = %RuntimeCallIsValidBadReturnType.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %TooFew.decl: %TooFew.type = fn_decl @TooFew [template = constants.%TooFew] { @@ -306,28 +306,28 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooFew.decl: %RuntimeCallTooFew.type = fn_decl @RuntimeCallTooFew [template = constants.%RuntimeCallTooFew] { +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.decl: %RuntimeCallIsValidTooFew.type = fn_decl @RuntimeCallIsValidTooFew [template = constants.%RuntimeCallIsValidTooFew] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc21_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc21_33: init type = call constants.%Float(%int_64.loc21_33) [template = f64] -// CHECK:STDOUT: %.loc21_33.1: type = value_of_initializer %float.make_type.loc21_33 [template = f64] -// CHECK:STDOUT: %.loc21_33.2: type = converted %float.make_type.loc21_33, %.loc21_33.1 [template = f64] +// CHECK:STDOUT: %int_64.loc21_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc21_40: init type = call constants.%Float(%int_64.loc21_40) [template = f64] +// CHECK:STDOUT: %.loc21_40.1: type = value_of_initializer %float.make_type.loc21_40 [template = f64] +// CHECK:STDOUT: %.loc21_40.2: type = converted %float.make_type.loc21_40, %.loc21_40.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc21_25.1: type = splice_block %.loc21_25.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc21_25: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc21_25: init type = call constants.%Float(%int_64.loc21_25) [template = f64] -// CHECK:STDOUT: %.loc21_25.2: type = value_of_initializer %float.make_type.loc21_25 [template = f64] -// CHECK:STDOUT: %.loc21_25.3: type = converted %float.make_type.loc21_25, %.loc21_25.2 [template = f64] +// CHECK:STDOUT: %.loc21_32.1: type = splice_block %.loc21_32.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc21_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc21_32: init type = call constants.%Float(%int_64.loc21_32) [template = f64] +// CHECK:STDOUT: %.loc21_32.2: type = value_of_initializer %float.make_type.loc21_32 [template = f64] +// CHECK:STDOUT: %.loc21_32.3: type = converted %float.make_type.loc21_32, %.loc21_32.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooMany.decl: %RuntimeCallTooMany.type = fn_decl @RuntimeCallTooMany [template = constants.%RuntimeCallTooMany] { +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.decl: %RuntimeCallIsValidTooMany.type = fn_decl @RuntimeCallIsValidTooMany [template = constants.%RuntimeCallIsValidTooMany] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -337,38 +337,38 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param3 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc32_50: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc32_50: init type = call constants.%Float(%int_64.loc32_50) [template = f64] -// CHECK:STDOUT: %.loc32_50.1: type = value_of_initializer %float.make_type.loc32_50 [template = f64] -// CHECK:STDOUT: %.loc32_50.2: type = converted %float.make_type.loc32_50, %.loc32_50.1 [template = f64] +// CHECK:STDOUT: %int_64.loc32_57: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc32_57: init type = call constants.%Float(%int_64.loc32_57) [template = f64] +// CHECK:STDOUT: %.loc32_57.1: type = value_of_initializer %float.make_type.loc32_57 [template = f64] +// CHECK:STDOUT: %.loc32_57.2: type = converted %float.make_type.loc32_57, %.loc32_57.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc32_26.1: type = splice_block %.loc32_26.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc32_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc32_26: init type = call constants.%Float(%int_64.loc32_26) [template = f64] -// CHECK:STDOUT: %.loc32_26.2: type = value_of_initializer %float.make_type.loc32_26 [template = f64] -// CHECK:STDOUT: %.loc32_26.3: type = converted %float.make_type.loc32_26, %.loc32_26.2 [template = f64] +// CHECK:STDOUT: %.loc32_33.1: type = splice_block %.loc32_33.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc32_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc32_33: init type = call constants.%Float(%int_64.loc32_33) [template = f64] +// CHECK:STDOUT: %.loc32_33.2: type = value_of_initializer %float.make_type.loc32_33 [template = f64] +// CHECK:STDOUT: %.loc32_33.3: type = converted %float.make_type.loc32_33, %.loc32_33.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc32_34.1: type = splice_block %.loc32_34.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc32_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc32_34: init type = call constants.%Float(%int_64.loc32_34) [template = f64] -// CHECK:STDOUT: %.loc32_34.2: type = value_of_initializer %float.make_type.loc32_34 [template = f64] -// CHECK:STDOUT: %.loc32_34.3: type = converted %float.make_type.loc32_34, %.loc32_34.2 [template = f64] +// CHECK:STDOUT: %.loc32_41.1: type = splice_block %.loc32_41.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc32_41: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc32_41: init type = call constants.%Float(%int_64.loc32_41) [template = f64] +// CHECK:STDOUT: %.loc32_41.2: type = value_of_initializer %float.make_type.loc32_41 [template = f64] +// CHECK:STDOUT: %.loc32_41.3: type = converted %float.make_type.loc32_41, %.loc32_41.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %c.param: f64 = value_param runtime_param2 -// CHECK:STDOUT: %.loc32_42.1: type = splice_block %.loc32_42.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc32_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc32_42: init type = call constants.%Float(%int_64.loc32_42) [template = f64] -// CHECK:STDOUT: %.loc32_42.2: type = value_of_initializer %float.make_type.loc32_42 [template = f64] -// CHECK:STDOUT: %.loc32_42.3: type = converted %float.make_type.loc32_42, %.loc32_42.2 [template = f64] +// CHECK:STDOUT: %.loc32_49.1: type = splice_block %.loc32_49.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc32_49: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc32_49: init type = call constants.%Float(%int_64.loc32_49) [template = f64] +// CHECK:STDOUT: %.loc32_49.2: type = value_of_initializer %float.make_type.loc32_49 [template = f64] +// CHECK:STDOUT: %.loc32_49.3: type = converted %float.make_type.loc32_49, %.loc32_49.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %c: f64 = bind_name c, %c.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param3 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallBadReturnType.decl: %RuntimeCallBadReturnType.type = fn_decl @RuntimeCallBadReturnType [template = constants.%RuntimeCallBadReturnType] { +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.decl: %RuntimeCallIsValidBadReturnType.type = fn_decl @RuntimeCallIsValidBadReturnType [template = constants.%RuntimeCallIsValidBadReturnType] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -377,22 +377,22 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc43_48.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc43_48.2: type = converted %bool.make_type, %.loc43_48.1 [template = bool] +// CHECK:STDOUT: %.loc43_55.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc43_55.2: type = converted %bool.make_type, %.loc43_55.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc43_32.1: type = splice_block %.loc43_32.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc43_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc43_32: init type = call constants.%Float(%int_64.loc43_32) [template = f64] -// CHECK:STDOUT: %.loc43_32.2: type = value_of_initializer %float.make_type.loc43_32 [template = f64] -// CHECK:STDOUT: %.loc43_32.3: type = converted %float.make_type.loc43_32, %.loc43_32.2 [template = f64] +// CHECK:STDOUT: %.loc43_39.1: type = splice_block %.loc43_39.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc43_39: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc43_39: init type = call constants.%Float(%int_64.loc43_39) [template = f64] +// CHECK:STDOUT: %.loc43_39.2: type = value_of_initializer %float.make_type.loc43_39 [template = f64] +// CHECK:STDOUT: %.loc43_39.3: type = converted %float.make_type.loc43_39, %.loc43_39.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc43_40.1: type = splice_block %.loc43_40.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc43_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc43_40: init type = call constants.%Float(%int_64.loc43_40) [template = f64] -// CHECK:STDOUT: %.loc43_40.2: type = value_of_initializer %float.make_type.loc43_40 [template = f64] -// CHECK:STDOUT: %.loc43_40.3: type = converted %float.make_type.loc43_40, %.loc43_40.2 [template = f64] +// CHECK:STDOUT: %.loc43_47.1: type = splice_block %.loc43_47.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc43_47: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc43_47: init type = call constants.%Float(%int_64.loc43_47) [template = f64] +// CHECK:STDOUT: %.loc43_47.2: type = value_of_initializer %float.make_type.loc43_47 [template = f64] +// CHECK:STDOUT: %.loc43_47.3: type = converted %float.make_type.loc43_47, %.loc43_47.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -408,14 +408,14 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @JustRight(%a.param_patt: f64) -> f64 = "float.negate"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooFew(%a.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooFew(%a.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooFew.ref: %TooFew.type = name_ref TooFew, file.%TooFew.decl [template = constants.%TooFew] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooMany.ref: %TooMany.type = name_ref TooMany, file.%TooMany.decl [template = constants.%TooMany] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -424,7 +424,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValidBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, file.%BadReturnType.decl [template = constants.%BadReturnType] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/neq.carbon b/toolchain/check/testdata/builtins/float/neq.carbon index e0364272e5f60..7e6d5002d58d6 100644 --- a/toolchain/check/testdata/builtins/float/neq.carbon +++ b/toolchain/check/testdata/builtins/float/neq.carbon @@ -20,7 +20,7 @@ fn F(true_: True, false_: False) { false_ as (if Neq(1.0, 1.0) then True else False); } -fn RuntimeCall(a: f64, b: f64) -> bool { +fn RuntimeCallIsValid(a: f64, b: f64) -> bool { return Neq(a, b); } @@ -53,8 +53,8 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq"; // CHECK:STDOUT: %float.2: f64 = float_literal 2 [template] // CHECK:STDOUT: %true: bool = bool_literal true [template] // CHECK:STDOUT: %false: bool = bool_literal false [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,7 +73,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq"; // CHECK:STDOUT: .True = %True.decl // CHECK:STDOUT: .False = %False.decl // CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Neq.decl: %Neq.type = fn_decl @Neq [template = constants.%Neq] { @@ -121,7 +121,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq"; // CHECK:STDOUT: %False.ref.loc7: type = name_ref False, file.%False.decl [template = constants.%False] // CHECK:STDOUT: %false_: %False = bind_name false_, %false_.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -130,22 +130,22 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq"; // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc12_35.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc12_35.2: type = converted %bool.make_type, %.loc12_35.1 [template = bool] +// CHECK:STDOUT: %.loc12_42.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc12_42.2: type = converted %bool.make_type, %.loc12_42.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc12_19.1: type = splice_block %.loc12_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc12_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc12_19: init type = call constants.%Float(%int_64.loc12_19) [template = f64] -// CHECK:STDOUT: %.loc12_19.2: type = value_of_initializer %float.make_type.loc12_19 [template = f64] -// CHECK:STDOUT: %.loc12_19.3: type = converted %float.make_type.loc12_19, %.loc12_19.2 [template = f64] +// CHECK:STDOUT: %.loc12_26.1: type = splice_block %.loc12_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc12_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc12_26: init type = call constants.%Float(%int_64.loc12_26) [template = f64] +// CHECK:STDOUT: %.loc12_26.2: type = value_of_initializer %float.make_type.loc12_26 [template = f64] +// CHECK:STDOUT: %.loc12_26.3: type = converted %float.make_type.loc12_26, %.loc12_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc12_27.1: type = splice_block %.loc12_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc12_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc12_27: init type = call constants.%Float(%int_64.loc12_27) [template = f64] -// CHECK:STDOUT: %.loc12_27.2: type = value_of_initializer %float.make_type.loc12_27 [template = f64] -// CHECK:STDOUT: %.loc12_27.3: type = converted %float.make_type.loc12_27, %.loc12_27.2 [template = f64] +// CHECK:STDOUT: %.loc12_34.1: type = splice_block %.loc12_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc12_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc12_34: init type = call constants.%Float(%int_64.loc12_34) [template = f64] +// CHECK:STDOUT: %.loc12_34.2: type = value_of_initializer %float.make_type.loc12_34 [template = f64] +// CHECK:STDOUT: %.loc12_34.3: type = converted %float.make_type.loc12_34, %.loc12_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -214,7 +214,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq"; // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Neq.ref: %Neq.type = name_ref Neq, file.%Neq.decl [template = constants.%Neq] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/float/sub.carbon b/toolchain/check/testdata/builtins/float/sub.carbon index 07303628f1cc6..03add0c7e2126 100644 --- a/toolchain/check/testdata/builtins/float/sub.carbon +++ b/toolchain/check/testdata/builtins/float/sub.carbon @@ -12,7 +12,7 @@ fn Sub(a: f64, b: f64) -> f64 = "float.sub"; -fn RuntimeCall(a: f64, b: f64) -> f64 { +fn RuntimeCallIsValid(a: f64, b: f64) -> f64 { return Sub(a, b); } @@ -38,15 +38,15 @@ fn TooMany(a: f64, b: f64, c: f64) -> f64 = "float.sub"; fn BadReturnType(a: f64, b: f64) -> bool = "float.sub"; fn JustRight(a: f64, b: f64) -> f64 = "float.sub"; -fn RuntimeCallTooFew(a: f64) -> f64 { +fn RuntimeCallIsValidTooFew(a: f64) -> f64 { return TooFew(a); } -fn RuntimeCallTooMany(a: f64, b: f64, c: f64) -> f64 { +fn RuntimeCallIsValidTooMany(a: f64, b: f64, c: f64) -> f64 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { +fn RuntimeCallIsValidBadReturnType(a: f64, b: f64) -> bool { return BadReturnType(a, b); } @@ -58,8 +58,8 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %Float: %Float.type = struct_value () [template] // CHECK:STDOUT: %Sub.type: type = fn_type @Sub [template] // CHECK:STDOUT: %Sub: %Sub.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCall.type: type = fn_type @RuntimeCall [template] -// CHECK:STDOUT: %RuntimeCall: %RuntimeCall.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValid.type: type = fn_type @RuntimeCallIsValid [template] +// CHECK:STDOUT: %RuntimeCallIsValid: %RuntimeCallIsValid.type = struct_value () [template] // CHECK:STDOUT: %float.1: f64 = float_literal 2 [template] // CHECK:STDOUT: %float.2: f64 = float_literal 0.5 [template] // CHECK:STDOUT: %float.3: f64 = float_literal 1.5 [template] @@ -77,7 +77,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Sub = %Sub.decl -// CHECK:STDOUT: .RuntimeCall = %RuntimeCall.decl +// CHECK:STDOUT: .RuntimeCallIsValid = %RuntimeCallIsValid.decl // CHECK:STDOUT: .x = %x // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core @@ -112,7 +112,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCall.decl: %RuntimeCall.type = fn_decl @RuntimeCall [template = constants.%RuntimeCall] { +// CHECK:STDOUT: %RuntimeCallIsValid.decl: %RuntimeCallIsValid.type = fn_decl @RuntimeCallIsValid [template = constants.%RuntimeCallIsValid] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -120,24 +120,24 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc4_35: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%int_64.loc4_35) [template = f64] -// CHECK:STDOUT: %.loc4_35.1: type = value_of_initializer %float.make_type.loc4_35 [template = f64] -// CHECK:STDOUT: %.loc4_35.2: type = converted %float.make_type.loc4_35, %.loc4_35.1 [template = f64] +// CHECK:STDOUT: %int_64.loc4_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_42: init type = call constants.%Float(%int_64.loc4_42) [template = f64] +// CHECK:STDOUT: %.loc4_42.1: type = value_of_initializer %float.make_type.loc4_42 [template = f64] +// CHECK:STDOUT: %.loc4_42.2: type = converted %float.make_type.loc4_42, %.loc4_42.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc4_19.1: type = splice_block %.loc4_19.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_19: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%int_64.loc4_19) [template = f64] -// CHECK:STDOUT: %.loc4_19.2: type = value_of_initializer %float.make_type.loc4_19 [template = f64] -// CHECK:STDOUT: %.loc4_19.3: type = converted %float.make_type.loc4_19, %.loc4_19.2 [template = f64] +// CHECK:STDOUT: %.loc4_26.1: type = splice_block %.loc4_26.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_26: init type = call constants.%Float(%int_64.loc4_26) [template = f64] +// CHECK:STDOUT: %.loc4_26.2: type = value_of_initializer %float.make_type.loc4_26 [template = f64] +// CHECK:STDOUT: %.loc4_26.3: type = converted %float.make_type.loc4_26, %.loc4_26.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc4_27.1: type = splice_block %.loc4_27.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc4_27: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%int_64.loc4_27) [template = f64] -// CHECK:STDOUT: %.loc4_27.2: type = value_of_initializer %float.make_type.loc4_27 [template = f64] -// CHECK:STDOUT: %.loc4_27.3: type = converted %float.make_type.loc4_27, %.loc4_27.2 [template = f64] +// CHECK:STDOUT: %.loc4_34.1: type = splice_block %.loc4_34.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc4_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc4_34: init type = call constants.%Float(%int_64.loc4_34) [template = f64] +// CHECK:STDOUT: %.loc4_34.2: type = value_of_initializer %float.make_type.loc4_34 [template = f64] +// CHECK:STDOUT: %.loc4_34.3: type = converted %float.make_type.loc4_34, %.loc4_34.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 @@ -149,7 +149,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @Sub(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.sub"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCall(%a.param_patt: f64, %b.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValid(%a.param_patt: f64, %b.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Sub.ref: %Sub.type = name_ref Sub, file.%Sub.decl [template = constants.%Sub] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -186,12 +186,12 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %BadReturnType: %BadReturnType.type = struct_value () [template] // CHECK:STDOUT: %JustRight.type: type = fn_type @JustRight [template] // CHECK:STDOUT: %JustRight: %JustRight.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooFew.type: type = fn_type @RuntimeCallTooFew [template] -// CHECK:STDOUT: %RuntimeCallTooFew: %RuntimeCallTooFew.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallTooMany.type: type = fn_type @RuntimeCallTooMany [template] -// CHECK:STDOUT: %RuntimeCallTooMany: %RuntimeCallTooMany.type = struct_value () [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType.type: type = fn_type @RuntimeCallBadReturnType [template] -// CHECK:STDOUT: %RuntimeCallBadReturnType: %RuntimeCallBadReturnType.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.type: type = fn_type @RuntimeCallIsValidTooFew [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooFew: %RuntimeCallIsValidTooFew.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.type: type = fn_type @RuntimeCallIsValidTooMany [template] +// CHECK:STDOUT: %RuntimeCallIsValidTooMany: %RuntimeCallIsValidTooMany.type = struct_value () [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.type: type = fn_type @RuntimeCallIsValidBadReturnType [template] +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType: %RuntimeCallIsValidBadReturnType.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -210,9 +210,9 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: .TooMany = %TooMany.decl // CHECK:STDOUT: .BadReturnType = %BadReturnType.decl // CHECK:STDOUT: .JustRight = %JustRight.decl -// CHECK:STDOUT: .RuntimeCallTooFew = %RuntimeCallTooFew.decl -// CHECK:STDOUT: .RuntimeCallTooMany = %RuntimeCallTooMany.decl -// CHECK:STDOUT: .RuntimeCallBadReturnType = %RuntimeCallBadReturnType.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooFew = %RuntimeCallIsValidTooFew.decl +// CHECK:STDOUT: .RuntimeCallIsValidTooMany = %RuntimeCallIsValidTooMany.decl +// CHECK:STDOUT: .RuntimeCallIsValidBadReturnType = %RuntimeCallIsValidBadReturnType.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %TooFew.decl: %TooFew.type = fn_decl @TooFew [template = constants.%TooFew] { @@ -338,28 +338,28 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param2 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooFew.decl: %RuntimeCallTooFew.type = fn_decl @RuntimeCallTooFew [template = constants.%RuntimeCallTooFew] { +// CHECK:STDOUT: %RuntimeCallIsValidTooFew.decl: %RuntimeCallIsValidTooFew.type = fn_decl @RuntimeCallIsValidTooFew [template = constants.%RuntimeCallIsValidTooFew] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc20_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%int_64.loc20_33) [template = f64] -// CHECK:STDOUT: %.loc20_33.1: type = value_of_initializer %float.make_type.loc20_33 [template = f64] -// CHECK:STDOUT: %.loc20_33.2: type = converted %float.make_type.loc20_33, %.loc20_33.1 [template = f64] +// CHECK:STDOUT: %int_64.loc20_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_40: init type = call constants.%Float(%int_64.loc20_40) [template = f64] +// CHECK:STDOUT: %.loc20_40.1: type = value_of_initializer %float.make_type.loc20_40 [template = f64] +// CHECK:STDOUT: %.loc20_40.2: type = converted %float.make_type.loc20_40, %.loc20_40.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc20_25.1: type = splice_block %.loc20_25.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc20_25: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%int_64.loc20_25) [template = f64] -// CHECK:STDOUT: %.loc20_25.2: type = value_of_initializer %float.make_type.loc20_25 [template = f64] -// CHECK:STDOUT: %.loc20_25.3: type = converted %float.make_type.loc20_25, %.loc20_25.2 [template = f64] +// CHECK:STDOUT: %.loc20_32.1: type = splice_block %.loc20_32.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc20_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc20_32: init type = call constants.%Float(%int_64.loc20_32) [template = f64] +// CHECK:STDOUT: %.loc20_32.2: type = value_of_initializer %float.make_type.loc20_32 [template = f64] +// CHECK:STDOUT: %.loc20_32.3: type = converted %float.make_type.loc20_32, %.loc20_32.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param1 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallTooMany.decl: %RuntimeCallTooMany.type = fn_decl @RuntimeCallTooMany [template = constants.%RuntimeCallTooMany] { +// CHECK:STDOUT: %RuntimeCallIsValidTooMany.decl: %RuntimeCallIsValidTooMany.type = fn_decl @RuntimeCallIsValidTooMany [template = constants.%RuntimeCallIsValidTooMany] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -369,38 +369,38 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.patt: f64 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param3 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_64.loc24_50: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%int_64.loc24_50) [template = f64] -// CHECK:STDOUT: %.loc24_50.1: type = value_of_initializer %float.make_type.loc24_50 [template = f64] -// CHECK:STDOUT: %.loc24_50.2: type = converted %float.make_type.loc24_50, %.loc24_50.1 [template = f64] +// CHECK:STDOUT: %int_64.loc24_57: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_57: init type = call constants.%Float(%int_64.loc24_57) [template = f64] +// CHECK:STDOUT: %.loc24_57.1: type = value_of_initializer %float.make_type.loc24_57 [template = f64] +// CHECK:STDOUT: %.loc24_57.2: type = converted %float.make_type.loc24_57, %.loc24_57.1 [template = f64] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc24_26.1: type = splice_block %.loc24_26.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_26: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%int_64.loc24_26) [template = f64] -// CHECK:STDOUT: %.loc24_26.2: type = value_of_initializer %float.make_type.loc24_26 [template = f64] -// CHECK:STDOUT: %.loc24_26.3: type = converted %float.make_type.loc24_26, %.loc24_26.2 [template = f64] +// CHECK:STDOUT: %.loc24_33.1: type = splice_block %.loc24_33.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_33: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_33: init type = call constants.%Float(%int_64.loc24_33) [template = f64] +// CHECK:STDOUT: %.loc24_33.2: type = value_of_initializer %float.make_type.loc24_33 [template = f64] +// CHECK:STDOUT: %.loc24_33.3: type = converted %float.make_type.loc24_33, %.loc24_33.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc24_34.1: type = splice_block %.loc24_34.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_34: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%int_64.loc24_34) [template = f64] -// CHECK:STDOUT: %.loc24_34.2: type = value_of_initializer %float.make_type.loc24_34 [template = f64] -// CHECK:STDOUT: %.loc24_34.3: type = converted %float.make_type.loc24_34, %.loc24_34.2 [template = f64] +// CHECK:STDOUT: %.loc24_41.1: type = splice_block %.loc24_41.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_41: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_41: init type = call constants.%Float(%int_64.loc24_41) [template = f64] +// CHECK:STDOUT: %.loc24_41.2: type = value_of_initializer %float.make_type.loc24_41 [template = f64] +// CHECK:STDOUT: %.loc24_41.3: type = converted %float.make_type.loc24_41, %.loc24_41.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %c.param: f64 = value_param runtime_param2 -// CHECK:STDOUT: %.loc24_42.1: type = splice_block %.loc24_42.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc24_42: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%int_64.loc24_42) [template = f64] -// CHECK:STDOUT: %.loc24_42.2: type = value_of_initializer %float.make_type.loc24_42 [template = f64] -// CHECK:STDOUT: %.loc24_42.3: type = converted %float.make_type.loc24_42, %.loc24_42.2 [template = f64] +// CHECK:STDOUT: %.loc24_49.1: type = splice_block %.loc24_49.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc24_49: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc24_49: init type = call constants.%Float(%int_64.loc24_49) [template = f64] +// CHECK:STDOUT: %.loc24_49.2: type = value_of_initializer %float.make_type.loc24_49 [template = f64] +// CHECK:STDOUT: %.loc24_49.3: type = converted %float.make_type.loc24_49, %.loc24_49.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %c: f64 = bind_name c, %c.param // CHECK:STDOUT: %return.param: ref f64 = out_param runtime_param3 // CHECK:STDOUT: %return: ref f64 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %RuntimeCallBadReturnType.decl: %RuntimeCallBadReturnType.type = fn_decl @RuntimeCallBadReturnType [template = constants.%RuntimeCallBadReturnType] { +// CHECK:STDOUT: %RuntimeCallIsValidBadReturnType.decl: %RuntimeCallIsValidBadReturnType.type = fn_decl @RuntimeCallIsValidBadReturnType [template = constants.%RuntimeCallIsValidBadReturnType] { // CHECK:STDOUT: %a.patt: f64 = binding_pattern a // CHECK:STDOUT: %a.param_patt: f64 = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %b.patt: f64 = binding_pattern b @@ -409,22 +409,22 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2 // CHECK:STDOUT: } { // CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc28_48.1: type = value_of_initializer %bool.make_type [template = bool] -// CHECK:STDOUT: %.loc28_48.2: type = converted %bool.make_type, %.loc28_48.1 [template = bool] +// CHECK:STDOUT: %.loc28_55.1: type = value_of_initializer %bool.make_type [template = bool] +// CHECK:STDOUT: %.loc28_55.2: type = converted %bool.make_type, %.loc28_55.1 [template = bool] // CHECK:STDOUT: %a.param: f64 = value_param runtime_param0 -// CHECK:STDOUT: %.loc28_32.1: type = splice_block %.loc28_32.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_32: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%int_64.loc28_32) [template = f64] -// CHECK:STDOUT: %.loc28_32.2: type = value_of_initializer %float.make_type.loc28_32 [template = f64] -// CHECK:STDOUT: %.loc28_32.3: type = converted %float.make_type.loc28_32, %.loc28_32.2 [template = f64] +// CHECK:STDOUT: %.loc28_39.1: type = splice_block %.loc28_39.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_39: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_39: init type = call constants.%Float(%int_64.loc28_39) [template = f64] +// CHECK:STDOUT: %.loc28_39.2: type = value_of_initializer %float.make_type.loc28_39 [template = f64] +// CHECK:STDOUT: %.loc28_39.3: type = converted %float.make_type.loc28_39, %.loc28_39.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %a: f64 = bind_name a, %a.param // CHECK:STDOUT: %b.param: f64 = value_param runtime_param1 -// CHECK:STDOUT: %.loc28_40.1: type = splice_block %.loc28_40.3 [template = f64] { -// CHECK:STDOUT: %int_64.loc28_40: Core.IntLiteral = int_value 64 [template = constants.%int_64] -// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%int_64.loc28_40) [template = f64] -// CHECK:STDOUT: %.loc28_40.2: type = value_of_initializer %float.make_type.loc28_40 [template = f64] -// CHECK:STDOUT: %.loc28_40.3: type = converted %float.make_type.loc28_40, %.loc28_40.2 [template = f64] +// CHECK:STDOUT: %.loc28_47.1: type = splice_block %.loc28_47.3 [template = f64] { +// CHECK:STDOUT: %int_64.loc28_47: Core.IntLiteral = int_value 64 [template = constants.%int_64] +// CHECK:STDOUT: %float.make_type.loc28_47: init type = call constants.%Float(%int_64.loc28_47) [template = f64] +// CHECK:STDOUT: %.loc28_47.2: type = value_of_initializer %float.make_type.loc28_47 [template = f64] +// CHECK:STDOUT: %.loc28_47.3: type = converted %float.make_type.loc28_47, %.loc28_47.2 [template = f64] // CHECK:STDOUT: } // CHECK:STDOUT: %b: f64 = bind_name b, %b.param // CHECK:STDOUT: %return.param: ref bool = out_param runtime_param2 @@ -440,7 +440,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: // CHECK:STDOUT: fn @JustRight(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.sub"; // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooFew(%a.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooFew(%a.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooFew.ref: %TooFew.type = name_ref TooFew, file.%TooFew.decl [template = constants.%TooFew] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -450,7 +450,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc21_19.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { +// CHECK:STDOUT: fn @RuntimeCallIsValidTooMany(%a.param_patt: f64, %b.param_patt: f64, %c.param_patt: f64) -> f64 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %TooMany.ref: %TooMany.type = name_ref TooMany, file.%TooMany.decl [template = constants.%TooMany] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a @@ -462,7 +462,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool { // CHECK:STDOUT: return %.loc25_26.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @RuntimeCallBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { +// CHECK:STDOUT: fn @RuntimeCallIsValidBadReturnType(%a.param_patt: f64, %b.param_patt: f64) -> bool { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %BadReturnType.ref: %BadReturnType.type = name_ref BadReturnType, file.%BadReturnType.decl [template = constants.%BadReturnType] // CHECK:STDOUT: %a.ref: f64 = name_ref a, %a diff --git a/toolchain/check/testdata/builtins/int/and.carbon b/toolchain/check/testdata/builtins/int/and.carbon index 03fde9ad57391..325f6f0ff821d 100644 --- a/toolchain/check/testdata/builtins/int/and.carbon +++ b/toolchain/check/testdata/builtins/int/and.carbon @@ -17,6 +17,6 @@ fn And(a: i32, b: i32) -> i32 = "int.and"; var arr: [i32; And(12, 10)]; let arr_p: [i32; 8]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return And(a, b); } diff --git a/toolchain/check/testdata/builtins/int/complement.carbon b/toolchain/check/testdata/builtins/int/complement.carbon index 287b8d9264ae4..ddcb047d88f73 100644 --- a/toolchain/check/testdata/builtins/int/complement.carbon +++ b/toolchain/check/testdata/builtins/int/complement.carbon @@ -18,6 +18,6 @@ fn And(a: i32, b: i32) -> i32 = "int.and"; var arr: [i32; And(Complement(0x123456), 0xFFFFFF)]; let arr_p: [i32; 0xEDCBA9]* = &arr; -fn RuntimeCall(a: i32) -> i32 { +fn RuntimeCallIsValid(a: i32) -> i32 { return Complement(a); } diff --git a/toolchain/check/testdata/builtins/int/eq.carbon b/toolchain/check/testdata/builtins/int/eq.carbon index 30e4790702bd5..2700539af9293 100644 --- a/toolchain/check/testdata/builtins/int/eq.carbon +++ b/toolchain/check/testdata/builtins/int/eq.carbon @@ -22,7 +22,7 @@ fn F(true_: True, false_: False) { false_ as (if Eq(1, 2) then True else False); } -fn RuntimeCall(a: i32, b: i32) -> bool { +fn RuntimeCallIsValid(a: i32, b: i32) -> bool { return Eq(a, b); } diff --git a/toolchain/check/testdata/builtins/int/greater.carbon b/toolchain/check/testdata/builtins/int/greater.carbon index c39a45ae6e3a1..5b5925db71832 100644 --- a/toolchain/check/testdata/builtins/int/greater.carbon +++ b/toolchain/check/testdata/builtins/int/greater.carbon @@ -26,6 +26,6 @@ fn F(true_: True, false_: False) { true_ as (if Greater(0, Negate(1)) then True else False); } -fn RuntimeCall(a: i32, b: i32) -> bool { +fn RuntimeCallIsValid(a: i32, b: i32) -> bool { return Greater(a, b); } diff --git a/toolchain/check/testdata/builtins/int/greater_eq.carbon b/toolchain/check/testdata/builtins/int/greater_eq.carbon index 7a103aefb915e..952e906458a0a 100644 --- a/toolchain/check/testdata/builtins/int/greater_eq.carbon +++ b/toolchain/check/testdata/builtins/int/greater_eq.carbon @@ -26,6 +26,6 @@ fn F(true_: True, false_: False) { true_ as (if GreaterEq(0, Negate(1)) then True else False); } -fn RuntimeCall(a: i32, b: i32) -> bool { +fn RuntimeCallIsValid(a: i32, b: i32) -> bool { return GreaterEq(a, b); } diff --git a/toolchain/check/testdata/builtins/int/left_shift.carbon b/toolchain/check/testdata/builtins/int/left_shift.carbon index dc5be6adcd086..47a7036515f12 100644 --- a/toolchain/check/testdata/builtins/int/left_shift.carbon +++ b/toolchain/check/testdata/builtins/int/left_shift.carbon @@ -17,7 +17,7 @@ fn LeftShift(a: i32, b: i32) -> i32 = "int.left_shift"; var arr: [i32; LeftShift(5, 2)]; let arr_p: [i32; 20]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return LeftShift(a, b); } diff --git a/toolchain/check/testdata/builtins/int/less.carbon b/toolchain/check/testdata/builtins/int/less.carbon index 36293802bfd0c..fa6181050d87f 100644 --- a/toolchain/check/testdata/builtins/int/less.carbon +++ b/toolchain/check/testdata/builtins/int/less.carbon @@ -26,6 +26,6 @@ fn F(true_: True, false_: False) { false_ as (if Less(0, Negate(1)) then True else False); } -fn RuntimeCall(a: i32, b: i32) -> bool { +fn RuntimeCallIsValid(a: i32, b: i32) -> bool { return Less(a, b); } diff --git a/toolchain/check/testdata/builtins/int/less_eq.carbon b/toolchain/check/testdata/builtins/int/less_eq.carbon index bee7f004b699c..6ae44f2efd2d0 100644 --- a/toolchain/check/testdata/builtins/int/less_eq.carbon +++ b/toolchain/check/testdata/builtins/int/less_eq.carbon @@ -26,6 +26,6 @@ fn F(true_: True, false_: False) { false_ as (if LessEq(0, Negate(1)) then True else False); } -fn RuntimeCall(a: i32, b: i32) -> bool { +fn RuntimeCallIsValid(a: i32, b: i32) -> bool { return LessEq(a, b); } diff --git a/toolchain/check/testdata/builtins/int/neq.carbon b/toolchain/check/testdata/builtins/int/neq.carbon index 441394402abd9..702010fba3aaf 100644 --- a/toolchain/check/testdata/builtins/int/neq.carbon +++ b/toolchain/check/testdata/builtins/int/neq.carbon @@ -22,6 +22,6 @@ fn F(true_: True, false_: False) { true_ as (if Neq(1, 2) then True else False); } -fn RuntimeCall(a: i32, b: i32) -> bool { +fn RuntimeCallIsValid(a: i32, b: i32) -> bool { return Neq(a, b); } diff --git a/toolchain/check/testdata/builtins/int/or.carbon b/toolchain/check/testdata/builtins/int/or.carbon index 4baf7d3af6e4b..9dbd3cca8b7ef 100644 --- a/toolchain/check/testdata/builtins/int/or.carbon +++ b/toolchain/check/testdata/builtins/int/or.carbon @@ -17,6 +17,6 @@ fn Or(a: i32, b: i32) -> i32 = "int.or"; var arr: [i32; Or(12, 10)]; let arr_p: [i32; 14]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Or(a, b); } diff --git a/toolchain/check/testdata/builtins/int/right_shift.carbon b/toolchain/check/testdata/builtins/int/right_shift.carbon index b3ada6d910f0c..ead0fec1966a4 100644 --- a/toolchain/check/testdata/builtins/int/right_shift.carbon +++ b/toolchain/check/testdata/builtins/int/right_shift.carbon @@ -17,7 +17,7 @@ fn RightShift(a: i32, b: i32) -> i32 = "int.right_shift"; var arr: [i32; RightShift(22, 2)]; let arr_p: [i32; 5]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return RightShift(a, b); } diff --git a/toolchain/check/testdata/builtins/int/sadd.carbon b/toolchain/check/testdata/builtins/int/sadd.carbon index 25e2328224f7f..92a7a741edf4a 100644 --- a/toolchain/check/testdata/builtins/int/sadd.carbon +++ b/toolchain/check/testdata/builtins/int/sadd.carbon @@ -17,7 +17,7 @@ fn Add(a: i32, b: i32) -> i32 = "int.sadd"; var arr: [i32; Add(1, 2)]; let arr_p: [i32; 3]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Add(a, b); } @@ -67,15 +67,15 @@ var bad_return_type: [i32; BadReturnType(1, 2)]; // CHECK:STDERR: var bad_call: [i32; JustRight(1, 2, 3)]; -fn RuntimeCallTooFew(a: i32) -> i32 { +fn RuntimeCallIsValidTooFew(a: i32) -> i32 { return TooFew(a); } -fn RuntimeCallTooMany(a: i32, b: i32, c: i32) -> i32 { +fn RuntimeCallIsValidTooMany(a: i32, b: i32, c: i32) -> i32 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: i32, b: i32) -> bool { +fn RuntimeCallIsValidBadReturnType(a: i32, b: i32) -> bool { return BadReturnType(a, b); } diff --git a/toolchain/check/testdata/builtins/int/sdiv.carbon b/toolchain/check/testdata/builtins/int/sdiv.carbon index 87b0d82c78563..abec5e0bce168 100644 --- a/toolchain/check/testdata/builtins/int/sdiv.carbon +++ b/toolchain/check/testdata/builtins/int/sdiv.carbon @@ -17,7 +17,7 @@ fn Div(a: i32, b: i32) -> i32 = "int.sdiv"; var arr: [i32; Div(3, 2)]; let arr_p: [i32; 1]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Div(a, b); } diff --git a/toolchain/check/testdata/builtins/int/smod.carbon b/toolchain/check/testdata/builtins/int/smod.carbon index aa2220c8a0769..72f5f4f01cd1b 100644 --- a/toolchain/check/testdata/builtins/int/smod.carbon +++ b/toolchain/check/testdata/builtins/int/smod.carbon @@ -17,7 +17,7 @@ fn Mod(a: i32, b: i32) -> i32 = "int.smod"; var arr: [i32; Mod(5, 3)]; let arr_p: [i32; 2]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Mod(a, b); } diff --git a/toolchain/check/testdata/builtins/int/smul.carbon b/toolchain/check/testdata/builtins/int/smul.carbon index 900045d8460af..563d39d864353 100644 --- a/toolchain/check/testdata/builtins/int/smul.carbon +++ b/toolchain/check/testdata/builtins/int/smul.carbon @@ -17,7 +17,7 @@ fn Mul(a: i32, b: i32) -> i32 = "int.smul"; var arr: [i32; Mul(3, 2)]; let arr_p: [i32; 6]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Mul(a, b); } diff --git a/toolchain/check/testdata/builtins/int/snegate.carbon b/toolchain/check/testdata/builtins/int/snegate.carbon index cb1500e09827d..a0c03f880e7c1 100644 --- a/toolchain/check/testdata/builtins/int/snegate.carbon +++ b/toolchain/check/testdata/builtins/int/snegate.carbon @@ -19,7 +19,7 @@ let arr_p: [i32; 123]* = &arr; let n: i32 = Negate(1); -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Negate(a); } @@ -69,7 +69,7 @@ var bad_return_type: [i32; BadReturnType(1)]; // CHECK:STDERR: var bad_call: [i32; JustRight(1, 2)]; -fn RuntimeCallTooFew(a: i32) -> i32 { +fn RuntimeCallIsValidTooFew(a: i32) -> i32 { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 1 argument passed to function expecting 0 arguments [CallArgCountMismatch] // CHECK:STDERR: return TooFew(a); // CHECK:STDERR: ^~~~~~~~~ @@ -80,7 +80,7 @@ fn RuntimeCallTooFew(a: i32) -> i32 { return TooFew(a); } -fn RuntimeCallTooMany(a: i32, b: i32, c: i32) -> i32 { +fn RuntimeCallIsValidTooMany(a: i32, b: i32, c: i32) -> i32 { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 3 arguments passed to function expecting 2 arguments [CallArgCountMismatch] // CHECK:STDERR: return TooMany(a, b, c); // CHECK:STDERR: ^~~~~~~~~~~~~~~~ @@ -91,7 +91,7 @@ fn RuntimeCallTooMany(a: i32, b: i32, c: i32) -> i32 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: i32, b: i32) -> bool { +fn RuntimeCallIsValidBadReturnType(a: i32, b: i32) -> bool { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 2 arguments passed to function expecting 1 argument [CallArgCountMismatch] // CHECK:STDERR: return BadReturnType(a, b); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~ diff --git a/toolchain/check/testdata/builtins/int/ssub.carbon b/toolchain/check/testdata/builtins/int/ssub.carbon index aae24d11e6f79..c27bfe561aac8 100644 --- a/toolchain/check/testdata/builtins/int/ssub.carbon +++ b/toolchain/check/testdata/builtins/int/ssub.carbon @@ -17,7 +17,7 @@ fn Sub(a: i32, b: i32) -> i32 = "int.ssub"; var arr: [i32; Sub(3, 2)]; let arr_p: [i32; 1]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Sub(a, b); } diff --git a/toolchain/check/testdata/builtins/int/uadd.carbon b/toolchain/check/testdata/builtins/int/uadd.carbon index 910ed75aac6ea..cd7ac70b6b990 100644 --- a/toolchain/check/testdata/builtins/int/uadd.carbon +++ b/toolchain/check/testdata/builtins/int/uadd.carbon @@ -17,7 +17,7 @@ fn Add(a: i32, b: i32) -> i32 = "int.uadd"; var arr: [i32; Add(1, 2)]; let arr_p: [i32; 3]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Add(a, b); } @@ -66,15 +66,15 @@ var bad_return_type: [i32; BadReturnType(1, 2)]; // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ var bad_call: [i32; JustRight(1, 2, 3)]; -fn RuntimeCallTooFew(a: i32) -> i32 { +fn RuntimeCallIsValidTooFew(a: i32) -> i32 { return TooFew(a); } -fn RuntimeCallTooMany(a: i32, b: i32, c: i32) -> i32 { +fn RuntimeCallIsValidTooMany(a: i32, b: i32, c: i32) -> i32 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: i32, b: i32) -> bool { +fn RuntimeCallIsValidBadReturnType(a: i32, b: i32) -> bool { return BadReturnType(a, b); } diff --git a/toolchain/check/testdata/builtins/int/udiv.carbon b/toolchain/check/testdata/builtins/int/udiv.carbon index eb169fbd534e4..1efe7a8938583 100644 --- a/toolchain/check/testdata/builtins/int/udiv.carbon +++ b/toolchain/check/testdata/builtins/int/udiv.carbon @@ -17,7 +17,7 @@ fn Div(a: i32, b: i32) -> i32 = "int.udiv"; var arr: [i32; Div(3, 2)]; let arr_p: [i32; 1]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Div(a, b); } diff --git a/toolchain/check/testdata/builtins/int/umod.carbon b/toolchain/check/testdata/builtins/int/umod.carbon index 02a44284176a6..dc6067eb2d641 100644 --- a/toolchain/check/testdata/builtins/int/umod.carbon +++ b/toolchain/check/testdata/builtins/int/umod.carbon @@ -17,7 +17,7 @@ fn Mod(a: i32, b: i32) -> i32 = "int.umod"; var arr: [i32; Mod(5, 3)]; let arr_p: [i32; 2]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Mod(a, b); } diff --git a/toolchain/check/testdata/builtins/int/umul.carbon b/toolchain/check/testdata/builtins/int/umul.carbon index 58183926b2b5c..40d89a11cd87f 100644 --- a/toolchain/check/testdata/builtins/int/umul.carbon +++ b/toolchain/check/testdata/builtins/int/umul.carbon @@ -17,7 +17,7 @@ fn Mul(a: i32, b: i32) -> i32 = "int.umul"; var arr: [i32; Mul(3, 2)]; let arr_p: [i32; 6]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Mul(a, b); } diff --git a/toolchain/check/testdata/builtins/int/unegate.carbon b/toolchain/check/testdata/builtins/int/unegate.carbon index edda616ec7b34..0bbd88372f7d4 100644 --- a/toolchain/check/testdata/builtins/int/unegate.carbon +++ b/toolchain/check/testdata/builtins/int/unegate.carbon @@ -19,7 +19,7 @@ let arr_p: [u32; 123]* = &arr; let n: u32 = Negate(1); -fn RuntimeCall(a: u32, b: u32) -> u32 { +fn RuntimeCallIsValid(a: u32, b: u32) -> u32 { return Negate(a); } @@ -69,7 +69,7 @@ var bad_return_type: [u32; BadReturnType(1)]; // CHECK:STDERR: var bad_call: [u32; JustRight(1, 2)]; -fn RuntimeCallTooFew(a: u32) -> u32 { +fn RuntimeCallIsValidTooFew(a: u32) -> u32 { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 1 argument passed to function expecting 0 arguments [CallArgCountMismatch] // CHECK:STDERR: return TooFew(a); // CHECK:STDERR: ^~~~~~~~~ @@ -80,7 +80,7 @@ fn RuntimeCallTooFew(a: u32) -> u32 { return TooFew(a); } -fn RuntimeCallTooMany(a: u32, b: u32, c: u32) -> u32 { +fn RuntimeCallIsValidTooMany(a: u32, b: u32, c: u32) -> u32 { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+7]]:10: error: 3 arguments passed to function expecting 2 arguments [CallArgCountMismatch] // CHECK:STDERR: return TooMany(a, b, c); // CHECK:STDERR: ^~~~~~~~~~~~~~~~ @@ -91,7 +91,7 @@ fn RuntimeCallTooMany(a: u32, b: u32, c: u32) -> u32 { return TooMany(a, b, c); } -fn RuntimeCallBadReturnType(a: u32, b: u32) -> bool { +fn RuntimeCallIsValidBadReturnType(a: u32, b: u32) -> bool { // CHECK:STDERR: fail_bad_decl.carbon:[[@LINE+6]]:10: error: 2 arguments passed to function expecting 1 argument [CallArgCountMismatch] // CHECK:STDERR: return BadReturnType(a, b); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~ diff --git a/toolchain/check/testdata/builtins/int/usub.carbon b/toolchain/check/testdata/builtins/int/usub.carbon index bfd9d010b929a..662d33f36fbac 100644 --- a/toolchain/check/testdata/builtins/int/usub.carbon +++ b/toolchain/check/testdata/builtins/int/usub.carbon @@ -17,7 +17,7 @@ fn Sub(a: i32, b: i32) -> i32 = "int.usub"; var arr: [i32; Sub(3, 2)]; let arr_p: [i32; 1]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Sub(a, b); } diff --git a/toolchain/check/testdata/builtins/int/xor.carbon b/toolchain/check/testdata/builtins/int/xor.carbon index 45ebdcd33459c..5471c38e8b83f 100644 --- a/toolchain/check/testdata/builtins/int/xor.carbon +++ b/toolchain/check/testdata/builtins/int/xor.carbon @@ -17,6 +17,6 @@ fn Xor(a: i32, b: i32) -> i32 = "int.xor"; var arr: [i32; Xor(12, 10)]; let arr_p: [i32; 6]* = &arr; -fn RuntimeCall(a: i32, b: i32) -> i32 { +fn RuntimeCallIsValid(a: i32, b: i32) -> i32 { return Xor(a, b); }