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

Rename BigInt to IntLiteral. (#4476)

Browse Source 
In preparation for changing the type of integer literals to
`IntLiteral`.
This commit is contained in:
Richard Smith
2024-11-02 02:09:10 +00:00
committed by GitHub
parent db76e81630
commit 44fe65fbe5
38 changed files with 556 additions and 466 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/prelude/types.carbon
+4 -4
View File
@@ -11,8 +11,8 @@ export import library "prelude/types/bool";
// noise in the toolchain tests.
// import library "prelude/types/i32";
fn BigInt() -> type = "big_int.make_type";
fn IntLiteral() -> type = "int_literal.make_type";
fn Int32() -> type = "int.make_type_32";
fn Int(size: BigInt()) -> type = "int.make_type_signed";
fn UInt(size: BigInt()) -> type = "int.make_type_unsigned";
fn Float(size: BigInt()) -> type = "float.make_type";
fn Int(size: IntLiteral()) -> type = "int.make_type_signed";
fn UInt(size: IntLiteral()) -> type = "int.make_type_unsigned";
fn Float(size: IntLiteral()) -> type = "float.make_type";
toolchain/check/context.cpp
+1 -1
View File
@@ -924,7 +924,7 @@ class TypeCompleter {
case SemIR::BuiltinInstKind::Error:
case SemIR::BuiltinInstKind::Invalid:
case SemIR::BuiltinInstKind::BoolType:
case SemIR::BuiltinInstKind::BigIntType:
case SemIR::BuiltinInstKind::IntLiteralType:
case SemIR::BuiltinInstKind::IntType:
case SemIR::BuiltinInstKind::FloatType:
case SemIR::BuiltinInstKind::NamespaceType:
toolchain/check/eval.cpp
+3 -2
View File
@@ -928,8 +928,9 @@ static auto MakeConstantForBuiltinCall(Context& context, SemIRLoc loc,
return SemIR::ConstantId::NotConstant;
}
case SemIR::BuiltinFunctionKind::BigIntMakeType: {
return context.constant_values().Get(SemIR::InstId::BuiltinBigIntType);
case SemIR::BuiltinFunctionKind::IntLiteralMakeType: {
return context.constant_values().Get(
SemIR::InstId::BuiltinIntLiteralType);
}
case SemIR::BuiltinFunctionKind::IntMakeType32: {
toolchain/check/handle_literal.cpp
+8 -8
View File
@@ -49,17 +49,17 @@ static auto MakeI32Literal(Context& context, Parse::NodeId node_id,
.int_id = context.ints().Add(i32_val)});
}
// Forms an IntValue instruction with type `BigInt` for a given literal
// Forms an IntValue instruction with type `IntLiteral` for a given literal
// integer value, which is assumed to be unsigned.
static auto MakeBigIntLiteral(Context& context, Parse::NodeId node_id,
IntId int_id) -> SemIR::InstId {
static auto MakeIntLiteral(Context& context, Parse::NodeId node_id,
IntId int_id) -> SemIR::InstId {
// TODO: `IntId`s with different bit-widths are considered different values
// here. Decide how we want to canonicalize these. For now this is only used
// by type literals, so we rely on the lexer picking some consistent rule.
return context.AddInst<SemIR::IntValue>(
node_id,
{.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::BigIntType),
.int_id = int_id});
node_id, {.type_id = context.GetBuiltinType(
SemIR::BuiltinInstKind::IntLiteralType),
.int_id = int_id});
}
auto HandleParseNode(Context& context, Parse::IntLiteralId node_id) -> bool {
@@ -147,7 +147,7 @@ static auto HandleIntOrUnsignedIntTypeLiteral(Context& context,
node_id, IntWidthNotMultipleOf8, int_kind.is_signed(),
llvm::APSInt(context.ints().Get(size_id), /*isUnsigned=*/true));
}
auto width_id = MakeBigIntLiteral(context, node_id, size_id);
auto width_id = MakeIntLiteral(context, node_id, size_id);
auto fn_inst_id = context.LookupNameInCore(
node_id, int_kind == SemIR::IntKind::Signed ? "Int" : "UInt");
auto type_inst_id = PerformCall(context, node_id, fn_inst_id, {width_id});
@@ -188,7 +188,7 @@ auto HandleParseNode(Context& context, Parse::FloatTypeLiteralId node_id)
}
auto tok_id = context.parse_tree().node_token(node_id);
auto size_id = context.tokens().GetTypeLiteralSize(tok_id);
auto width_id = MakeBigIntLiteral(context, node_id, size_id);
auto width_id = MakeIntLiteral(context, node_id, size_id);
auto fn_inst_id = context.LookupNameInCore(node_id, "Float");
auto type_inst_id = PerformCall(context, node_id, fn_inst_id, {width_id});
context.node_stack().Push(node_id, type_inst_id);
toolchain/check/testdata/array/base.carbon
Vendored
+3 -3
View File
@@ -24,7 +24,7 @@ var c: [(); 5] = ((), (), (), (), (),);
// CHECK:STDOUT: %.5: type = tuple_type (i32) [template]
// CHECK:STDOUT: %.6: i32 = int_value 0 [template]
// CHECK:STDOUT: %array.1: %.3 = tuple_value (%.2) [template]
// CHECK:STDOUT: %.7: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.7: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %.8: i32 = int_value 2 [template]
@@ -70,7 +70,7 @@ var c: [(); 5] = ((), (), (), (), (),);
// CHECK:STDOUT: %.loc11_15: type = array_type %.loc11_14, i32 [template = constants.%.3]
// CHECK:STDOUT: %a.var: ref %.3 = var a
// CHECK:STDOUT: %a: ref %.3 = bind_name a, %a.var
// CHECK:STDOUT: %.loc12_9.1: Core.BigInt = int_value 64 [template = constants.%.7]
// CHECK:STDOUT: %.loc12_9.1: Core.IntLiteral = int_value 64 [template = constants.%.7]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc12_9.1) [template = f64]
// CHECK:STDOUT: %.loc12_14: i32 = int_value 2 [template = constants.%.8]
// CHECK:STDOUT: %.loc12_9.2: type = value_of_initializer %float.make_type [template = f64]
@@ -88,7 +88,7 @@ var c: [(); 5] = ((), (), (), (), (),);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/basics/builtin_insts.carbon
Vendored
+2 -2
View File
@@ -33,7 +33,7 @@
// CHECK:STDOUT: instError: {kind: BuiltinInst, arg0: Error, type: typeError}
// CHECK:STDOUT: instAutoType: {kind: BuiltinInst, arg0: AutoType, type: typeTypeType}
// CHECK:STDOUT: instBoolType: {kind: BuiltinInst, arg0: BoolType, type: typeTypeType}
// CHECK:STDOUT: instBigIntType: {kind: BuiltinInst, arg0: BigIntType, type: typeTypeType}
// CHECK:STDOUT: instIntLiteralType: {kind: BuiltinInst, arg0: IntLiteralType, type: typeTypeType}
// CHECK:STDOUT: instIntType: {kind: BuiltinInst, arg0: IntType, type: typeTypeType}
// CHECK:STDOUT: instFloatType: {kind: BuiltinInst, arg0: FloatType, type: typeTypeType}
// CHECK:STDOUT: instStringType: {kind: BuiltinInst, arg0: StringType, type: typeTypeType}
@@ -48,7 +48,7 @@
// CHECK:STDOUT: instError: templateConstant(instError)
// CHECK:STDOUT: instAutoType: templateConstant(instAutoType)
// CHECK:STDOUT: instBoolType: templateConstant(instBoolType)
// CHECK:STDOUT: instBigIntType: templateConstant(instBigIntType)
// CHECK:STDOUT: instIntLiteralType: templateConstant(instIntLiteralType)
// CHECK:STDOUT: instIntType: templateConstant(instIntType)
// CHECK:STDOUT: instFloatType: templateConstant(instFloatType)
// CHECK:STDOUT: instStringType: templateConstant(instStringType)
toolchain/check/testdata/basics/builtin_types.carbon
Vendored
+3 -3
View File
@@ -20,7 +20,7 @@ var test_type: type = i32;
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %.2: i32 = int_value 0 [template]
// CHECK:STDOUT: %.3: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.3: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %.4: f64 = float_literal 0.10000000000000001 [template]
@@ -53,7 +53,7 @@ var test_type: type = i32;
// CHECK:STDOUT: %.loc11_15.2: type = converted %int.make_type_32, %.loc11_15.1 [template = i32]
// CHECK:STDOUT: %test_i32.var: ref i32 = var test_i32
// CHECK:STDOUT: %test_i32: ref i32 = bind_name test_i32, %test_i32.var
// CHECK:STDOUT: %.loc12_15.1: Core.BigInt = int_value 64 [template = constants.%.3]
// CHECK:STDOUT: %.loc12_15.1: Core.IntLiteral = int_value 64 [template = constants.%.3]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc12_15.1) [template = f64]
// CHECK:STDOUT: %.loc12_15.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc12_15.3: type = converted %float.make_type, %.loc12_15.2 [template = f64]
@@ -65,7 +65,7 @@ var test_type: type = i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon
Vendored
+4 -4
View File
@@ -43,7 +43,7 @@ let e: f64 = 5.0e39999999999999999993;
// CHECK:STDOUT: %Int32.type: type = fn_type @Int32 [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: }
@@ -78,11 +78,11 @@ let e: f64 = 5.0e39999999999999999993;
// CHECK:STDOUT: %int.make_type_32.loc27: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc27_8.1: type = value_of_initializer %int.make_type_32.loc27 [template = i32]
// CHECK:STDOUT: %.loc27_8.2: type = converted %int.make_type_32.loc27, %.loc27_8.1 [template = i32]
// CHECK:STDOUT: %.loc33_8.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc33_8.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type.loc33: init type = call constants.%Float(%.loc33_8.1) [template = f64]
// CHECK:STDOUT: %.loc33_8.2: type = value_of_initializer %float.make_type.loc33 [template = f64]
// CHECK:STDOUT: %.loc33_8.3: type = converted %float.make_type.loc33, %.loc33_8.2 [template = f64]
// CHECK:STDOUT: %.loc38_8.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc38_8.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type.loc38: init type = call constants.%Float(%.loc38_8.1) [template = f64]
// CHECK:STDOUT: %.loc38_8.2: type = value_of_initializer %float.make_type.loc38 [template = f64]
// CHECK:STDOUT: %.loc38_8.3: type = converted %float.make_type.loc38, %.loc38_8.2 [template = f64]
@@ -90,7 +90,7 @@ let e: f64 = 5.0e39999999999999999993;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/basics/numeric_literals.carbon
Vendored
+3 -3
View File
@@ -51,7 +51,7 @@ fn F() {
// CHECK:STDOUT: %.13: i32 = int_value 4 [template]
// CHECK:STDOUT: %.14: i32 = int_value 5 [template]
// CHECK:STDOUT: %array.1: %.3 = tuple_value (%.5, %.6, %.5, %.5, %.7, %.7) [template]
// CHECK:STDOUT: %.15: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.15: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %.16: type = array_type %.2, f64 [template]
@@ -123,7 +123,7 @@ fn F() {
// CHECK:STDOUT: %.loc21_3.20: init %.3 = array_init (%.loc21_3.4, %.loc21_3.7, %.loc21_3.10, %.loc21_3.13, %.loc21_3.16, %.loc21_3.19) to %ints.var [template = constants.%array.1]
// CHECK:STDOUT: %.loc21_4: init %.3 = converted %.loc21_3.1, %.loc21_3.20 [template = constants.%array.1]
// CHECK:STDOUT: assign %ints.var, %.loc21_4
// CHECK:STDOUT: %.loc22_16.1: Core.BigInt = int_value 64 [template = constants.%.15]
// CHECK:STDOUT: %.loc22_16.1: Core.IntLiteral = int_value 64 [template = constants.%.15]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc22_16.1) [template = f64]
// CHECK:STDOUT: %.loc22_21: i32 = int_value 6 [template = constants.%.2]
// CHECK:STDOUT: %.loc22_16.2: type = value_of_initializer %float.make_type [template = f64]
@@ -164,5 +164,5 @@ fn F() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/basics/type_literals.carbon
Vendored
+22 -22
View File
@@ -130,14 +130,14 @@ var test_f128: f128;
// CHECK:STDOUT: --- iN.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 8 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 8 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %.3: type = int_type signed, %.1 [template]
// CHECK:STDOUT: %.4: Core.BigInt = int_value 16 [template]
// CHECK:STDOUT: %.4: Core.IntLiteral = int_value 16 [template]
// CHECK:STDOUT: %.5: type = int_type signed, %.4 [template]
// CHECK:STDOUT: %.6: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.6: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %.7: type = int_type signed, %.6 [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -158,19 +158,19 @@ var test_f128: f128;
// CHECK:STDOUT: .test_i64 = %test_i64
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %.loc3_14.1: Core.BigInt = int_value 8 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_14.1: Core.IntLiteral = int_value 8 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_signed.loc3: init type = call constants.%Int(%.loc3_14.1) [template = constants.%.3]
// CHECK:STDOUT: %.loc3_14.2: type = value_of_initializer %int.make_type_signed.loc3 [template = constants.%.3]
// CHECK:STDOUT: %.loc3_14.3: type = converted %int.make_type_signed.loc3, %.loc3_14.2 [template = constants.%.3]
// CHECK:STDOUT: %test_i8.var: ref %.3 = var test_i8
// CHECK:STDOUT: %test_i8: ref %.3 = bind_name test_i8, %test_i8.var
// CHECK:STDOUT: %.loc4_15.1: Core.BigInt = int_value 16 [template = constants.%.4]
// CHECK:STDOUT: %.loc4_15.1: Core.IntLiteral = int_value 16 [template = constants.%.4]
// CHECK:STDOUT: %int.make_type_signed.loc4: init type = call constants.%Int(%.loc4_15.1) [template = constants.%.5]
// CHECK:STDOUT: %.loc4_15.2: type = value_of_initializer %int.make_type_signed.loc4 [template = constants.%.5]
// CHECK:STDOUT: %.loc4_15.3: type = converted %int.make_type_signed.loc4, %.loc4_15.2 [template = constants.%.5]
// CHECK:STDOUT: %test_i16.var: ref %.5 = var test_i16
// CHECK:STDOUT: %test_i16: ref %.5 = bind_name test_i16, %test_i16.var
// CHECK:STDOUT: %.loc5_15.1: Core.BigInt = int_value 64 [template = constants.%.6]
// CHECK:STDOUT: %.loc5_15.1: Core.IntLiteral = int_value 64 [template = constants.%.6]
// CHECK:STDOUT: %int.make_type_signed.loc5: init type = call constants.%Int(%.loc5_15.1) [template = constants.%.7]
// CHECK:STDOUT: %.loc5_15.2: type = value_of_initializer %int.make_type_signed.loc5 [template = constants.%.7]
// CHECK:STDOUT: %.loc5_15.3: type = converted %int.make_type_signed.loc5, %.loc5_15.2 [template = constants.%.7]
@@ -178,36 +178,36 @@ var test_f128: f128;
// CHECK:STDOUT: %test_i64: ref %.7 = bind_name test_i64, %test_i64.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.BigInt) -> type = "int.make_type_signed";
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.IntLiteral) -> type = "int.make_type_signed";
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_iN_bad_width.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 1 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 1 [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %.3: type = int_type signed, %.1 [template]
// CHECK:STDOUT: %.4: Core.BigInt = int_value 15 [template]
// CHECK:STDOUT: %.4: Core.IntLiteral = int_value 15 [template]
// CHECK:STDOUT: %.5: type = int_type signed, %.4 [template]
// CHECK:STDOUT: %.6: Core.BigInt = int_value 1000000000 [template]
// CHECK:STDOUT: %.6: Core.IntLiteral = int_value 1000000000 [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {}
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.BigInt) -> type = "int.make_type_signed";
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.IntLiteral) -> type = "int.make_type_signed";
// CHECK:STDOUT:
// CHECK:STDOUT: --- uN.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 8 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 8 [template]
// CHECK:STDOUT: %UInt.type: type = fn_type @UInt [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %UInt: %UInt.type = struct_value () [template]
// CHECK:STDOUT: %.3: type = int_type unsigned, %.1 [template]
// CHECK:STDOUT: %.4: Core.BigInt = int_value 16 [template]
// CHECK:STDOUT: %.4: Core.IntLiteral = int_value 16 [template]
// CHECK:STDOUT: %.5: type = int_type unsigned, %.4 [template]
// CHECK:STDOUT: %.6: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.6: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %.7: type = int_type unsigned, %.6 [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -228,19 +228,19 @@ var test_f128: f128;
// CHECK:STDOUT: .test_u64 = %test_u64
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %.loc3_14.1: Core.BigInt = int_value 8 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_14.1: Core.IntLiteral = int_value 8 [template = constants.%.1]
// CHECK:STDOUT: %int.make_type_unsigned.loc3: init type = call constants.%UInt(%.loc3_14.1) [template = constants.%.3]
// CHECK:STDOUT: %.loc3_14.2: type = value_of_initializer %int.make_type_unsigned.loc3 [template = constants.%.3]
// CHECK:STDOUT: %.loc3_14.3: type = converted %int.make_type_unsigned.loc3, %.loc3_14.2 [template = constants.%.3]
// CHECK:STDOUT: %test_u8.var: ref %.3 = var test_u8
// CHECK:STDOUT: %test_u8: ref %.3 = bind_name test_u8, %test_u8.var
// CHECK:STDOUT: %.loc4_15.1: Core.BigInt = int_value 16 [template = constants.%.4]
// CHECK:STDOUT: %.loc4_15.1: Core.IntLiteral = int_value 16 [template = constants.%.4]
// CHECK:STDOUT: %int.make_type_unsigned.loc4: init type = call constants.%UInt(%.loc4_15.1) [template = constants.%.5]
// CHECK:STDOUT: %.loc4_15.2: type = value_of_initializer %int.make_type_unsigned.loc4 [template = constants.%.5]
// CHECK:STDOUT: %.loc4_15.3: type = converted %int.make_type_unsigned.loc4, %.loc4_15.2 [template = constants.%.5]
// CHECK:STDOUT: %test_u16.var: ref %.5 = var test_u16
// CHECK:STDOUT: %test_u16: ref %.5 = bind_name test_u16, %test_u16.var
// CHECK:STDOUT: %.loc5_15.1: Core.BigInt = int_value 64 [template = constants.%.6]
// CHECK:STDOUT: %.loc5_15.1: Core.IntLiteral = int_value 64 [template = constants.%.6]
// CHECK:STDOUT: %int.make_type_unsigned.loc5: init type = call constants.%UInt(%.loc5_15.1) [template = constants.%.7]
// CHECK:STDOUT: %.loc5_15.2: type = value_of_initializer %int.make_type_unsigned.loc5 [template = constants.%.7]
// CHECK:STDOUT: %.loc5_15.3: type = converted %int.make_type_unsigned.loc5, %.loc5_15.2 [template = constants.%.7]
@@ -248,24 +248,24 @@ var test_f128: f128;
// CHECK:STDOUT: %test_u64: ref %.7 = bind_name test_u64, %test_u64.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @UInt(%size.param_patt: Core.BigInt) -> type = "int.make_type_unsigned";
// CHECK:STDOUT: fn @UInt(%size.param_patt: Core.IntLiteral) -> type = "int.make_type_unsigned";
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_uN_bad_width.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 1 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 1 [template]
// CHECK:STDOUT: %UInt.type: type = fn_type @UInt [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %UInt: %UInt.type = struct_value () [template]
// CHECK:STDOUT: %.3: type = int_type unsigned, %.1 [template]
// CHECK:STDOUT: %.4: Core.BigInt = int_value 15 [template]
// CHECK:STDOUT: %.4: Core.IntLiteral = int_value 15 [template]
// CHECK:STDOUT: %.5: type = int_type unsigned, %.4 [template]
// CHECK:STDOUT: %.6: Core.BigInt = int_value 1000000000 [template]
// CHECK:STDOUT: %.6: Core.IntLiteral = int_value 1000000000 [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {}
// CHECK:STDOUT:
// CHECK:STDOUT: fn @UInt(%size.param_patt: Core.BigInt) -> type = "int.make_type_unsigned";
// CHECK:STDOUT: fn @UInt(%size.param_patt: Core.IntLiteral) -> type = "int.make_type_unsigned";
// CHECK:STDOUT:
// CHECK:STDOUT: --- fail_fN_bad_width.carbon
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/add.carbon
Vendored
+30 -30
View File
@@ -53,7 +53,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_add.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -91,15 +91,15 @@ 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: %.loc2_11.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_11.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_11: init type = call constants.%Float(%.loc2_11.1) [template = f64]
// CHECK:STDOUT: %.loc2_11.2: type = value_of_initializer %float.make_type.loc2_11 [template = f64]
// CHECK:STDOUT: %.loc2_11.3: type = converted %float.make_type.loc2_11, %.loc2_11.2 [template = f64]
// CHECK:STDOUT: %.loc2_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_19: init type = call constants.%Float(%.loc2_19.1) [template = f64]
// CHECK:STDOUT: %.loc2_19.2: type = value_of_initializer %float.make_type.loc2_19 [template = f64]
// CHECK:STDOUT: %.loc2_19.3: type = converted %float.make_type.loc2_19, %.loc2_19.2 [template = f64]
// CHECK:STDOUT: %.loc2_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_27: init type = call constants.%Float(%.loc2_27.1) [template = f64]
// CHECK:STDOUT: %.loc2_27.2: type = value_of_initializer %float.make_type.loc2_27 [template = f64]
// CHECK:STDOUT: %.loc2_27.3: type = converted %float.make_type.loc2_27, %.loc2_27.2 [template = f64]
@@ -118,15 +118,15 @@ 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: %.loc4_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%.loc4_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%.loc4_27.1) [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_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%.loc4_35.1) [template = f64]
// CHECK:STDOUT: %.loc4_35.2: type = value_of_initializer %float.make_type.loc4_35 [template = f64]
// CHECK:STDOUT: %.loc4_35.3: type = converted %float.make_type.loc4_35, %.loc4_35.2 [template = f64]
@@ -137,7 +137,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: %.loc8_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc8_8.1) [template = f64]
// CHECK:STDOUT: %.loc8_8.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc8_8.3: type = converted %float.make_type, %.loc8_8.2 [template = f64]
@@ -145,7 +145,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %x: ref f64 = bind_name x, %x.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Add(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.add";
// CHECK:STDOUT:
@@ -173,7 +173,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -224,11 +224,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_14: init type = call constants.%Float(%.loc8_14.1) [template = f64]
// CHECK:STDOUT: %.loc8_14.2: type = value_of_initializer %float.make_type.loc8_14 [template = f64]
// CHECK:STDOUT: %.loc8_14.3: type = converted %float.make_type.loc8_14, %.loc8_14.2 [template = f64]
// CHECK:STDOUT: %.loc8_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_22: init type = call constants.%Float(%.loc8_22.1) [template = f64]
// CHECK:STDOUT: %.loc8_22.2: type = value_of_initializer %float.make_type.loc8_22 [template = f64]
// CHECK:STDOUT: %.loc8_22.3: type = converted %float.make_type.loc8_22, %.loc8_22.2 [template = f64]
@@ -247,19 +247,19 @@ 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: %.loc13_15.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_15.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_15: init type = call constants.%Float(%.loc13_15.1) [template = f64]
// CHECK:STDOUT: %.loc13_15.2: type = value_of_initializer %float.make_type.loc13_15 [template = f64]
// CHECK:STDOUT: %.loc13_15.3: type = converted %float.make_type.loc13_15, %.loc13_15.2 [template = f64]
// CHECK:STDOUT: %.loc13_23.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_23.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_23: init type = call constants.%Float(%.loc13_23.1) [template = f64]
// CHECK:STDOUT: %.loc13_23.2: type = value_of_initializer %float.make_type.loc13_23 [template = f64]
// CHECK:STDOUT: %.loc13_23.3: type = converted %float.make_type.loc13_23, %.loc13_23.2 [template = f64]
// CHECK:STDOUT: %.loc13_31.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_31.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_31: init type = call constants.%Float(%.loc13_31.1) [template = f64]
// CHECK:STDOUT: %.loc13_31.2: type = value_of_initializer %float.make_type.loc13_31 [template = f64]
// CHECK:STDOUT: %.loc13_31.3: type = converted %float.make_type.loc13_31, %.loc13_31.2 [template = f64]
// CHECK:STDOUT: %.loc13_39.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_39.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_39: init type = call constants.%Float(%.loc13_39.1) [template = f64]
// CHECK:STDOUT: %.loc13_39.2: type = value_of_initializer %float.make_type.loc13_39 [template = f64]
// CHECK:STDOUT: %.loc13_39.3: type = converted %float.make_type.loc13_39, %.loc13_39.2 [template = f64]
@@ -280,11 +280,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc17_21.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_21.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_21: init type = call constants.%Float(%.loc17_21.1) [template = f64]
// CHECK:STDOUT: %.loc17_21.2: type = value_of_initializer %float.make_type.loc17_21 [template = f64]
// CHECK:STDOUT: %.loc17_21.3: type = converted %float.make_type.loc17_21, %.loc17_21.2 [template = f64]
// CHECK:STDOUT: %.loc17_29.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_29.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_29: init type = call constants.%Float(%.loc17_29.1) [template = f64]
// CHECK:STDOUT: %.loc17_29.2: type = value_of_initializer %float.make_type.loc17_29 [template = f64]
// CHECK:STDOUT: %.loc17_29.3: type = converted %float.make_type.loc17_29, %.loc17_29.2 [template = f64]
@@ -306,15 +306,15 @@ 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: %.loc18_17.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_17.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_17: init type = call constants.%Float(%.loc18_17.1) [template = f64]
// CHECK:STDOUT: %.loc18_17.2: type = value_of_initializer %float.make_type.loc18_17 [template = f64]
// CHECK:STDOUT: %.loc18_17.3: type = converted %float.make_type.loc18_17, %.loc18_17.2 [template = f64]
// CHECK:STDOUT: %.loc18_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_25: init type = call constants.%Float(%.loc18_25.1) [template = f64]
// CHECK:STDOUT: %.loc18_25.2: type = value_of_initializer %float.make_type.loc18_25 [template = f64]
// CHECK:STDOUT: %.loc18_25.3: type = converted %float.make_type.loc18_25, %.loc18_25.2 [template = f64]
// CHECK:STDOUT: %.loc18_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_33: init type = call constants.%Float(%.loc18_33.1) [template = f64]
// CHECK:STDOUT: %.loc18_33.2: type = value_of_initializer %float.make_type.loc18_33 [template = f64]
// CHECK:STDOUT: %.loc18_33.3: type = converted %float.make_type.loc18_33, %.loc18_33.2 [template = f64]
@@ -331,11 +331,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc20_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%.loc20_25.1) [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_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%.loc20_33.1) [template = f64]
// CHECK:STDOUT: %.loc20_33.2: type = value_of_initializer %float.make_type.loc20_33 [template = f64]
// CHECK:STDOUT: %.loc20_33.3: type = converted %float.make_type.loc20_33, %.loc20_33.2 [template = f64]
@@ -354,19 +354,19 @@ 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: %.loc24_26.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_26.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%.loc24_26.1) [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_34.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_34.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%.loc24_34.1) [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_42.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_42.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%.loc24_42.1) [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_50.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_50.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%.loc24_50.1) [template = f64]
// CHECK:STDOUT: %.loc24_50.2: type = value_of_initializer %float.make_type.loc24_50 [template = f64]
// CHECK:STDOUT: %.loc24_50.3: type = converted %float.make_type.loc24_50, %.loc24_50.2 [template = f64]
@@ -387,11 +387,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc28_32.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_32.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%.loc28_32.1) [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_40.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_40.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%.loc28_40.1) [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]
@@ -407,7 +407,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TooFew(%a.param_patt: f64) -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/div.carbon
Vendored
+32 -32
View File
@@ -55,7 +55,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_div.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -99,15 +99,15 @@ 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: %.loc2_11.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_11.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_11: init type = call constants.%Float(%.loc2_11.1) [template = f64]
// CHECK:STDOUT: %.loc2_11.2: type = value_of_initializer %float.make_type.loc2_11 [template = f64]
// CHECK:STDOUT: %.loc2_11.3: type = converted %float.make_type.loc2_11, %.loc2_11.2 [template = f64]
// CHECK:STDOUT: %.loc2_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_19: init type = call constants.%Float(%.loc2_19.1) [template = f64]
// CHECK:STDOUT: %.loc2_19.2: type = value_of_initializer %float.make_type.loc2_19 [template = f64]
// CHECK:STDOUT: %.loc2_19.3: type = converted %float.make_type.loc2_19, %.loc2_19.2 [template = f64]
// CHECK:STDOUT: %.loc2_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_27: init type = call constants.%Float(%.loc2_27.1) [template = f64]
// CHECK:STDOUT: %.loc2_27.2: type = value_of_initializer %float.make_type.loc2_27 [template = f64]
// CHECK:STDOUT: %.loc2_27.3: type = converted %float.make_type.loc2_27, %.loc2_27.2 [template = f64]
@@ -126,15 +126,15 @@ 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: %.loc4_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%.loc4_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%.loc4_27.1) [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_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%.loc4_35.1) [template = f64]
// CHECK:STDOUT: %.loc4_35.2: type = value_of_initializer %float.make_type.loc4_35 [template = f64]
// CHECK:STDOUT: %.loc4_35.3: type = converted %float.make_type.loc4_35, %.loc4_35.2 [template = f64]
@@ -145,23 +145,23 @@ 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: %.loc8_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8: init type = call constants.%Float(%.loc8_8.1) [template = f64]
// CHECK:STDOUT: %.loc8_8.2: type = value_of_initializer %float.make_type.loc8 [template = f64]
// CHECK:STDOUT: %.loc8_8.3: type = converted %float.make_type.loc8, %.loc8_8.2 [template = f64]
// CHECK:STDOUT: %a.var: ref f64 = var a
// CHECK:STDOUT: %a: ref f64 = bind_name a, %a.var
// CHECK:STDOUT: %.loc9_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc9_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc9: init type = call constants.%Float(%.loc9_8.1) [template = f64]
// CHECK:STDOUT: %.loc9_8.2: type = value_of_initializer %float.make_type.loc9 [template = f64]
// CHECK:STDOUT: %.loc9_8.3: type = converted %float.make_type.loc9, %.loc9_8.2 [template = f64]
// CHECK:STDOUT: %.loc10_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc10_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc10: init type = call constants.%Float(%.loc10_8.1) [template = f64]
// CHECK:STDOUT: %.loc10_8.2: type = value_of_initializer %float.make_type.loc10 [template = f64]
// CHECK:STDOUT: %.loc10_8.3: type = converted %float.make_type.loc10, %.loc10_8.2 [template = f64]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Div(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.div";
// CHECK:STDOUT:
@@ -203,7 +203,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -254,11 +254,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_14: init type = call constants.%Float(%.loc8_14.1) [template = f64]
// CHECK:STDOUT: %.loc8_14.2: type = value_of_initializer %float.make_type.loc8_14 [template = f64]
// CHECK:STDOUT: %.loc8_14.3: type = converted %float.make_type.loc8_14, %.loc8_14.2 [template = f64]
// CHECK:STDOUT: %.loc8_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_22: init type = call constants.%Float(%.loc8_22.1) [template = f64]
// CHECK:STDOUT: %.loc8_22.2: type = value_of_initializer %float.make_type.loc8_22 [template = f64]
// CHECK:STDOUT: %.loc8_22.3: type = converted %float.make_type.loc8_22, %.loc8_22.2 [template = f64]
@@ -277,19 +277,19 @@ 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: %.loc13_15.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_15.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_15: init type = call constants.%Float(%.loc13_15.1) [template = f64]
// CHECK:STDOUT: %.loc13_15.2: type = value_of_initializer %float.make_type.loc13_15 [template = f64]
// CHECK:STDOUT: %.loc13_15.3: type = converted %float.make_type.loc13_15, %.loc13_15.2 [template = f64]
// CHECK:STDOUT: %.loc13_23.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_23.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_23: init type = call constants.%Float(%.loc13_23.1) [template = f64]
// CHECK:STDOUT: %.loc13_23.2: type = value_of_initializer %float.make_type.loc13_23 [template = f64]
// CHECK:STDOUT: %.loc13_23.3: type = converted %float.make_type.loc13_23, %.loc13_23.2 [template = f64]
// CHECK:STDOUT: %.loc13_31.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_31.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_31: init type = call constants.%Float(%.loc13_31.1) [template = f64]
// CHECK:STDOUT: %.loc13_31.2: type = value_of_initializer %float.make_type.loc13_31 [template = f64]
// CHECK:STDOUT: %.loc13_31.3: type = converted %float.make_type.loc13_31, %.loc13_31.2 [template = f64]
// CHECK:STDOUT: %.loc13_39.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_39.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_39: init type = call constants.%Float(%.loc13_39.1) [template = f64]
// CHECK:STDOUT: %.loc13_39.2: type = value_of_initializer %float.make_type.loc13_39 [template = f64]
// CHECK:STDOUT: %.loc13_39.3: type = converted %float.make_type.loc13_39, %.loc13_39.2 [template = f64]
@@ -310,11 +310,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc17_21.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_21.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_21: init type = call constants.%Float(%.loc17_21.1) [template = f64]
// CHECK:STDOUT: %.loc17_21.2: type = value_of_initializer %float.make_type.loc17_21 [template = f64]
// CHECK:STDOUT: %.loc17_21.3: type = converted %float.make_type.loc17_21, %.loc17_21.2 [template = f64]
// CHECK:STDOUT: %.loc17_29.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_29.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_29: init type = call constants.%Float(%.loc17_29.1) [template = f64]
// CHECK:STDOUT: %.loc17_29.2: type = value_of_initializer %float.make_type.loc17_29 [template = f64]
// CHECK:STDOUT: %.loc17_29.3: type = converted %float.make_type.loc17_29, %.loc17_29.2 [template = f64]
@@ -336,15 +336,15 @@ 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: %.loc18_17.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_17.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_17: init type = call constants.%Float(%.loc18_17.1) [template = f64]
// CHECK:STDOUT: %.loc18_17.2: type = value_of_initializer %float.make_type.loc18_17 [template = f64]
// CHECK:STDOUT: %.loc18_17.3: type = converted %float.make_type.loc18_17, %.loc18_17.2 [template = f64]
// CHECK:STDOUT: %.loc18_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_25: init type = call constants.%Float(%.loc18_25.1) [template = f64]
// CHECK:STDOUT: %.loc18_25.2: type = value_of_initializer %float.make_type.loc18_25 [template = f64]
// CHECK:STDOUT: %.loc18_25.3: type = converted %float.make_type.loc18_25, %.loc18_25.2 [template = f64]
// CHECK:STDOUT: %.loc18_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_33: init type = call constants.%Float(%.loc18_33.1) [template = f64]
// CHECK:STDOUT: %.loc18_33.2: type = value_of_initializer %float.make_type.loc18_33 [template = f64]
// CHECK:STDOUT: %.loc18_33.3: type = converted %float.make_type.loc18_33, %.loc18_33.2 [template = f64]
@@ -361,11 +361,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc20_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%.loc20_25.1) [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_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%.loc20_33.1) [template = f64]
// CHECK:STDOUT: %.loc20_33.2: type = value_of_initializer %float.make_type.loc20_33 [template = f64]
// CHECK:STDOUT: %.loc20_33.3: type = converted %float.make_type.loc20_33, %.loc20_33.2 [template = f64]
@@ -384,19 +384,19 @@ 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: %.loc24_26.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_26.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%.loc24_26.1) [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_34.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_34.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%.loc24_34.1) [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_42.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_42.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%.loc24_42.1) [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_50.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_50.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%.loc24_50.1) [template = f64]
// CHECK:STDOUT: %.loc24_50.2: type = value_of_initializer %float.make_type.loc24_50 [template = f64]
// CHECK:STDOUT: %.loc24_50.3: type = converted %float.make_type.loc24_50, %.loc24_50.2 [template = f64]
@@ -417,11 +417,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc28_32.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_32.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%.loc28_32.1) [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_40.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_40.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%.loc28_40.1) [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]
@@ -437,7 +437,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TooFew(%a.param_patt: f64) -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/eq.carbon
Vendored
+11 -11
View File
@@ -36,7 +36,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// CHECK:STDOUT: --- float_eq.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -88,11 +88,11 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_10.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_10.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_10: init type = call constants.%Float(%.loc2_10.1) [template = f64]
// CHECK:STDOUT: %.loc2_10.2: type = value_of_initializer %float.make_type.loc2_10 [template = f64]
// CHECK:STDOUT: %.loc2_10.3: type = converted %float.make_type.loc2_10, %.loc2_10.2 [template = f64]
// CHECK:STDOUT: %.loc2_18.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_18.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_18: init type = call constants.%Float(%.loc2_18.1) [template = f64]
// CHECK:STDOUT: %.loc2_18.2: type = value_of_initializer %float.make_type.loc2_18 [template = f64]
// CHECK:STDOUT: %.loc2_18.3: type = converted %float.make_type.loc2_18, %.loc2_18.2 [template = f64]
@@ -129,11 +129,11 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc12_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc12_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc12_19: init type = call constants.%Float(%.loc12_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc12_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc12_27: init type = call constants.%Float(%.loc12_27.1) [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]
@@ -163,7 +163,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// CHECK:STDOUT: .Self = constants.%False
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type";
// CHECK:STDOUT:
@@ -226,7 +226,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -257,15 +257,15 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// 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: %.loc7_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc7_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc7_19: init type = call constants.%Float(%.loc7_19.1) [template = f64]
// CHECK:STDOUT: %.loc7_19.2: type = value_of_initializer %float.make_type.loc7_19 [template = f64]
// CHECK:STDOUT: %.loc7_19.3: type = converted %float.make_type.loc7_19, %.loc7_19.2 [template = f64]
// CHECK:STDOUT: %.loc7_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc7_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc7_27: init type = call constants.%Float(%.loc7_27.1) [template = f64]
// CHECK:STDOUT: %.loc7_27.2: type = value_of_initializer %float.make_type.loc7_27 [template = f64]
// CHECK:STDOUT: %.loc7_27.3: type = converted %float.make_type.loc7_27, %.loc7_27.2 [template = f64]
// CHECK:STDOUT: %.loc7_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc7_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc7_35: init type = call constants.%Float(%.loc7_35.1) [template = f64]
// CHECK:STDOUT: %.loc7_35.2: type = value_of_initializer %float.make_type.loc7_35 [template = f64]
// CHECK:STDOUT: %.loc7_35.3: type = converted %float.make_type.loc7_35, %.loc7_35.2 [template = f64]
@@ -278,7 +278,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.eq";
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @WrongResult(%a.param_patt: f64, %b.param_patt: f64) -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/greater.carbon
Vendored
+8 -8
View File
@@ -31,7 +31,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_greater.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -88,11 +88,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_15.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_15.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_15: init type = call constants.%Float(%.loc2_15.1) [template = f64]
// CHECK:STDOUT: %.loc2_15.2: type = value_of_initializer %float.make_type.loc2_15 [template = f64]
// CHECK:STDOUT: %.loc2_15.3: type = converted %float.make_type.loc2_15, %.loc2_15.2 [template = f64]
// CHECK:STDOUT: %.loc2_23.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_23.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_23: init type = call constants.%Float(%.loc2_23.1) [template = f64]
// CHECK:STDOUT: %.loc2_23.2: type = value_of_initializer %float.make_type.loc2_23 [template = f64]
// CHECK:STDOUT: %.loc2_23.3: type = converted %float.make_type.loc2_23, %.loc2_23.2 [template = f64]
@@ -112,11 +112,11 @@ fn RuntimeCall(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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc3_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_14: init type = call constants.%Float(%.loc3_14.1) [template = f64]
// CHECK:STDOUT: %.loc3_14.2: type = value_of_initializer %float.make_type.loc3_14 [template = f64]
// CHECK:STDOUT: %.loc3_14.3: type = converted %float.make_type.loc3_14, %.loc3_14.2 [template = f64]
// CHECK:STDOUT: %.loc3_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_22: init type = call constants.%Float(%.loc3_22.1) [template = f64]
// CHECK:STDOUT: %.loc3_22.2: type = value_of_initializer %float.make_type.loc3_22 [template = f64]
// CHECK:STDOUT: %.loc3_22.3: type = converted %float.make_type.loc3_22, %.loc3_22.2 [template = f64]
@@ -148,11 +148,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc16_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%.loc16_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%.loc16_27.1) [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]
@@ -182,7 +182,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: .Self = constants.%False
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/greater_eq.carbon
Vendored
+8 -8
View File
@@ -31,7 +31,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_greater_eq.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -88,11 +88,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_17.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_17.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_17: init type = call constants.%Float(%.loc2_17.1) [template = f64]
// CHECK:STDOUT: %.loc2_17.2: type = value_of_initializer %float.make_type.loc2_17 [template = f64]
// CHECK:STDOUT: %.loc2_17.3: type = converted %float.make_type.loc2_17, %.loc2_17.2 [template = f64]
// CHECK:STDOUT: %.loc2_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_25: init type = call constants.%Float(%.loc2_25.1) [template = f64]
// CHECK:STDOUT: %.loc2_25.2: type = value_of_initializer %float.make_type.loc2_25 [template = f64]
// CHECK:STDOUT: %.loc2_25.3: type = converted %float.make_type.loc2_25, %.loc2_25.2 [template = f64]
@@ -112,11 +112,11 @@ fn RuntimeCall(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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc3_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_14: init type = call constants.%Float(%.loc3_14.1) [template = f64]
// CHECK:STDOUT: %.loc3_14.2: type = value_of_initializer %float.make_type.loc3_14 [template = f64]
// CHECK:STDOUT: %.loc3_14.3: type = converted %float.make_type.loc3_14, %.loc3_14.2 [template = f64]
// CHECK:STDOUT: %.loc3_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_22: init type = call constants.%Float(%.loc3_22.1) [template = f64]
// CHECK:STDOUT: %.loc3_22.2: type = value_of_initializer %float.make_type.loc3_22 [template = f64]
// CHECK:STDOUT: %.loc3_22.3: type = converted %float.make_type.loc3_22, %.loc3_22.2 [template = f64]
@@ -148,11 +148,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc16_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%.loc16_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%.loc16_27.1) [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]
@@ -182,7 +182,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: .Self = constants.%False
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/less.carbon
Vendored
+8 -8
View File
@@ -31,7 +31,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_less.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -88,11 +88,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_12.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_12.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_12: init type = call constants.%Float(%.loc2_12.1) [template = f64]
// CHECK:STDOUT: %.loc2_12.2: type = value_of_initializer %float.make_type.loc2_12 [template = f64]
// CHECK:STDOUT: %.loc2_12.3: type = converted %float.make_type.loc2_12, %.loc2_12.2 [template = f64]
// CHECK:STDOUT: %.loc2_20.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_20.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_20: init type = call constants.%Float(%.loc2_20.1) [template = f64]
// CHECK:STDOUT: %.loc2_20.2: type = value_of_initializer %float.make_type.loc2_20 [template = f64]
// CHECK:STDOUT: %.loc2_20.3: type = converted %float.make_type.loc2_20, %.loc2_20.2 [template = f64]
@@ -112,11 +112,11 @@ fn RuntimeCall(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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc3_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_14: init type = call constants.%Float(%.loc3_14.1) [template = f64]
// CHECK:STDOUT: %.loc3_14.2: type = value_of_initializer %float.make_type.loc3_14 [template = f64]
// CHECK:STDOUT: %.loc3_14.3: type = converted %float.make_type.loc3_14, %.loc3_14.2 [template = f64]
// CHECK:STDOUT: %.loc3_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_22: init type = call constants.%Float(%.loc3_22.1) [template = f64]
// CHECK:STDOUT: %.loc3_22.2: type = value_of_initializer %float.make_type.loc3_22 [template = f64]
// CHECK:STDOUT: %.loc3_22.3: type = converted %float.make_type.loc3_22, %.loc3_22.2 [template = f64]
@@ -148,11 +148,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc16_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%.loc16_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%.loc16_27.1) [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]
@@ -182,7 +182,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: .Self = constants.%False
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/less_eq.carbon
Vendored
+8 -8
View File
@@ -31,7 +31,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_less_eq.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -88,11 +88,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_14: init type = call constants.%Float(%.loc2_14.1) [template = f64]
// CHECK:STDOUT: %.loc2_14.2: type = value_of_initializer %float.make_type.loc2_14 [template = f64]
// CHECK:STDOUT: %.loc2_14.3: type = converted %float.make_type.loc2_14, %.loc2_14.2 [template = f64]
// CHECK:STDOUT: %.loc2_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_22: init type = call constants.%Float(%.loc2_22.1) [template = f64]
// CHECK:STDOUT: %.loc2_22.2: type = value_of_initializer %float.make_type.loc2_22 [template = f64]
// CHECK:STDOUT: %.loc2_22.3: type = converted %float.make_type.loc2_22, %.loc2_22.2 [template = f64]
@@ -112,11 +112,11 @@ fn RuntimeCall(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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc3_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_14: init type = call constants.%Float(%.loc3_14.1) [template = f64]
// CHECK:STDOUT: %.loc3_14.2: type = value_of_initializer %float.make_type.loc3_14 [template = f64]
// CHECK:STDOUT: %.loc3_14.3: type = converted %float.make_type.loc3_14, %.loc3_14.2 [template = f64]
// CHECK:STDOUT: %.loc3_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc3_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc3_22: init type = call constants.%Float(%.loc3_22.1) [template = f64]
// CHECK:STDOUT: %.loc3_22.2: type = value_of_initializer %float.make_type.loc3_22 [template = f64]
// CHECK:STDOUT: %.loc3_22.3: type = converted %float.make_type.loc3_22, %.loc3_22.2 [template = f64]
@@ -148,11 +148,11 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc16_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_19: init type = call constants.%Float(%.loc16_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc16_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc16_27: init type = call constants.%Float(%.loc16_27.1) [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]
@@ -182,7 +182,7 @@ fn RuntimeCall(a: f64, b: f64) -> bool {
// CHECK:STDOUT: .Self = constants.%False
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/mul.carbon
Vendored
+30 -30
View File
@@ -53,7 +53,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- mul_sub.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -91,15 +91,15 @@ 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: %.loc2_11.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_11.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_11: init type = call constants.%Float(%.loc2_11.1) [template = f64]
// CHECK:STDOUT: %.loc2_11.2: type = value_of_initializer %float.make_type.loc2_11 [template = f64]
// CHECK:STDOUT: %.loc2_11.3: type = converted %float.make_type.loc2_11, %.loc2_11.2 [template = f64]
// CHECK:STDOUT: %.loc2_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_19: init type = call constants.%Float(%.loc2_19.1) [template = f64]
// CHECK:STDOUT: %.loc2_19.2: type = value_of_initializer %float.make_type.loc2_19 [template = f64]
// CHECK:STDOUT: %.loc2_19.3: type = converted %float.make_type.loc2_19, %.loc2_19.2 [template = f64]
// CHECK:STDOUT: %.loc2_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_27: init type = call constants.%Float(%.loc2_27.1) [template = f64]
// CHECK:STDOUT: %.loc2_27.2: type = value_of_initializer %float.make_type.loc2_27 [template = f64]
// CHECK:STDOUT: %.loc2_27.3: type = converted %float.make_type.loc2_27, %.loc2_27.2 [template = f64]
@@ -118,15 +118,15 @@ 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: %.loc4_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%.loc4_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%.loc4_27.1) [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_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%.loc4_35.1) [template = f64]
// CHECK:STDOUT: %.loc4_35.2: type = value_of_initializer %float.make_type.loc4_35 [template = f64]
// CHECK:STDOUT: %.loc4_35.3: type = converted %float.make_type.loc4_35, %.loc4_35.2 [template = f64]
@@ -137,7 +137,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: %.loc8_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc8_8.1) [template = f64]
// CHECK:STDOUT: %.loc8_8.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc8_8.3: type = converted %float.make_type, %.loc8_8.2 [template = f64]
@@ -145,7 +145,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %x: ref f64 = bind_name x, %x.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Mul(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.mul";
// CHECK:STDOUT:
@@ -173,7 +173,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -224,11 +224,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_14: init type = call constants.%Float(%.loc8_14.1) [template = f64]
// CHECK:STDOUT: %.loc8_14.2: type = value_of_initializer %float.make_type.loc8_14 [template = f64]
// CHECK:STDOUT: %.loc8_14.3: type = converted %float.make_type.loc8_14, %.loc8_14.2 [template = f64]
// CHECK:STDOUT: %.loc8_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_22: init type = call constants.%Float(%.loc8_22.1) [template = f64]
// CHECK:STDOUT: %.loc8_22.2: type = value_of_initializer %float.make_type.loc8_22 [template = f64]
// CHECK:STDOUT: %.loc8_22.3: type = converted %float.make_type.loc8_22, %.loc8_22.2 [template = f64]
@@ -247,19 +247,19 @@ 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: %.loc13_15.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_15.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_15: init type = call constants.%Float(%.loc13_15.1) [template = f64]
// CHECK:STDOUT: %.loc13_15.2: type = value_of_initializer %float.make_type.loc13_15 [template = f64]
// CHECK:STDOUT: %.loc13_15.3: type = converted %float.make_type.loc13_15, %.loc13_15.2 [template = f64]
// CHECK:STDOUT: %.loc13_23.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_23.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_23: init type = call constants.%Float(%.loc13_23.1) [template = f64]
// CHECK:STDOUT: %.loc13_23.2: type = value_of_initializer %float.make_type.loc13_23 [template = f64]
// CHECK:STDOUT: %.loc13_23.3: type = converted %float.make_type.loc13_23, %.loc13_23.2 [template = f64]
// CHECK:STDOUT: %.loc13_31.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_31.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_31: init type = call constants.%Float(%.loc13_31.1) [template = f64]
// CHECK:STDOUT: %.loc13_31.2: type = value_of_initializer %float.make_type.loc13_31 [template = f64]
// CHECK:STDOUT: %.loc13_31.3: type = converted %float.make_type.loc13_31, %.loc13_31.2 [template = f64]
// CHECK:STDOUT: %.loc13_39.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_39.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_39: init type = call constants.%Float(%.loc13_39.1) [template = f64]
// CHECK:STDOUT: %.loc13_39.2: type = value_of_initializer %float.make_type.loc13_39 [template = f64]
// CHECK:STDOUT: %.loc13_39.3: type = converted %float.make_type.loc13_39, %.loc13_39.2 [template = f64]
@@ -280,11 +280,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc17_21.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_21.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_21: init type = call constants.%Float(%.loc17_21.1) [template = f64]
// CHECK:STDOUT: %.loc17_21.2: type = value_of_initializer %float.make_type.loc17_21 [template = f64]
// CHECK:STDOUT: %.loc17_21.3: type = converted %float.make_type.loc17_21, %.loc17_21.2 [template = f64]
// CHECK:STDOUT: %.loc17_29.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_29.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_29: init type = call constants.%Float(%.loc17_29.1) [template = f64]
// CHECK:STDOUT: %.loc17_29.2: type = value_of_initializer %float.make_type.loc17_29 [template = f64]
// CHECK:STDOUT: %.loc17_29.3: type = converted %float.make_type.loc17_29, %.loc17_29.2 [template = f64]
@@ -306,15 +306,15 @@ 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: %.loc18_17.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_17.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_17: init type = call constants.%Float(%.loc18_17.1) [template = f64]
// CHECK:STDOUT: %.loc18_17.2: type = value_of_initializer %float.make_type.loc18_17 [template = f64]
// CHECK:STDOUT: %.loc18_17.3: type = converted %float.make_type.loc18_17, %.loc18_17.2 [template = f64]
// CHECK:STDOUT: %.loc18_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_25: init type = call constants.%Float(%.loc18_25.1) [template = f64]
// CHECK:STDOUT: %.loc18_25.2: type = value_of_initializer %float.make_type.loc18_25 [template = f64]
// CHECK:STDOUT: %.loc18_25.3: type = converted %float.make_type.loc18_25, %.loc18_25.2 [template = f64]
// CHECK:STDOUT: %.loc18_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_33: init type = call constants.%Float(%.loc18_33.1) [template = f64]
// CHECK:STDOUT: %.loc18_33.2: type = value_of_initializer %float.make_type.loc18_33 [template = f64]
// CHECK:STDOUT: %.loc18_33.3: type = converted %float.make_type.loc18_33, %.loc18_33.2 [template = f64]
@@ -331,11 +331,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc20_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%.loc20_25.1) [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_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%.loc20_33.1) [template = f64]
// CHECK:STDOUT: %.loc20_33.2: type = value_of_initializer %float.make_type.loc20_33 [template = f64]
// CHECK:STDOUT: %.loc20_33.3: type = converted %float.make_type.loc20_33, %.loc20_33.2 [template = f64]
@@ -354,19 +354,19 @@ 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: %.loc24_26.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_26.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%.loc24_26.1) [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_34.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_34.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%.loc24_34.1) [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_42.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_42.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%.loc24_42.1) [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_50.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_50.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%.loc24_50.1) [template = f64]
// CHECK:STDOUT: %.loc24_50.2: type = value_of_initializer %float.make_type.loc24_50 [template = f64]
// CHECK:STDOUT: %.loc24_50.3: type = converted %float.make_type.loc24_50, %.loc24_50.2 [template = f64]
@@ -387,11 +387,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc28_32.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_32.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%.loc28_32.1) [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_40.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_40.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%.loc28_40.1) [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]
@@ -407,7 +407,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TooFew(%a.param_patt: f64) -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/negate.carbon
Vendored
+25 -25
View File
@@ -74,7 +74,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_negate.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -109,11 +109,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_14: init type = call constants.%Float(%.loc2_14.1) [template = f64]
// CHECK:STDOUT: %.loc2_14.2: type = value_of_initializer %float.make_type.loc2_14 [template = f64]
// CHECK:STDOUT: %.loc2_14.3: type = converted %float.make_type.loc2_14, %.loc2_14.2 [template = f64]
// CHECK:STDOUT: %.loc2_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_22: init type = call constants.%Float(%.loc2_22.1) [template = f64]
// CHECK:STDOUT: %.loc2_22.2: type = value_of_initializer %float.make_type.loc2_22 [template = f64]
// CHECK:STDOUT: %.loc2_22.3: type = converted %float.make_type.loc2_22, %.loc2_22.2 [template = f64]
@@ -130,15 +130,15 @@ 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: %.loc4_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%.loc4_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%.loc4_27.1) [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_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%.loc4_35.1) [template = f64]
// CHECK:STDOUT: %.loc4_35.2: type = value_of_initializer %float.make_type.loc4_35 [template = f64]
// CHECK:STDOUT: %.loc4_35.3: type = converted %float.make_type.loc4_35, %.loc4_35.2 [template = f64]
@@ -149,13 +149,13 @@ 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: %.loc8_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc8_8.1) [template = f64]
// CHECK:STDOUT: %.loc8_8.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc8_8.3: type = converted %float.make_type, %.loc8_8.2 [template = f64]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Negate(%a.param_patt: f64) -> f64 = "float.negate";
// CHECK:STDOUT:
@@ -183,7 +183,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -232,7 +232,7 @@ 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_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_16.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_16.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc8_16.1) [template = f64]
// CHECK:STDOUT: %.loc8_16.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc8_16.3: type = converted %float.make_type, %.loc8_16.2 [template = f64]
@@ -247,15 +247,15 @@ 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: %.loc13_15.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_15.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_15: init type = call constants.%Float(%.loc13_15.1) [template = f64]
// CHECK:STDOUT: %.loc13_15.2: type = value_of_initializer %float.make_type.loc13_15 [template = f64]
// CHECK:STDOUT: %.loc13_15.3: type = converted %float.make_type.loc13_15, %.loc13_15.2 [template = f64]
// CHECK:STDOUT: %.loc13_23.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_23.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_23: init type = call constants.%Float(%.loc13_23.1) [template = f64]
// CHECK:STDOUT: %.loc13_23.2: type = value_of_initializer %float.make_type.loc13_23 [template = f64]
// CHECK:STDOUT: %.loc13_23.3: type = converted %float.make_type.loc13_23, %.loc13_23.2 [template = f64]
// CHECK:STDOUT: %.loc13_31.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_31.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_31: init type = call constants.%Float(%.loc13_31.1) [template = f64]
// CHECK:STDOUT: %.loc13_31.2: type = value_of_initializer %float.make_type.loc13_31 [template = f64]
// CHECK:STDOUT: %.loc13_31.3: type = converted %float.make_type.loc13_31, %.loc13_31.2 [template = f64]
@@ -272,7 +272,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc18_21.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_21.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc18_21.1) [template = f64]
// CHECK:STDOUT: %.loc18_21.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc18_21.3: type = converted %float.make_type, %.loc18_21.2 [template = f64]
@@ -290,11 +290,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc19_17.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc19_17.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc19_17: init type = call constants.%Float(%.loc19_17.1) [template = f64]
// CHECK:STDOUT: %.loc19_17.2: type = value_of_initializer %float.make_type.loc19_17 [template = f64]
// CHECK:STDOUT: %.loc19_17.3: type = converted %float.make_type.loc19_17, %.loc19_17.2 [template = f64]
// CHECK:STDOUT: %.loc19_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc19_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc19_25: init type = call constants.%Float(%.loc19_25.1) [template = f64]
// CHECK:STDOUT: %.loc19_25.2: type = value_of_initializer %float.make_type.loc19_25 [template = f64]
// CHECK:STDOUT: %.loc19_25.3: type = converted %float.make_type.loc19_25, %.loc19_25.2 [template = f64]
@@ -309,11 +309,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc21_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc21_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc21_25: init type = call constants.%Float(%.loc21_25.1) [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_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc21_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc21_33: init type = call constants.%Float(%.loc21_33.1) [template = f64]
// CHECK:STDOUT: %.loc21_33.2: type = value_of_initializer %float.make_type.loc21_33 [template = f64]
// CHECK:STDOUT: %.loc21_33.3: type = converted %float.make_type.loc21_33, %.loc21_33.2 [template = f64]
@@ -332,19 +332,19 @@ 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: %.loc32_26.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc32_26.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc32_26: init type = call constants.%Float(%.loc32_26.1) [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_34.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc32_34.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc32_34: init type = call constants.%Float(%.loc32_34.1) [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_42.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc32_42.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc32_42: init type = call constants.%Float(%.loc32_42.1) [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_50.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc32_50.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc32_50: init type = call constants.%Float(%.loc32_50.1) [template = f64]
// CHECK:STDOUT: %.loc32_50.2: type = value_of_initializer %float.make_type.loc32_50 [template = f64]
// CHECK:STDOUT: %.loc32_50.3: type = converted %float.make_type.loc32_50, %.loc32_50.2 [template = f64]
@@ -365,11 +365,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc43_32.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc43_32.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc43_32: init type = call constants.%Float(%.loc43_32.1) [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_40.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc43_40.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc43_40: init type = call constants.%Float(%.loc43_40.1) [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]
@@ -385,7 +385,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TooFew() -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/neq.carbon
Vendored
+11 -11
View File
@@ -36,7 +36,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// CHECK:STDOUT: --- float_neq.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -88,11 +88,11 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc2_11.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_11.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_11: init type = call constants.%Float(%.loc2_11.1) [template = f64]
// CHECK:STDOUT: %.loc2_11.2: type = value_of_initializer %float.make_type.loc2_11 [template = f64]
// CHECK:STDOUT: %.loc2_11.3: type = converted %float.make_type.loc2_11, %.loc2_11.2 [template = f64]
// CHECK:STDOUT: %.loc2_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_19: init type = call constants.%Float(%.loc2_19.1) [template = f64]
// CHECK:STDOUT: %.loc2_19.2: type = value_of_initializer %float.make_type.loc2_19 [template = f64]
// CHECK:STDOUT: %.loc2_19.3: type = converted %float.make_type.loc2_19, %.loc2_19.2 [template = f64]
@@ -129,11 +129,11 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc12_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc12_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc12_19: init type = call constants.%Float(%.loc12_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc12_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc12_27: init type = call constants.%Float(%.loc12_27.1) [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]
@@ -163,7 +163,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// CHECK:STDOUT: .Self = constants.%False
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type";
// CHECK:STDOUT:
@@ -226,7 +226,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -257,15 +257,15 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// 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: %.loc7_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc7_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc7_19: init type = call constants.%Float(%.loc7_19.1) [template = f64]
// CHECK:STDOUT: %.loc7_19.2: type = value_of_initializer %float.make_type.loc7_19 [template = f64]
// CHECK:STDOUT: %.loc7_19.3: type = converted %float.make_type.loc7_19, %.loc7_19.2 [template = f64]
// CHECK:STDOUT: %.loc7_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc7_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc7_27: init type = call constants.%Float(%.loc7_27.1) [template = f64]
// CHECK:STDOUT: %.loc7_27.2: type = value_of_initializer %float.make_type.loc7_27 [template = f64]
// CHECK:STDOUT: %.loc7_27.3: type = converted %float.make_type.loc7_27, %.loc7_27.2 [template = f64]
// CHECK:STDOUT: %.loc7_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc7_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc7_35: init type = call constants.%Float(%.loc7_35.1) [template = f64]
// CHECK:STDOUT: %.loc7_35.2: type = value_of_initializer %float.make_type.loc7_35 [template = f64]
// CHECK:STDOUT: %.loc7_35.3: type = converted %float.make_type.loc7_35, %.loc7_35.2 [template = f64]
@@ -278,7 +278,7 @@ fn WrongResult(a: f64, b: f64) -> f64 = "float.neq";
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @WrongResult(%a.param_patt: f64, %b.param_patt: f64) -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/float/sub.carbon
Vendored
+30 -30
View File
@@ -53,7 +53,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- float_sub.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -91,15 +91,15 @@ 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: %.loc2_11.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_11.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_11: init type = call constants.%Float(%.loc2_11.1) [template = f64]
// CHECK:STDOUT: %.loc2_11.2: type = value_of_initializer %float.make_type.loc2_11 [template = f64]
// CHECK:STDOUT: %.loc2_11.3: type = converted %float.make_type.loc2_11, %.loc2_11.2 [template = f64]
// CHECK:STDOUT: %.loc2_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_19: init type = call constants.%Float(%.loc2_19.1) [template = f64]
// CHECK:STDOUT: %.loc2_19.2: type = value_of_initializer %float.make_type.loc2_19 [template = f64]
// CHECK:STDOUT: %.loc2_19.3: type = converted %float.make_type.loc2_19, %.loc2_19.2 [template = f64]
// CHECK:STDOUT: %.loc2_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc2_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc2_27: init type = call constants.%Float(%.loc2_27.1) [template = f64]
// CHECK:STDOUT: %.loc2_27.2: type = value_of_initializer %float.make_type.loc2_27 [template = f64]
// CHECK:STDOUT: %.loc2_27.3: type = converted %float.make_type.loc2_27, %.loc2_27.2 [template = f64]
@@ -118,15 +118,15 @@ 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: %.loc4_19.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_19.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_19: init type = call constants.%Float(%.loc4_19.1) [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_27.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_27.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_27: init type = call constants.%Float(%.loc4_27.1) [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_35.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc4_35.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc4_35: init type = call constants.%Float(%.loc4_35.1) [template = f64]
// CHECK:STDOUT: %.loc4_35.2: type = value_of_initializer %float.make_type.loc4_35 [template = f64]
// CHECK:STDOUT: %.loc4_35.3: type = converted %float.make_type.loc4_35, %.loc4_35.2 [template = f64]
@@ -137,7 +137,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: %.loc8_8.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_8.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc8_8.1) [template = f64]
// CHECK:STDOUT: %.loc8_8.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc8_8.3: type = converted %float.make_type, %.loc8_8.2 [template = f64]
@@ -145,7 +145,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %x: ref f64 = bind_name x, %x.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Sub(%a.param_patt: f64, %b.param_patt: f64) -> f64 = "float.sub";
// CHECK:STDOUT:
@@ -173,7 +173,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: --- fail_bad_decl.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -224,11 +224,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_14.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_14.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_14: init type = call constants.%Float(%.loc8_14.1) [template = f64]
// CHECK:STDOUT: %.loc8_14.2: type = value_of_initializer %float.make_type.loc8_14 [template = f64]
// CHECK:STDOUT: %.loc8_14.3: type = converted %float.make_type.loc8_14, %.loc8_14.2 [template = f64]
// CHECK:STDOUT: %.loc8_22.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc8_22.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc8_22: init type = call constants.%Float(%.loc8_22.1) [template = f64]
// CHECK:STDOUT: %.loc8_22.2: type = value_of_initializer %float.make_type.loc8_22 [template = f64]
// CHECK:STDOUT: %.loc8_22.3: type = converted %float.make_type.loc8_22, %.loc8_22.2 [template = f64]
@@ -247,19 +247,19 @@ 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: %.loc13_15.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_15.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_15: init type = call constants.%Float(%.loc13_15.1) [template = f64]
// CHECK:STDOUT: %.loc13_15.2: type = value_of_initializer %float.make_type.loc13_15 [template = f64]
// CHECK:STDOUT: %.loc13_15.3: type = converted %float.make_type.loc13_15, %.loc13_15.2 [template = f64]
// CHECK:STDOUT: %.loc13_23.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_23.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_23: init type = call constants.%Float(%.loc13_23.1) [template = f64]
// CHECK:STDOUT: %.loc13_23.2: type = value_of_initializer %float.make_type.loc13_23 [template = f64]
// CHECK:STDOUT: %.loc13_23.3: type = converted %float.make_type.loc13_23, %.loc13_23.2 [template = f64]
// CHECK:STDOUT: %.loc13_31.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_31.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_31: init type = call constants.%Float(%.loc13_31.1) [template = f64]
// CHECK:STDOUT: %.loc13_31.2: type = value_of_initializer %float.make_type.loc13_31 [template = f64]
// CHECK:STDOUT: %.loc13_31.3: type = converted %float.make_type.loc13_31, %.loc13_31.2 [template = f64]
// CHECK:STDOUT: %.loc13_39.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc13_39.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc13_39: init type = call constants.%Float(%.loc13_39.1) [template = f64]
// CHECK:STDOUT: %.loc13_39.2: type = value_of_initializer %float.make_type.loc13_39 [template = f64]
// CHECK:STDOUT: %.loc13_39.3: type = converted %float.make_type.loc13_39, %.loc13_39.2 [template = f64]
@@ -280,11 +280,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc17_21.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_21.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_21: init type = call constants.%Float(%.loc17_21.1) [template = f64]
// CHECK:STDOUT: %.loc17_21.2: type = value_of_initializer %float.make_type.loc17_21 [template = f64]
// CHECK:STDOUT: %.loc17_21.3: type = converted %float.make_type.loc17_21, %.loc17_21.2 [template = f64]
// CHECK:STDOUT: %.loc17_29.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc17_29.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc17_29: init type = call constants.%Float(%.loc17_29.1) [template = f64]
// CHECK:STDOUT: %.loc17_29.2: type = value_of_initializer %float.make_type.loc17_29 [template = f64]
// CHECK:STDOUT: %.loc17_29.3: type = converted %float.make_type.loc17_29, %.loc17_29.2 [template = f64]
@@ -306,15 +306,15 @@ 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: %.loc18_17.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_17.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_17: init type = call constants.%Float(%.loc18_17.1) [template = f64]
// CHECK:STDOUT: %.loc18_17.2: type = value_of_initializer %float.make_type.loc18_17 [template = f64]
// CHECK:STDOUT: %.loc18_17.3: type = converted %float.make_type.loc18_17, %.loc18_17.2 [template = f64]
// CHECK:STDOUT: %.loc18_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_25: init type = call constants.%Float(%.loc18_25.1) [template = f64]
// CHECK:STDOUT: %.loc18_25.2: type = value_of_initializer %float.make_type.loc18_25 [template = f64]
// CHECK:STDOUT: %.loc18_25.3: type = converted %float.make_type.loc18_25, %.loc18_25.2 [template = f64]
// CHECK:STDOUT: %.loc18_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc18_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc18_33: init type = call constants.%Float(%.loc18_33.1) [template = f64]
// CHECK:STDOUT: %.loc18_33.2: type = value_of_initializer %float.make_type.loc18_33 [template = f64]
// CHECK:STDOUT: %.loc18_33.3: type = converted %float.make_type.loc18_33, %.loc18_33.2 [template = f64]
@@ -331,11 +331,11 @@ 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_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc20_25.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_25.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_25: init type = call constants.%Float(%.loc20_25.1) [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_33.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc20_33.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc20_33: init type = call constants.%Float(%.loc20_33.1) [template = f64]
// CHECK:STDOUT: %.loc20_33.2: type = value_of_initializer %float.make_type.loc20_33 [template = f64]
// CHECK:STDOUT: %.loc20_33.3: type = converted %float.make_type.loc20_33, %.loc20_33.2 [template = f64]
@@ -354,19 +354,19 @@ 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: %.loc24_26.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_26.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_26: init type = call constants.%Float(%.loc24_26.1) [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_34.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_34.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_34: init type = call constants.%Float(%.loc24_34.1) [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_42.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_42.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_42: init type = call constants.%Float(%.loc24_42.1) [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_50.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc24_50.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc24_50: init type = call constants.%Float(%.loc24_50.1) [template = f64]
// CHECK:STDOUT: %.loc24_50.2: type = value_of_initializer %float.make_type.loc24_50 [template = f64]
// CHECK:STDOUT: %.loc24_50.3: type = converted %float.make_type.loc24_50, %.loc24_50.2 [template = f64]
@@ -387,11 +387,11 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: %return.patt: bool = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: bool = out_param_pattern %return.patt, runtime_param2
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc28_32.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_32.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_32: init type = call constants.%Float(%.loc28_32.1) [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_40.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc28_40.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type.loc28_40: init type = call constants.%Float(%.loc28_40.1) [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]
@@ -407,7 +407,7 @@ fn RuntimeCallBadReturnType(a: f64, b: f64) -> bool {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @TooFew(%a.param_patt: f64) -> f64;
// CHECK:STDOUT:
toolchain/check/testdata/builtins/big_int/make_type.carbon → toolchain/check/testdata/builtins/int_literal/make_type.carbon
Vendored
+20 -20
View File
@@ -4,15 +4,15 @@
//
// AUTOUPDATE
// TIP: To test this file alone, run:
// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/builtins/big_int/make_type.carbon
// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/builtins/int_literal/make_type.carbon
// TIP: To dump output, run:
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/builtins/big_int/make_type.carbon
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/builtins/int_literal/make_type.carbon
// --- types.carbon
library "[[@TEST_NAME]]";
fn BigInt() -> type = "big_int.make_type";
fn IntLiteral() -> type = "int_literal.make_type";
// --- use_types.carbon
@@ -20,14 +20,14 @@ library "[[@TEST_NAME]]";
import library "types";
var i: BigInt();
var i: IntLiteral();
// CHECK:STDOUT: --- types.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %BigInt.type: type = fn_type @BigInt [template]
// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %BigInt: %BigInt.type = struct_value () [template]
// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
@@ -40,10 +40,10 @@ var i: BigInt();
// CHECK:STDOUT: file {
// CHECK:STDOUT: package: <namespace> = namespace [template] {
// CHECK:STDOUT: .Core = imports.%Core
// CHECK:STDOUT: .BigInt = %BigInt.decl
// CHECK:STDOUT: .IntLiteral = %IntLiteral.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %BigInt.decl: %BigInt.type = fn_decl @BigInt [template = constants.%BigInt] {
// CHECK:STDOUT: %IntLiteral.decl: %IntLiteral.type = fn_decl @IntLiteral [template = constants.%IntLiteral] {
// CHECK:STDOUT: %return.patt: type = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: type = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
@@ -52,18 +52,18 @@ var i: BigInt();
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @BigInt() -> type = "big_int.make_type";
// CHECK:STDOUT: fn @IntLiteral() -> type = "int_literal.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: --- use_types.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %BigInt.type: type = fn_type @BigInt [template]
// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %BigInt: %BigInt.type = struct_value () [template]
// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %import_ref: %BigInt.type = import_ref Main//types, inst+7, loaded [template = constants.%BigInt]
// CHECK:STDOUT: %import_ref: %IntLiteral.type = import_ref Main//types, inst+7, loaded [template = constants.%IntLiteral]
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/...
@@ -72,19 +72,19 @@ var i: BigInt();
// CHECK:STDOUT:
// CHECK:STDOUT: file {
// CHECK:STDOUT: package: <namespace> = namespace [template] {
// CHECK:STDOUT: .BigInt = imports.%import_ref
// CHECK:STDOUT: .IntLiteral = imports.%import_ref
// CHECK:STDOUT: .Core = imports.%Core
// CHECK:STDOUT: .i = %i
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %default.import = import <invalid>
// CHECK:STDOUT: %BigInt.ref: %BigInt.type = name_ref BigInt, imports.%import_ref [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type: init type = call %BigInt.ref() [template = Core.BigInt]
// CHECK:STDOUT: %.loc6_15.1: type = value_of_initializer %big_int.make_type [template = Core.BigInt]
// CHECK:STDOUT: %.loc6_15.2: type = converted %big_int.make_type, %.loc6_15.1 [template = Core.BigInt]
// CHECK:STDOUT: %i.var: ref Core.BigInt = var i
// CHECK:STDOUT: %i: ref Core.BigInt = bind_name i, %i.var
// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc6_19.1: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc6_19.2: type = converted %int_literal.make_type, %.loc6_19.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %i.var: ref Core.IntLiteral = var i
// CHECK:STDOUT: %i: ref Core.IntLiteral = bind_name i, %i.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @BigInt() -> type = "big_int.make_type";
// CHECK:STDOUT: fn @IntLiteral() -> type = "int_literal.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/deduce/int_float.carbon
Vendored
+108 -108
View File
@@ -12,11 +12,11 @@
library "[[@TEST_NAME]]";
fn F[N:! Core.BigInt()](n: Core.Int(N)) -> Core.BigInt() {
fn F[N:! Core.IntLiteral()](n: Core.Int(N)) -> Core.IntLiteral() {
return N;
}
fn G(a: i64) -> Core.BigInt() {
fn G(a: i64) -> Core.IntLiteral() {
return F(a);
}
@@ -25,31 +25,31 @@ fn G(a: i64) -> Core.BigInt() {
library "[[@TEST_NAME]]";
// TODO: This should pass once we accept symbolic widths for Core.Float.
// CHECK:STDERR: fail_todo_float.carbon:[[@LINE+3]]:28: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: fn F[N:! Core.BigInt()](n: Core.Float(N)) -> Core.BigInt() {
// CHECK:STDERR: ^~~~~~~~~~~~~
fn F[N:! Core.BigInt()](n: Core.Float(N)) -> Core.BigInt() {
// CHECK:STDERR: fail_todo_float.carbon:[[@LINE+3]]:32: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: fn F[N:! Core.IntLiteral()](n: Core.Float(N)) -> Core.IntLiteral() {
// CHECK:STDERR: ^~~~~~~~~~~~~
fn F[N:! Core.IntLiteral()](n: Core.Float(N)) -> Core.IntLiteral() {
return N;
}
fn G(a: f64) -> Core.BigInt() {
fn G(a: f64) -> Core.IntLiteral() {
return F(a);
}
// CHECK:STDOUT: --- int.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %BigInt.type: type = fn_type @BigInt [template]
// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %BigInt: %BigInt.type = struct_value () [template]
// CHECK:STDOUT: %N: Core.BigInt = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template]
// CHECK:STDOUT: %N: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
// CHECK:STDOUT: %Int: %Int.type = struct_value () [template]
// CHECK:STDOUT: %.2: type = int_type signed, %N [symbolic]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %.3: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.3: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %.4: type = int_type signed, %.3 [template]
// CHECK:STDOUT: %G.type: type = fn_type @G [template]
// CHECK:STDOUT: %G: %G.type = struct_value () [template]
@@ -58,12 +58,12 @@ fn G(a: f64) -> Core.BigInt() {
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .BigInt = %import_ref.1
// CHECK:STDOUT: .IntLiteral = %import_ref.1
// CHECK:STDOUT: .Int = %import_ref.2
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/...
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %BigInt.type = import_ref Core//prelude/types, inst+7, loaded [template = constants.%BigInt]
// CHECK:STDOUT: %import_ref.1: %IntLiteral.type = import_ref Core//prelude/types, inst+7, loaded [template = constants.%IntLiteral]
// CHECK:STDOUT: %import_ref.2: %Int.type = import_ref Core//prelude/types, inst+30, loaded [template = constants.%Int]
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -75,97 +75,97 @@ fn G(a: f64) -> Core.BigInt() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %N.patt.loc4_6.1: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: Core.BigInt = value_param_pattern %N.patt.loc4_6.1, runtime_param<invalid> [symbolic = %N.patt.loc4_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %n.patt: @F.%.loc4_36 (%.2) = binding_pattern n
// CHECK:STDOUT: %n.param_patt: @F.%.loc4_36 (%.2) = value_param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %return.patt: Core.BigInt = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.BigInt = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %N.patt.loc4_6.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: Core.IntLiteral = value_param_pattern %N.patt.loc4_6.1, runtime_param<invalid> [symbolic = %N.patt.loc4_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %n.patt: @F.%.loc4_40 (%.2) = binding_pattern n
// CHECK:STDOUT: %n.param_patt: @F.%.loc4_40 (%.2) = value_param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %return.patt: Core.IntLiteral = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.IntLiteral = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Core.ref.loc4_10: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref.loc4_14: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type.loc4_21: init type = call %BigInt.ref.loc4_14() [template = Core.BigInt]
// CHECK:STDOUT: %.loc4_22.1: type = value_of_initializer %big_int.make_type.loc4_21 [template = Core.BigInt]
// CHECK:STDOUT: %.loc4_22.2: type = converted %big_int.make_type.loc4_21, %.loc4_22.1 [template = Core.BigInt]
// CHECK:STDOUT: %Core.ref.loc4_28: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref.loc4_14: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type.loc4_25: init type = call %IntLiteral.ref.loc4_14() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc4_26.1: type = value_of_initializer %int_literal.make_type.loc4_25 [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc4_26.2: type = converted %int_literal.make_type.loc4_25, %.loc4_26.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %Core.ref.loc4_32: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %Int.ref: %Int.type = name_ref Int, imports.%import_ref.2 [template = constants.%Int]
// CHECK:STDOUT: %N.ref.loc4: Core.BigInt = name_ref N, %N.loc4_6.1 [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %int.make_type_signed: init type = call %Int.ref(%N.ref.loc4) [symbolic = %.loc4_36 (constants.%.2)]
// CHECK:STDOUT: %.loc4_38.1: type = value_of_initializer %int.make_type_signed [symbolic = %.loc4_36 (constants.%.2)]
// CHECK:STDOUT: %.loc4_38.2: type = converted %int.make_type_signed, %.loc4_38.1 [symbolic = %.loc4_36 (constants.%.2)]
// CHECK:STDOUT: %Core.ref.loc4_44: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref.loc4_48: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type.loc4_55: init type = call %BigInt.ref.loc4_48() [template = Core.BigInt]
// CHECK:STDOUT: %.loc4_56.1: type = value_of_initializer %big_int.make_type.loc4_55 [template = Core.BigInt]
// CHECK:STDOUT: %.loc4_56.2: type = converted %big_int.make_type.loc4_55, %.loc4_56.1 [template = Core.BigInt]
// CHECK:STDOUT: %N.param: Core.BigInt = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc4_6.1: Core.BigInt = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %n.param: @F.%.loc4_36 (%.2) = value_param runtime_param0
// CHECK:STDOUT: %n: @F.%.loc4_36 (%.2) = bind_name n, %n.param
// CHECK:STDOUT: %return.param: ref Core.BigInt = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.BigInt = return_slot %return.param
// CHECK:STDOUT: %N.ref.loc4: Core.IntLiteral = name_ref N, %N.loc4_6.1 [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %int.make_type_signed: init type = call %Int.ref(%N.ref.loc4) [symbolic = %.loc4_40 (constants.%.2)]
// CHECK:STDOUT: %.loc4_42.1: type = value_of_initializer %int.make_type_signed [symbolic = %.loc4_40 (constants.%.2)]
// CHECK:STDOUT: %.loc4_42.2: type = converted %int.make_type_signed, %.loc4_42.1 [symbolic = %.loc4_40 (constants.%.2)]
// CHECK:STDOUT: %Core.ref.loc4_48: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref.loc4_52: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type.loc4_63: init type = call %IntLiteral.ref.loc4_52() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc4_64.1: type = value_of_initializer %int_literal.make_type.loc4_63 [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc4_64.2: type = converted %int_literal.make_type.loc4_63, %.loc4_64.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %N.param: Core.IntLiteral = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc4_6.1: Core.IntLiteral = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %n.param: @F.%.loc4_40 (%.2) = value_param runtime_param0
// CHECK:STDOUT: %n: @F.%.loc4_40 (%.2) = bind_name n, %n.param
// CHECK:STDOUT: %return.param: ref Core.IntLiteral = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.IntLiteral = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {
// CHECK:STDOUT: %a.patt: %.4 = binding_pattern a
// CHECK:STDOUT: %a.param_patt: %.4 = value_param_pattern %a.patt, runtime_param0
// CHECK:STDOUT: %return.patt: Core.BigInt = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.BigInt = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %return.patt: Core.IntLiteral = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.IntLiteral = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc8_9.1: Core.BigInt = int_value 64 [template = constants.%.3]
// CHECK:STDOUT: %.loc8_9.1: Core.IntLiteral = int_value 64 [template = constants.%.3]
// CHECK:STDOUT: %int.make_type_signed: init type = call constants.%Int(%.loc8_9.1) [template = constants.%.4]
// CHECK:STDOUT: %.loc8_9.2: type = value_of_initializer %int.make_type_signed [template = constants.%.4]
// CHECK:STDOUT: %.loc8_9.3: type = converted %int.make_type_signed, %.loc8_9.2 [template = constants.%.4]
// CHECK:STDOUT: %Core.ref: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type: init type = call %BigInt.ref() [template = Core.BigInt]
// CHECK:STDOUT: %.loc8_29.1: type = value_of_initializer %big_int.make_type [template = Core.BigInt]
// CHECK:STDOUT: %.loc8_29.2: type = converted %big_int.make_type, %.loc8_29.1 [template = Core.BigInt]
// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc8_33.1: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc8_33.2: type = converted %int_literal.make_type, %.loc8_33.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %a.param: %.4 = value_param runtime_param0
// CHECK:STDOUT: %a: %.4 = bind_name a, %a.param
// CHECK:STDOUT: %return.param: ref Core.BigInt = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.BigInt = return_slot %return.param
// CHECK:STDOUT: %return.param: ref Core.IntLiteral = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.IntLiteral = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @BigInt() -> type = "big_int.make_type";
// CHECK:STDOUT: fn @IntLiteral() -> type = "int_literal.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.BigInt) -> type = "int.make_type_signed";
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.IntLiteral) -> type = "int.make_type_signed";
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%N.loc4_6.1: Core.BigInt) {
// CHECK:STDOUT: %N.loc4_6.2: Core.BigInt = bind_symbolic_name N, 0 [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc4_6.2: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %.loc4_36: type = int_type signed, %N.loc4_6.2 [symbolic = %.loc4_36 (constants.%.2)]
// CHECK:STDOUT: generic fn @F(%N.loc4_6.1: Core.IntLiteral) {
// CHECK:STDOUT: %N.loc4_6.2: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc4_6.2: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %.loc4_40: type = int_type signed, %N.loc4_6.2 [symbolic = %.loc4_40 (constants.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%N.param_patt: Core.BigInt](%n.param_patt: @F.%.loc4_36 (%.2)) -> Core.BigInt {
// CHECK:STDOUT: fn[%N.param_patt: Core.IntLiteral](%n.param_patt: @F.%.loc4_40 (%.2)) -> Core.IntLiteral {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %N.ref.loc5: Core.BigInt = name_ref N, %N.loc4_6.1 [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: %N.ref.loc5: Core.IntLiteral = name_ref N, %N.loc4_6.1 [symbolic = %N.loc4_6.2 (constants.%N)]
// CHECK:STDOUT: return %N.ref.loc5
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G(%a.param_patt: %.4) -> Core.BigInt {
// CHECK:STDOUT: fn @G(%a.param_patt: %.4) -> Core.IntLiteral {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %a.ref: %.4 = name_ref a, %a
// CHECK:STDOUT: %.loc9_10: <specific function> = specific_function %F.ref, @F(constants.%.3) [template = constants.%.5]
// CHECK:STDOUT: %F.call: init Core.BigInt = call %.loc9_10(%a.ref)
// CHECK:STDOUT: %.loc9_14.1: Core.BigInt = value_of_initializer %F.call
// CHECK:STDOUT: %.loc9_14.2: Core.BigInt = converted %F.call, %.loc9_14.1
// CHECK:STDOUT: %F.call: init Core.IntLiteral = call %.loc9_10(%a.ref)
// CHECK:STDOUT: %.loc9_14.1: Core.IntLiteral = value_of_initializer %F.call
// CHECK:STDOUT: %.loc9_14.2: Core.IntLiteral = converted %F.call, %.loc9_14.1
// CHECK:STDOUT: return %.loc9_14.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%N) {
// CHECK:STDOUT: %N.loc4_6.2 => constants.%N
// CHECK:STDOUT: %N.patt.loc4_6.2 => constants.%N
// CHECK:STDOUT: %.loc4_36 => constants.%.2
// CHECK:STDOUT: %.loc4_40 => constants.%.2
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @F(constants.%.3) {
// CHECK:STDOUT: %N.loc4_6.2 => constants.%.3
// CHECK:STDOUT: %N.patt.loc4_6.2 => constants.%.3
// CHECK:STDOUT: %.loc4_36 => constants.%.4
// CHECK:STDOUT: %.loc4_40 => constants.%.4
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
@@ -173,28 +173,28 @@ fn G(a: f64) -> Core.BigInt() {
// CHECK:STDOUT: --- fail_todo_float.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %BigInt.type: type = fn_type @BigInt [template]
// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %BigInt: %BigInt.type = struct_value () [template]
// CHECK:STDOUT: %N: Core.BigInt = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template]
// CHECK:STDOUT: %N: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %F.type: type = fn_type @F [template]
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %G.type: type = fn_type @G [template]
// CHECK:STDOUT: %G: %G.type = struct_value () [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .BigInt = %import_ref.1
// CHECK:STDOUT: .IntLiteral = %import_ref.1
// CHECK:STDOUT: .Float = %import_ref.2
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/...
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %BigInt.type = import_ref Core//prelude/types, inst+7, loaded [template = constants.%BigInt]
// CHECK:STDOUT: %import_ref.1: %IntLiteral.type = import_ref Core//prelude/types, inst+7, loaded [template = constants.%IntLiteral]
// CHECK:STDOUT: %import_ref.2: %Float.type = import_ref Core//prelude/types, inst+60, loaded [template = constants.%Float]
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -206,76 +206,76 @@ fn G(a: f64) -> Core.BigInt() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] {
// CHECK:STDOUT: %N.patt.loc8_6.1: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: Core.BigInt = value_param_pattern %N.patt.loc8_6.1, runtime_param<invalid> [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.patt.loc8_6.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: Core.IntLiteral = value_param_pattern %N.patt.loc8_6.1, runtime_param<invalid> [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)]
// CHECK:STDOUT: %n.patt: <error> = binding_pattern n
// CHECK:STDOUT: %n.param_patt: <error> = value_param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %return.patt: Core.BigInt = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.BigInt = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %return.patt: Core.IntLiteral = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.IntLiteral = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Core.ref.loc8_10: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref.loc8_14: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type.loc8_21: init type = call %BigInt.ref.loc8_14() [template = Core.BigInt]
// CHECK:STDOUT: %.loc8_22.1: type = value_of_initializer %big_int.make_type.loc8_21 [template = Core.BigInt]
// CHECK:STDOUT: %.loc8_22.2: type = converted %big_int.make_type.loc8_21, %.loc8_22.1 [template = Core.BigInt]
// CHECK:STDOUT: %Core.ref.loc8_28: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref.loc8_14: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type.loc8_25: init type = call %IntLiteral.ref.loc8_14() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc8_26.1: type = value_of_initializer %int_literal.make_type.loc8_25 [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc8_26.2: type = converted %int_literal.make_type.loc8_25, %.loc8_26.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %Core.ref.loc8_32: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %Float.ref: %Float.type = name_ref Float, imports.%import_ref.2 [template = constants.%Float]
// CHECK:STDOUT: %N.ref.loc8: Core.BigInt = name_ref N, %N.loc8_6.1 [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %N.ref.loc8: Core.IntLiteral = name_ref N, %N.loc8_6.1 [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %float.make_type: init type = call %Float.ref(%N.ref.loc8)
// CHECK:STDOUT: %.loc8_40.1: type = value_of_initializer %float.make_type
// CHECK:STDOUT: %.loc8_40.2: type = converted %float.make_type, %.loc8_40.1
// CHECK:STDOUT: %Core.ref.loc8_46: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref.loc8_50: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type.loc8_57: init type = call %BigInt.ref.loc8_50() [template = Core.BigInt]
// CHECK:STDOUT: %.loc8_58.1: type = value_of_initializer %big_int.make_type.loc8_57 [template = Core.BigInt]
// CHECK:STDOUT: %.loc8_58.2: type = converted %big_int.make_type.loc8_57, %.loc8_58.1 [template = Core.BigInt]
// CHECK:STDOUT: %N.param: Core.BigInt = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc8_6.1: Core.BigInt = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %.loc8_44.1: type = value_of_initializer %float.make_type
// CHECK:STDOUT: %.loc8_44.2: type = converted %float.make_type, %.loc8_44.1
// CHECK:STDOUT: %Core.ref.loc8_50: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref.loc8_54: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type.loc8_65: init type = call %IntLiteral.ref.loc8_54() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc8_66.1: type = value_of_initializer %int_literal.make_type.loc8_65 [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc8_66.2: type = converted %int_literal.make_type.loc8_65, %.loc8_66.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %N.param: Core.IntLiteral = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc8_6.1: Core.IntLiteral = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %n.param: <error> = value_param runtime_param0
// CHECK:STDOUT: %n: <error> = bind_name n, %n.param
// CHECK:STDOUT: %return.param: ref Core.BigInt = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.BigInt = return_slot %return.param
// CHECK:STDOUT: %return.param: ref Core.IntLiteral = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.IntLiteral = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {
// 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: Core.BigInt = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.BigInt = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: %return.patt: Core.IntLiteral = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: Core.IntLiteral = out_param_pattern %return.patt, runtime_param1
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc12_9.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc12_9.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc12_9.1) [template = f64]
// CHECK:STDOUT: %.loc12_9.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc12_9.3: type = converted %float.make_type, %.loc12_9.2 [template = f64]
// CHECK:STDOUT: %Core.ref: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type: init type = call %BigInt.ref() [template = Core.BigInt]
// CHECK:STDOUT: %.loc12_29.1: type = value_of_initializer %big_int.make_type [template = Core.BigInt]
// CHECK:STDOUT: %.loc12_29.2: type = converted %big_int.make_type, %.loc12_29.1 [template = Core.BigInt]
// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc12_33.1: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc12_33.2: type = converted %int_literal.make_type, %.loc12_33.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %a.param: f64 = value_param runtime_param0
// CHECK:STDOUT: %a: f64 = bind_name a, %a.param
// CHECK:STDOUT: %return.param: ref Core.BigInt = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.BigInt = return_slot %return.param
// CHECK:STDOUT: %return.param: ref Core.IntLiteral = out_param runtime_param1
// CHECK:STDOUT: %return: ref Core.IntLiteral = return_slot %return.param
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @BigInt() -> type = "big_int.make_type";
// CHECK:STDOUT: fn @IntLiteral() -> type = "int_literal.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @F(%N.loc8_6.1: Core.BigInt) {
// CHECK:STDOUT: %N.loc8_6.2: Core.BigInt = bind_symbolic_name N, 0 [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc8_6.2: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)]
// CHECK:STDOUT: generic fn @F(%N.loc8_6.1: Core.IntLiteral) {
// CHECK:STDOUT: %N.loc8_6.2: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc8_6.2: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%N.param_patt: Core.BigInt](%n.param_patt: <error>) -> Core.BigInt {
// CHECK:STDOUT: fn[%N.param_patt: Core.IntLiteral](%n.param_patt: <error>) -> Core.IntLiteral {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %N.ref.loc9: Core.BigInt = name_ref N, %N.loc8_6.1 [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: %N.ref.loc9: Core.IntLiteral = name_ref N, %N.loc8_6.1 [symbolic = %N.loc8_6.2 (constants.%N)]
// CHECK:STDOUT: return %N.ref.loc9
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G(%a.param_patt: f64) -> Core.BigInt {
// CHECK:STDOUT: fn @G(%a.param_patt: f64) -> Core.IntLiteral {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F]
// CHECK:STDOUT: %a.ref: f64 = name_ref a, %a
toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon
Vendored
+3 -3
View File
@@ -23,7 +23,7 @@ fn Run() {
// CHECK:STDOUT: --- fail_return_type_mismatch.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -82,7 +82,7 @@ fn Run() {
// CHECK:STDOUT: %return.patt: f64 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc11_13.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc11_13.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc11_13.1) [template = f64]
// CHECK:STDOUT: %.loc11_13.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc11_13.3: type = converted %float.make_type, %.loc11_13.2 [template = f64]
@@ -112,7 +112,7 @@ fn Run() {
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Foo() -> f64 {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/function/generic/resolve_used.carbon
Vendored
+135 -47
View File
@@ -12,13 +12,7 @@
library "[[@TEST_NAME]]";
// TODO: This declaration should be accepted, and the `var v` below should be
// rejected during monomorphization, once integer literals have the type
// `Core.IntLiteral(N)` as described in the design.
// CHECK:STDERR: fail_todo_call_monomorphization_error.carbon:[[@LINE+3]]:41: error: name `IntLiteral` not found [NameNotFound]
// CHECK:STDERR: fn ErrorIfNIsZero[N:! Core.BigInt()](n: Core.IntLiteral(N)) {
// CHECK:STDERR: ^~~~~~~~~~~~~~~
fn ErrorIfNIsZero[N:! Core.BigInt()](n: Core.IntLiteral(N)) {
fn ErrorIfNIsZero(N:! Core.IntLiteral()) {
// Check that we resolve the definition of a used specific function by
// ensuring we produce an error when doing so. Notionally this error is
// produced as a result of instantiating the `Core.Int` template, although
@@ -27,17 +21,28 @@ fn ErrorIfNIsZero[N:! Core.BigInt()](n: Core.IntLiteral(N)) {
}
fn CallNegative() {
// TODO: This should fail during monomorphization once integer literals have
// the type `Core.IntLiteral`.
// CHECK:STDERR: fail_todo_call_monomorphization_error.carbon:[[@LINE+9]]:3: error: cannot implicitly convert from `i32` to `Core.IntLiteral` [ImplicitAsConversionFailure]
// CHECK:STDERR: ErrorIfNIsZero(0);
// CHECK:STDERR: ^~~~~~~~~~~~~~~
// CHECK:STDERR: fail_todo_call_monomorphization_error.carbon:[[@LINE+6]]:3: note: type `i32` does not implement interface `ImplicitAs` [MissingImplInMemberAccessNote]
// CHECK:STDERR: ErrorIfNIsZero(0);
// CHECK:STDERR: ^~~~~~~~~~~~~~~
// CHECK:STDERR: fail_todo_call_monomorphization_error.carbon:[[@LINE-17]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere]
// CHECK:STDERR: fn ErrorIfNIsZero(N:! Core.IntLiteral()) {
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ErrorIfNIsZero(0);
}
// CHECK:STDOUT: --- fail_todo_call_monomorphization_error.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %BigInt.type: type = fn_type @BigInt [template]
// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template]
// CHECK:STDOUT: %.1: type = tuple_type () [template]
// CHECK:STDOUT: %BigInt: %BigInt.type = struct_value () [template]
// CHECK:STDOUT: %N: Core.BigInt = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template]
// CHECK:STDOUT: %N: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic]
// CHECK:STDOUT: %N.patt: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic]
// CHECK:STDOUT: %ErrorIfNIsZero.type: type = fn_type @ErrorIfNIsZero [template]
// CHECK:STDOUT: %ErrorIfNIsZero: %ErrorIfNIsZero.type = struct_value () [template]
// CHECK:STDOUT: %Int.type: type = fn_type @Int [template]
@@ -46,17 +51,41 @@ fn CallNegative() {
// CHECK:STDOUT: %CallNegative.type: type = fn_type @CallNegative [template]
// CHECK:STDOUT: %CallNegative: %CallNegative.type = struct_value () [template]
// CHECK:STDOUT: %.3: i32 = int_value 0 [template]
// CHECK:STDOUT: %ImplicitAs.type.1: type = generic_interface_type @ImplicitAs [template]
// CHECK:STDOUT: %ImplicitAs: %ImplicitAs.type.1 = struct_value () [template]
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic]
// CHECK:STDOUT: %ImplicitAs.type.2: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic]
// CHECK:STDOUT: %Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic]
// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic]
// CHECK:STDOUT: %Self.2: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic]
// CHECK:STDOUT: %Convert.type.1: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic]
// CHECK:STDOUT: %Convert.1: %Convert.type.1 = struct_value () [symbolic]
// CHECK:STDOUT: %.4: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.1 [symbolic]
// CHECK:STDOUT: %.5: %.4 = assoc_entity element0, imports.%import_ref.7 [symbolic]
// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(Core.IntLiteral) [template]
// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(Core.IntLiteral) [template]
// CHECK:STDOUT: %Convert.2: %Convert.type.2 = struct_value () [template]
// CHECK:STDOUT: %.6: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.2 [template]
// CHECK:STDOUT: %.7: %.6 = assoc_entity element0, imports.%import_ref.7 [template]
// CHECK:STDOUT: %.8: %.4 = assoc_entity element0, imports.%import_ref.8 [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [template] {
// CHECK:STDOUT: .BigInt = %import_ref.1
// CHECK:STDOUT: .IntLiteral = %import_ref.1
// CHECK:STDOUT: .Int = %import_ref.2
// CHECK:STDOUT: .ImplicitAs = %import_ref.3
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/...
// CHECK:STDOUT: }
// CHECK:STDOUT: %import_ref.1: %BigInt.type = import_ref Core//prelude/types, inst+7, loaded [template = constants.%BigInt]
// CHECK:STDOUT: %import_ref.1: %IntLiteral.type = import_ref Core//prelude/types, inst+7, loaded [template = constants.%IntLiteral]
// CHECK:STDOUT: %import_ref.2: %Int.type = import_ref Core//prelude/types, inst+30, loaded [template = constants.%Int]
// CHECK:STDOUT: %import_ref.3: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+49, loaded [template = constants.%ImplicitAs]
// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+55, unloaded
// CHECK:STDOUT: %import_ref.5: @ImplicitAs.%.1 (%.4) = import_ref Core//prelude/operators/as, inst+77, loaded [symbolic = @ImplicitAs.%.2 (constants.%.8)]
// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+70, unloaded
// CHECK:STDOUT: %import_ref.7 = import_ref Core//prelude/operators/as, inst+70, unloaded
// CHECK:STDOUT: %import_ref.8 = import_ref Core//prelude/operators/as, inst+70, unloaded
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
@@ -67,61 +96,120 @@ fn CallNegative() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %ErrorIfNIsZero.decl: %ErrorIfNIsZero.type = fn_decl @ErrorIfNIsZero [template = constants.%ErrorIfNIsZero] {
// CHECK:STDOUT: %N.patt.loc10_19.1: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_19.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: Core.BigInt = value_param_pattern %N.patt.loc10_19.1, runtime_param<invalid> [symbolic = %N.patt.loc10_19.2 (constants.%N.patt)]
// CHECK:STDOUT: %n.patt: <error> = binding_pattern n
// CHECK:STDOUT: %n.param_patt: <error> = value_param_pattern %n.patt, runtime_param0
// CHECK:STDOUT: %N.patt.loc4_19.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)]
// CHECK:STDOUT: %N.param_patt: Core.IntLiteral = value_param_pattern %N.patt.loc4_19.1, runtime_param<invalid> [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %Core.ref.loc10_23: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %BigInt.ref: %BigInt.type = name_ref BigInt, imports.%import_ref.1 [template = constants.%BigInt]
// CHECK:STDOUT: %big_int.make_type: init type = call %BigInt.ref() [template = Core.BigInt]
// CHECK:STDOUT: %.loc10_35.1: type = value_of_initializer %big_int.make_type [template = Core.BigInt]
// CHECK:STDOUT: %.loc10_35.2: type = converted %big_int.make_type, %.loc10_35.1 [template = Core.BigInt]
// CHECK:STDOUT: %Core.ref.loc10_41: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref: <error> = name_ref IntLiteral, <error> [template = <error>]
// CHECK:STDOUT: %N.ref.loc10: Core.BigInt = name_ref N, %N.loc10_19.1 [symbolic = %N.loc10_19.2 (constants.%N)]
// CHECK:STDOUT: %N.param: Core.BigInt = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc10_19.1: Core.BigInt = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc10_19.2 (constants.%N)]
// CHECK:STDOUT: %n.param: <error> = value_param runtime_param0
// CHECK:STDOUT: %n: <error> = bind_name n, %n.param
// CHECK:STDOUT: %Core.ref.loc4: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.1 [template = constants.%IntLiteral]
// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc4_39.1: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral]
// CHECK:STDOUT: %.loc4_39.2: type = converted %int_literal.make_type, %.loc4_39.1 [template = Core.IntLiteral]
// CHECK:STDOUT: %N.param: Core.IntLiteral = value_param runtime_param<invalid>
// CHECK:STDOUT: %N.loc4_19.1: Core.IntLiteral = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc4_19.2 (constants.%N)]
// CHECK:STDOUT: }
// CHECK:STDOUT: %CallNegative.decl: %CallNegative.type = fn_decl @CallNegative [template = constants.%CallNegative] {} {}
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @BigInt() -> type = "big_int.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ErrorIfNIsZero(%N.loc10_19.1: Core.BigInt) {
// CHECK:STDOUT: %N.loc10_19.2: Core.BigInt = bind_symbolic_name N, 0 [symbolic = %N.loc10_19.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc10_19.2: Core.BigInt = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_19.2 (constants.%N.patt)]
// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) {
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)]
// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt (constants.%Dest.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc15_18: type = int_type signed, %N.loc10_19.2 [symbolic = %.loc15_18 (constants.%.2)]
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
// CHECK:STDOUT: %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
// CHECK:STDOUT: %Convert.type: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic = %Convert.type (constants.%Convert.type.1)]
// CHECK:STDOUT: %Convert: @ImplicitAs.%Convert.type (%Convert.type.1) = struct_value () [symbolic = %Convert (constants.%Convert.1)]
// CHECK:STDOUT: %.1: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2), @ImplicitAs.%Convert.type (%Convert.type.1) [symbolic = %.1 (constants.%.4)]
// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.4) = assoc_entity element0, imports.%import_ref.7 [symbolic = %.2 (constants.%.5)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%N.param_patt: Core.BigInt](%n.param_patt: <error>) {
// CHECK:STDOUT: interface {
// CHECK:STDOUT: !members:
// CHECK:STDOUT: .Self = imports.%import_ref.4
// CHECK:STDOUT: .Convert = imports.%import_ref.5
// CHECK:STDOUT: witness = (imports.%import_ref.6)
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @IntLiteral() -> type = "int_literal.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @ErrorIfNIsZero(%N.loc4_19.1: Core.IntLiteral) {
// CHECK:STDOUT: %N.loc4_19.2: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic = %N.loc4_19.2 (constants.%N)]
// CHECK:STDOUT: %N.patt.loc4_19.2: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %.loc9_18: type = int_type signed, %N.loc4_19.2 [symbolic = %.loc9_18 (constants.%.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn(%N.param_patt: Core.IntLiteral) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Core.ref.loc15: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %Core.ref.loc9: <namespace> = name_ref Core, imports.%Core [template = imports.%Core]
// CHECK:STDOUT: %Int.ref: %Int.type = name_ref Int, imports.%import_ref.2 [template = constants.%Int]
// CHECK:STDOUT: %N.ref.loc15: Core.BigInt = name_ref N, %N.loc10_19.1 [symbolic = %N.loc10_19.2 (constants.%N)]
// CHECK:STDOUT: %int.make_type_signed: init type = call %Int.ref(%N.ref.loc15) [symbolic = %.loc15_18 (constants.%.2)]
// CHECK:STDOUT: %.loc15_20.1: type = value_of_initializer %int.make_type_signed [symbolic = %.loc15_18 (constants.%.2)]
// CHECK:STDOUT: %.loc15_20.2: type = converted %int.make_type_signed, %.loc15_20.1 [symbolic = %.loc15_18 (constants.%.2)]
// CHECK:STDOUT: %v.var: ref @ErrorIfNIsZero.%.loc15_18 (%.2) = var v
// CHECK:STDOUT: %v: ref @ErrorIfNIsZero.%.loc15_18 (%.2) = bind_name v, %v.var
// CHECK:STDOUT: %N.ref: Core.IntLiteral = name_ref N, %N.loc4_19.1 [symbolic = %N.loc4_19.2 (constants.%N)]
// CHECK:STDOUT: %int.make_type_signed: init type = call %Int.ref(%N.ref) [symbolic = %.loc9_18 (constants.%.2)]
// CHECK:STDOUT: %.loc9_20.1: type = value_of_initializer %int.make_type_signed [symbolic = %.loc9_18 (constants.%.2)]
// CHECK:STDOUT: %.loc9_20.2: type = converted %int.make_type_signed, %.loc9_20.1 [symbolic = %.loc9_18 (constants.%.2)]
// CHECK:STDOUT: %v.var: ref @ErrorIfNIsZero.%.loc9_18 (%.2) = var v
// CHECK:STDOUT: %v: ref @ErrorIfNIsZero.%.loc9_18 (%.2) = bind_name v, %v.var
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.BigInt) -> type = "int.make_type_signed";
// CHECK:STDOUT: fn @Int(%size.param_patt: Core.IntLiteral) -> type = "int.make_type_signed";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @CallNegative() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %ErrorIfNIsZero.ref: %ErrorIfNIsZero.type = name_ref ErrorIfNIsZero, file.%ErrorIfNIsZero.decl [template = constants.%ErrorIfNIsZero]
// CHECK:STDOUT: %.loc19: i32 = int_value 0 [template = constants.%.3]
// CHECK:STDOUT: %.loc24_18: i32 = int_value 0 [template = constants.%.3]
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(Core.IntLiteral) [template = constants.%ImplicitAs.type.3]
// CHECK:STDOUT: %.loc24_17.1: %.6 = specific_constant imports.%import_ref.5, @ImplicitAs(Core.IntLiteral) [template = constants.%.7]
// CHECK:STDOUT: %Convert.ref: %.6 = name_ref Convert, %.loc24_17.1 [template = constants.%.7]
// CHECK:STDOUT: %.loc24_17.2: Core.IntLiteral = converted %.loc24_18, <error> [template = <error>]
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Convert(constants.%Dest: type, constants.%Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2)) {
// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)]
// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.2)]
// CHECK:STDOUT: %Self: %ImplicitAs.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.2)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn[%self.param_patt: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest);
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ErrorIfNIsZero(constants.%N) {
// CHECK:STDOUT: %N.loc10_19.2 => constants.%N
// CHECK:STDOUT: %N.patt.loc10_19.2 => constants.%N
// CHECK:STDOUT: %N.loc4_19.2 => constants.%N
// CHECK:STDOUT: %N.patt.loc4_19.2 => constants.%N
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %Dest.patt => constants.%Dest
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.1) {
// CHECK:STDOUT: %Dest => constants.%Dest
// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.2
// CHECK:STDOUT: %Self => constants.%Self.1
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @ImplicitAs(Core.IntLiteral) {
// CHECK:STDOUT: %Dest => Core.IntLiteral
// CHECK:STDOUT: %Dest.patt => Core.IntLiteral
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3
// CHECK:STDOUT: %Self => constants.%Self.2
// CHECK:STDOUT: %Convert.type => constants.%Convert.type.2
// CHECK:STDOUT: %Convert => constants.%Convert.2
// CHECK:STDOUT: %.1 => constants.%.6
// CHECK:STDOUT: %.2 => constants.%.7
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/if_expr/fail_not_in_function.carbon
Vendored
+2 -2
View File
@@ -47,7 +47,7 @@ class C {
// CHECK:STDOUT: %.3: i32 = int_value 1 [template]
// CHECK:STDOUT: %.4: i32 = int_value 0 [template]
// CHECK:STDOUT: %C: type = class_type @C [template]
// CHECK:STDOUT: %.5: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.5: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %.6: type = unbound_element_type %C, i32 [template]
@@ -90,7 +90,7 @@ class C {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @__global_init() {
// CHECK:STDOUT: !entry:
toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon
Vendored
+3 -3
View File
@@ -51,7 +51,7 @@ var or_: F(true or true);
// CHECK:STDOUT: %F: %F.type = struct_value () [template]
// CHECK:STDOUT: %Int32.type: type = fn_type @Int32 [template]
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %.3: bool = bool_literal true [template]
@@ -94,7 +94,7 @@ var or_: F(true or true);
// CHECK:STDOUT: br !if.expr.result(%.loc13_20.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else:
// CHECK:STDOUT: %.loc13_29: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc13_29: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc13_29) [template = f64]
// CHECK:STDOUT: %.loc13_24.1: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc13_24.2: type = converted %float.make_type, %.loc13_24.1 [template = f64]
@@ -107,5 +107,5 @@ var or_: F(true or true);
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/return/fail_returned_var_type.carbon
Vendored
+3 -3
View File
@@ -27,7 +27,7 @@ fn Mismatch() -> i32 {
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %Mismatch.type: type = fn_type @Mismatch [template]
// CHECK:STDOUT: %Mismatch: %Mismatch.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %.3: f64 = float_literal 0 [template]
@@ -66,7 +66,7 @@ fn Mismatch() -> i32 {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Mismatch() -> i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc18_19.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc18_19.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc18_19.1) [template = f64]
// CHECK:STDOUT: %.loc18_19.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc18_19.3: type = converted %float.make_type, %.loc18_19.2 [template = f64]
@@ -76,5 +76,5 @@ fn Mismatch() -> i32 {
// CHECK:STDOUT: return <error>
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
toolchain/check/testdata/struct/fail_member_access_type.carbon
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ var y: i32 = x.b;
// CHECK:STDOUT: --- fail_member_access_type.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -46,7 +46,7 @@ var y: i32 = x.b;
// CHECK:STDOUT: .y = %y
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %.loc11_13.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc11_13.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc11_13.1) [template = f64]
// CHECK:STDOUT: %.loc11_13.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc11_13.3: type = converted %float.make_type, %.loc11_13.2 [template = f64]
@@ -60,7 +60,7 @@ var y: i32 = x.b;
// CHECK:STDOUT: %y: ref i32 = bind_name y, %y.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
toolchain/check/testdata/struct/member_access.carbon
Vendored
+3 -3
View File
@@ -15,7 +15,7 @@ var z: i32 = y;
// CHECK:STDOUT: --- member_access.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.1: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %.2: type = tuple_type () [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
@@ -47,7 +47,7 @@ var z: i32 = y;
// CHECK:STDOUT: .z = %z
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %.loc11_13.1: Core.BigInt = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %.loc11_13.1: Core.IntLiteral = int_value 64 [template = constants.%.1]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc11_13.1) [template = f64]
// CHECK:STDOUT: %.loc11_13.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc11_13.3: type = converted %float.make_type, %.loc11_13.2 [template = f64]
@@ -69,7 +69,7 @@ var z: i32 = y;
// CHECK:STDOUT: %z: ref i32 = bind_name z, %z.var
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32";
// CHECK:STDOUT:
toolchain/check/testdata/struct/reorder_fields.carbon
Vendored
+6 -6
View File
@@ -25,7 +25,7 @@ fn F() -> {.a: i32, .b: f64} {
// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template]
// CHECK:STDOUT: %MakeI32.type: type = fn_type @MakeI32 [template]
// CHECK:STDOUT: %MakeI32: %MakeI32.type = struct_value () [template]
// CHECK:STDOUT: %.2: Core.BigInt = int_value 64 [template]
// CHECK:STDOUT: %.2: Core.IntLiteral = int_value 64 [template]
// CHECK:STDOUT: %Float.type: type = fn_type @Float [template]
// CHECK:STDOUT: %Float: %Float.type = struct_value () [template]
// CHECK:STDOUT: %MakeF64.type: type = fn_type @MakeF64 [template]
@@ -71,7 +71,7 @@ fn F() -> {.a: i32, .b: f64} {
// CHECK:STDOUT: %return.patt: f64 = return_slot_pattern
// CHECK:STDOUT: %return.param_patt: f64 = out_param_pattern %return.patt, runtime_param0
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc12_17.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc12_17.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type: init type = call constants.%Float(%.loc12_17.1) [template = f64]
// CHECK:STDOUT: %.loc12_17.2: type = value_of_initializer %float.make_type [template = f64]
// CHECK:STDOUT: %.loc12_17.3: type = converted %float.make_type, %.loc12_17.2 [template = f64]
@@ -85,7 +85,7 @@ fn F() -> {.a: i32, .b: f64} {
// CHECK:STDOUT: %int.make_type_32.loc14: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc14_16.1: type = value_of_initializer %int.make_type_32.loc14 [template = i32]
// CHECK:STDOUT: %.loc14_16.2: type = converted %int.make_type_32.loc14, %.loc14_16.1 [template = i32]
// CHECK:STDOUT: %.loc14_25.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc14_25.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type.loc14: init type = call constants.%Float(%.loc14_25.1) [template = f64]
// CHECK:STDOUT: %.loc14_25.2: type = value_of_initializer %float.make_type.loc14 [template = f64]
// CHECK:STDOUT: %.loc14_25.3: type = converted %float.make_type.loc14, %.loc14_25.2 [template = f64]
@@ -99,7 +99,7 @@ fn F() -> {.a: i32, .b: f64} {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @MakeI32() -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.BigInt) -> type = "float.make_type";
// CHECK:STDOUT: fn @Float(%size.param_patt: Core.IntLiteral) -> type = "float.make_type";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @MakeF64() -> f64;
// CHECK:STDOUT:
@@ -108,7 +108,7 @@ fn F() -> {.a: i32, .b: f64} {
// CHECK:STDOUT: %int.make_type_32.loc15: init type = call constants.%Int32() [template = i32]
// CHECK:STDOUT: %.loc15_15.1: type = value_of_initializer %int.make_type_32.loc15 [template = i32]
// CHECK:STDOUT: %.loc15_15.2: type = converted %int.make_type_32.loc15, %.loc15_15.1 [template = i32]
// CHECK:STDOUT: %.loc15_24.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc15_24.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type.loc15: init type = call constants.%Float(%.loc15_24.1) [template = f64]
// CHECK:STDOUT: %.loc15_24.2: type = value_of_initializer %float.make_type.loc15 [template = f64]
// CHECK:STDOUT: %.loc15_24.3: type = converted %float.make_type.loc15, %.loc15_24.2 [template = f64]
@@ -125,7 +125,7 @@ fn F() -> {.a: i32, .b: f64} {
// CHECK:STDOUT: %struct.loc15: %.3 = struct_value (%.loc15_62.3, %.loc15_62.5)
// CHECK:STDOUT: %.loc15_63: %.3 = converted %.loc15_62.1, %struct.loc15
// CHECK:STDOUT: %x: %.3 = bind_name x, %.loc15_63
// CHECK:STDOUT: %.loc16_15.1: Core.BigInt = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %.loc16_15.1: Core.IntLiteral = int_value 64 [template = constants.%.2]
// CHECK:STDOUT: %float.make_type.loc16: init type = call constants.%Float(%.loc16_15.1) [template = f64]
// CHECK:STDOUT: %.loc16_15.2: type = value_of_initializer %float.make_type.loc16 [template = f64]
// CHECK:STDOUT: %.loc16_15.3: type = converted %float.make_type.loc16, %.loc16_15.2 [template = f64]
toolchain/lower/constant.cpp
+1 -1
View File
@@ -208,7 +208,7 @@ static auto EmitAsConstant(ConstantContext& context, SemIR::IntValue inst)
-> llvm::Constant* {
auto* type = context.GetType(inst.type_id);
// BigInt is represented as an empty struct. All other integer types are
// IntLiteral is represented as an empty struct. All other integer types are
// represented as an LLVM integer type.
if (!llvm::isa<llvm::IntegerType>(type)) {
auto* struct_type = llvm::dyn_cast<llvm::StructType>(type);
toolchain/lower/file_context.cpp
+1 -1
View File
@@ -491,7 +491,7 @@ static auto BuildTypeForInst(FileContext& context, SemIR::BuiltinInst inst)
// TODO: Decide how we want to represent `StringType`.
return llvm::PointerType::get(context.llvm_context(), 0);
case SemIR::BuiltinInstKind::BoundMethodType:
case SemIR::BuiltinInstKind::BigIntType:
case SemIR::BuiltinInstKind::IntLiteralType:
case SemIR::BuiltinInstKind::NamespaceType:
case SemIR::BuiltinInstKind::WitnessType:
// Return an empty struct as a placeholder.
toolchain/lower/handle_call.cpp
+1 -1
View File
@@ -93,9 +93,9 @@ static auto HandleBuiltinCall(FunctionContext& context, SemIR::InstId inst_id,
return;
}
case SemIR::BuiltinFunctionKind::BigIntMakeType:
case SemIR::BuiltinFunctionKind::BoolMakeType:
case SemIR::BuiltinFunctionKind::FloatMakeType:
case SemIR::BuiltinFunctionKind::IntLiteralMakeType:
case SemIR::BuiltinFunctionKind::IntMakeType32:
case SemIR::BuiltinFunctionKind::IntMakeTypeSigned:
case SemIR::BuiltinFunctionKind::IntMakeTypeUnsigned:
toolchain/lower/testdata/builtins/big_int.carbon → toolchain/lower/testdata/builtins/int_literal.carbon
Vendored
+6 -6
View File
@@ -4,18 +4,18 @@
//
// AUTOUPDATE
// TIP: To test this file alone, run:
// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/lower/testdata/builtins/big_int.carbon
// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/lower/testdata/builtins/int_literal.carbon
// TIP: To dump output, run:
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/lower/testdata/builtins/big_int.carbon
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/lower/testdata/builtins/int_literal.carbon
fn Make() -> type = "big_int.make_type";
fn Make() -> type = "int_literal.make_type";
fn Copy(x: Make()) -> Make() {
return x;
}
// CHECK:STDOUT: ; ModuleID = 'big_int.carbon'
// CHECK:STDOUT: source_filename = "big_int.carbon"
// CHECK:STDOUT: ; ModuleID = 'int_literal.carbon'
// CHECK:STDOUT: source_filename = "int_literal.carbon"
// CHECK:STDOUT:
// CHECK:STDOUT: define {} @_CCopy.Main({} %x) !dbg !4 {
// CHECK:STDOUT: entry:
@@ -28,7 +28,7 @@ fn Copy(x: Make()) -> Make() {
// CHECK:STDOUT: !0 = !{i32 7, !"Dwarf Version", i32 5}
// CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3}
// CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
// CHECK:STDOUT: !3 = !DIFile(filename: "big_int.carbon", directory: "")
// CHECK:STDOUT: !3 = !DIFile(filename: "int_literal.carbon", directory: "")
// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "Copy", linkageName: "_CCopy.Main", scope: null, file: !3, line: 13, type: !5, spFlags: DISPFlagDefinition, unit: !2)
// CHECK:STDOUT: !5 = !DISubroutineType(types: !6)
// CHECK:STDOUT: !6 = !{}
toolchain/sem_ir/builtin_function_kind.cpp
+5 -4
View File
@@ -79,7 +79,8 @@ using Bool = BuiltinType<InstId::BuiltinBoolType>;
struct AnyInt {
static auto Check(const File& sem_ir, ValidateState& state, TypeId type_id)
-> bool {
if (BuiltinType<InstId::BuiltinBigIntType>::Check(sem_ir, state, type_id)) {
if (BuiltinType<InstId::BuiltinIntLiteralType>::Check(sem_ir, state,
type_id)) {
return true;
}
if (BuiltinType<InstId::BuiltinIntType>::Check(sem_ir, state, type_id)) {
@@ -175,9 +176,9 @@ constexpr BuiltinInfo None = {"", nullptr};
constexpr BuiltinInfo PrintInt = {"print.int",
ValidateSignature<auto(AnyInt)->NoReturn>};
// Returns the `Core.BigInt` type.
constexpr BuiltinInfo BigIntMakeType = {"big_int.make_type",
ValidateSignature<auto()->Type>};
// Returns the `Core.IntLiteral` type.
constexpr BuiltinInfo IntLiteralMakeType = {"int_literal.make_type",
ValidateSignature<auto()->Type>};
// Returns the `i32` type. Doesn't take a bit size because we need an integer
// type as a basis for that.
toolchain/sem_ir/builtin_function_kind.def
+1 -1
View File
@@ -20,7 +20,7 @@ CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(None)
CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(PrintInt)
// Type factories.
CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(BigIntMakeType)
CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(IntLiteralMakeType)
CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(IntMakeType32)
CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(IntMakeTypeSigned)
CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(IntMakeTypeUnsigned)
toolchain/sem_ir/builtin_inst_kind.def
+1 -1
View File
@@ -62,7 +62,7 @@ CARBON_SEM_IR_BUILTIN_INST_KIND(BoolType, "bool")
// types of integer literals and as the parameter type of `Core.Int` and
// `Core.Float`. This type only provides compile-time operations, and is
// represented as an empty type at runtime.
CARBON_SEM_IR_BUILTIN_INST_KIND(BigIntType, "Core.BigInt")
CARBON_SEM_IR_BUILTIN_INST_KIND(IntLiteralType, "Core.IntLiteral")
// The type of integer values and integer literals, currently always i32.
CARBON_SEM_IR_BUILTIN_INST_KIND(IntType, "i32")