diff --git a/core/prelude/types.carbon b/core/prelude/types.carbon index a8b85cbef5c3..60181a143bb9 100644 --- a/core/prelude/types.carbon +++ b/core/prelude/types.carbon @@ -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"; diff --git a/toolchain/check/context.cpp b/toolchain/check/context.cpp index bb9b227f3401..061b445bd87f 100644 --- a/toolchain/check/context.cpp +++ b/toolchain/check/context.cpp @@ -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: diff --git a/toolchain/check/eval.cpp b/toolchain/check/eval.cpp index 1dcb999d05a6..56343adc8648 100644 --- a/toolchain/check/eval.cpp +++ b/toolchain/check/eval.cpp @@ -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: { diff --git a/toolchain/check/handle_literal.cpp b/toolchain/check/handle_literal.cpp index 2e6e47939721..d975de044809 100644 --- a/toolchain/check/handle_literal.cpp +++ b/toolchain/check/handle_literal.cpp @@ -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( - 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); diff --git a/toolchain/check/testdata/array/base.carbon b/toolchain/check/testdata/array/base.carbon index a8d6733cc9f0..8b95a6dd1898 100644 --- a/toolchain/check/testdata/array/base.carbon +++ b/toolchain/check/testdata/array/base.carbon @@ -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: diff --git a/toolchain/check/testdata/basics/builtin_insts.carbon b/toolchain/check/testdata/basics/builtin_insts.carbon index 032c61115994..31311bdef1da 100644 --- a/toolchain/check/testdata/basics/builtin_insts.carbon +++ b/toolchain/check/testdata/basics/builtin_insts.carbon @@ -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) diff --git a/toolchain/check/testdata/basics/builtin_types.carbon b/toolchain/check/testdata/basics/builtin_types.carbon index 633db2e550f9..c49abc02750e 100644 --- a/toolchain/check/testdata/basics/builtin_types.carbon +++ b/toolchain/check/testdata/basics/builtin_types.carbon @@ -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: diff --git a/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon b/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon index ce6cec26f41a..1bdefe3f3d95 100644 --- a/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon +++ b/toolchain/check/testdata/basics/fail_numeric_literal_overflow.carbon @@ -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: diff --git a/toolchain/check/testdata/basics/numeric_literals.carbon b/toolchain/check/testdata/basics/numeric_literals.carbon index 1c81e67fe12b..485ac3588496 100644 --- a/toolchain/check/testdata/basics/numeric_literals.carbon +++ b/toolchain/check/testdata/basics/numeric_literals.carbon @@ -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: diff --git a/toolchain/check/testdata/basics/type_literals.carbon b/toolchain/check/testdata/basics/type_literals.carbon index bff9c274f5f2..00a0c1f37daa 100644 --- a/toolchain/check/testdata/basics/type_literals.carbon +++ b/toolchain/check/testdata/basics/type_literals.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/add.carbon b/toolchain/check/testdata/builtins/float/add.carbon index 838f1ad29de9..86aca445a45f 100644 --- a/toolchain/check/testdata/builtins/float/add.carbon +++ b/toolchain/check/testdata/builtins/float/add.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/div.carbon b/toolchain/check/testdata/builtins/float/div.carbon index 8d46d971e615..fa36005e11d4 100644 --- a/toolchain/check/testdata/builtins/float/div.carbon +++ b/toolchain/check/testdata/builtins/float/div.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/eq.carbon b/toolchain/check/testdata/builtins/float/eq.carbon index 975cb6b47573..1871a067ad43 100644 --- a/toolchain/check/testdata/builtins/float/eq.carbon +++ b/toolchain/check/testdata/builtins/float/eq.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/greater.carbon b/toolchain/check/testdata/builtins/float/greater.carbon index eadbdad6294a..1ddddde7a240 100644 --- a/toolchain/check/testdata/builtins/float/greater.carbon +++ b/toolchain/check/testdata/builtins/float/greater.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/greater_eq.carbon b/toolchain/check/testdata/builtins/float/greater_eq.carbon index a67f73614217..a7e58bc88370 100644 --- a/toolchain/check/testdata/builtins/float/greater_eq.carbon +++ b/toolchain/check/testdata/builtins/float/greater_eq.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/less.carbon b/toolchain/check/testdata/builtins/float/less.carbon index f756c74a5dbc..e49aae80cf97 100644 --- a/toolchain/check/testdata/builtins/float/less.carbon +++ b/toolchain/check/testdata/builtins/float/less.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/less_eq.carbon b/toolchain/check/testdata/builtins/float/less_eq.carbon index d6c495e6b33e..07e693a2e260 100644 --- a/toolchain/check/testdata/builtins/float/less_eq.carbon +++ b/toolchain/check/testdata/builtins/float/less_eq.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/mul.carbon b/toolchain/check/testdata/builtins/float/mul.carbon index 9d5f1620c037..3f9552ba9ba8 100644 --- a/toolchain/check/testdata/builtins/float/mul.carbon +++ b/toolchain/check/testdata/builtins/float/mul.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/negate.carbon b/toolchain/check/testdata/builtins/float/negate.carbon index 226da881aa9c..52bfa530b9c8 100644 --- a/toolchain/check/testdata/builtins/float/negate.carbon +++ b/toolchain/check/testdata/builtins/float/negate.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/neq.carbon b/toolchain/check/testdata/builtins/float/neq.carbon index 930da0034a72..1526888b1131 100644 --- a/toolchain/check/testdata/builtins/float/neq.carbon +++ b/toolchain/check/testdata/builtins/float/neq.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/float/sub.carbon b/toolchain/check/testdata/builtins/float/sub.carbon index 33d0b8058f69..1c16d489d117 100644 --- a/toolchain/check/testdata/builtins/float/sub.carbon +++ b/toolchain/check/testdata/builtins/float/sub.carbon @@ -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: diff --git a/toolchain/check/testdata/builtins/big_int/make_type.carbon b/toolchain/check/testdata/builtins/int_literal/make_type.carbon similarity index 59% rename from toolchain/check/testdata/builtins/big_int/make_type.carbon rename to toolchain/check/testdata/builtins/int_literal/make_type.carbon index 859153deef0c..b6b8dace5fd1 100644 --- a/toolchain/check/testdata/builtins/big_int/make_type.carbon +++ b/toolchain/check/testdata/builtins/int_literal/make_type.carbon @@ -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 [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 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 [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 -// 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: diff --git a/toolchain/check/testdata/deduce/int_float.carbon b/toolchain/check/testdata/deduce/int_float.carbon index 5303e98ebaf7..f31a5c350733 100644 --- a/toolchain/check/testdata/deduce/int_float.carbon +++ b/toolchain/check/testdata/deduce/int_float.carbon @@ -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 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 [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 [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: = 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: = 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: = 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: = 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 -// 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: = 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 +// 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: = 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 %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 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 [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 [symbolic = %N.patt.loc8_6.2 (constants.%N.patt)] // CHECK:STDOUT: %n.patt: = binding_pattern n // CHECK:STDOUT: %n.param_patt: = 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: = 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: = 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: = 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: = 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 -// 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: = 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 +// 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: = value_param runtime_param0 // CHECK:STDOUT: %n: = 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: = 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: ) -> Core.BigInt { +// CHECK:STDOUT: fn[%N.param_patt: Core.IntLiteral](%n.param_patt: ) -> 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 diff --git a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon index 35e05ae8891f..99d8665ef26b 100644 --- a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon +++ b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon @@ -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: diff --git a/toolchain/check/testdata/function/generic/resolve_used.carbon b/toolchain/check/testdata/function/generic/resolve_used.carbon index 6daf89efd5a0..03b708901523 100644 --- a/toolchain/check/testdata/function/generic/resolve_used.carbon +++ b/toolchain/check/testdata/function/generic/resolve_used.carbon @@ -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 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 [symbolic = %N.patt.loc10_19.2 (constants.%N.patt)] -// CHECK:STDOUT: %n.patt: = binding_pattern n -// CHECK:STDOUT: %n.param_patt: = 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 [symbolic = %N.patt.loc4_19.2 (constants.%N.patt)] // CHECK:STDOUT: } { -// CHECK:STDOUT: %Core.ref.loc10_23: = 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: = name_ref Core, imports.%Core [template = imports.%Core] -// CHECK:STDOUT: %IntLiteral.ref: = name_ref IntLiteral, [template = ] -// 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 -// 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: = value_param runtime_param0 -// CHECK:STDOUT: %n: = bind_name n, %n.param +// CHECK:STDOUT: %Core.ref.loc4: = 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 +// 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: ) { +// 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: = name_ref Core, imports.%Core [template = imports.%Core] +// CHECK:STDOUT: %Core.ref.loc9: = 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, [template = ] // 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: diff --git a/toolchain/check/testdata/if_expr/fail_not_in_function.carbon b/toolchain/check/testdata/if_expr/fail_not_in_function.carbon index 3a3aab6e02ce..08b5e98ff1c8 100644 --- a/toolchain/check/testdata/if_expr/fail_not_in_function.carbon +++ b/toolchain/check/testdata/if_expr/fail_not_in_function.carbon @@ -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: diff --git a/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon b/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon index 0650defcaf6f..b9cfb4705e5d 100644 --- a/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon +++ b/toolchain/check/testdata/operators/builtin/fail_and_or_not_in_function.carbon @@ -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: diff --git a/toolchain/check/testdata/return/fail_returned_var_type.carbon b/toolchain/check/testdata/return/fail_returned_var_type.carbon index 3ed1b464bf83..d3ca28532aab 100644 --- a/toolchain/check/testdata/return/fail_returned_var_type.carbon +++ b/toolchain/check/testdata/return/fail_returned_var_type.carbon @@ -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 // 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: diff --git a/toolchain/check/testdata/struct/fail_member_access_type.carbon b/toolchain/check/testdata/struct/fail_member_access_type.carbon index cddd0574718a..a73f4d82753a 100644 --- a/toolchain/check/testdata/struct/fail_member_access_type.carbon +++ b/toolchain/check/testdata/struct/fail_member_access_type.carbon @@ -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: diff --git a/toolchain/check/testdata/struct/member_access.carbon b/toolchain/check/testdata/struct/member_access.carbon index a5286f4b145f..75c0af7a3aaa 100644 --- a/toolchain/check/testdata/struct/member_access.carbon +++ b/toolchain/check/testdata/struct/member_access.carbon @@ -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: diff --git a/toolchain/check/testdata/struct/reorder_fields.carbon b/toolchain/check/testdata/struct/reorder_fields.carbon index 9452d9b33353..ed677faf54bf 100644 --- a/toolchain/check/testdata/struct/reorder_fields.carbon +++ b/toolchain/check/testdata/struct/reorder_fields.carbon @@ -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] diff --git a/toolchain/lower/constant.cpp b/toolchain/lower/constant.cpp index 6f0c5b42ad68..528ea882f54b 100644 --- a/toolchain/lower/constant.cpp +++ b/toolchain/lower/constant.cpp @@ -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(type)) { auto* struct_type = llvm::dyn_cast(type); diff --git a/toolchain/lower/file_context.cpp b/toolchain/lower/file_context.cpp index 5960e91ef549..9d021a0ac5ef 100644 --- a/toolchain/lower/file_context.cpp +++ b/toolchain/lower/file_context.cpp @@ -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. diff --git a/toolchain/lower/handle_call.cpp b/toolchain/lower/handle_call.cpp index 45092b164682..7afda52a427e 100644 --- a/toolchain/lower/handle_call.cpp +++ b/toolchain/lower/handle_call.cpp @@ -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: diff --git a/toolchain/lower/testdata/builtins/big_int.carbon b/toolchain/lower/testdata/builtins/int_literal.carbon similarity index 78% rename from toolchain/lower/testdata/builtins/big_int.carbon rename to toolchain/lower/testdata/builtins/int_literal.carbon index 244f90137cac..afe16953ddbf 100644 --- a/toolchain/lower/testdata/builtins/big_int.carbon +++ b/toolchain/lower/testdata/builtins/int_literal.carbon @@ -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 = !{} diff --git a/toolchain/sem_ir/builtin_function_kind.cpp b/toolchain/sem_ir/builtin_function_kind.cpp index 89e9f955fceb..0547982a81d8 100644 --- a/toolchain/sem_ir/builtin_function_kind.cpp +++ b/toolchain/sem_ir/builtin_function_kind.cpp @@ -79,7 +79,8 @@ using Bool = BuiltinType; struct AnyInt { static auto Check(const File& sem_ir, ValidateState& state, TypeId type_id) -> bool { - if (BuiltinType::Check(sem_ir, state, type_id)) { + if (BuiltinType::Check(sem_ir, state, + type_id)) { return true; } if (BuiltinType::Check(sem_ir, state, type_id)) { @@ -175,9 +176,9 @@ constexpr BuiltinInfo None = {"", nullptr}; constexpr BuiltinInfo PrintInt = {"print.int", ValidateSignatureNoReturn>}; -// Returns the `Core.BigInt` type. -constexpr BuiltinInfo BigIntMakeType = {"big_int.make_type", - ValidateSignatureType>}; +// Returns the `Core.IntLiteral` type. +constexpr BuiltinInfo IntLiteralMakeType = {"int_literal.make_type", + ValidateSignatureType>}; // Returns the `i32` type. Doesn't take a bit size because we need an integer // type as a basis for that. diff --git a/toolchain/sem_ir/builtin_function_kind.def b/toolchain/sem_ir/builtin_function_kind.def index eb1c9756fd31..928022a8a04d 100644 --- a/toolchain/sem_ir/builtin_function_kind.def +++ b/toolchain/sem_ir/builtin_function_kind.def @@ -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) diff --git a/toolchain/sem_ir/builtin_inst_kind.def b/toolchain/sem_ir/builtin_inst_kind.def index 3c4b4b4b6eea..0b84ee0df8f0 100644 --- a/toolchain/sem_ir/builtin_inst_kind.def +++ b/toolchain/sem_ir/builtin_inst_kind.def @@ -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")