From 6dbeda612a103fc3c2009fcc815e5774ad47f0fa Mon Sep 17 00:00:00 2001 From: josh11b <15258583+josh11b@users.noreply.github.com> Date: Fri, 4 Oct 2024 18:03:43 -0700 Subject: [PATCH] `where` check stage, step 3: some type checking (#4364) With this, we now check: * The left argument to `where` is a facet type * The right argument of a rewrite (`=`) requirement converts to the type of the left argument. * The left argument of an `impls` requirement is a type and the right argument is a facet type. No checking is done for `==` constraints yet. In addition, make the "is facet type" query into its own function and fix some comments noticed as part of this change. This change reveals that accessing the members of a facet, like `.Self`, isn't doing the right thing, and will have to be fixed in a follow-on PR. Some tests have been adjusted or disabled as a result. --------- Co-authored-by: Josh L --- toolchain/check/context.cpp | 4 +- toolchain/check/context.h | 6 + toolchain/check/convert.h | 4 +- toolchain/check/handle_where.cpp | 40 +- .../impl/fail_todo_impl_assoc_const.carbon | 117 +- .../testdata/where_expr/constraints.carbon | 1063 +++++++++++++++-- .../{no_prelude => }/designator.carbon | 103 +- .../testdata/where_expr/fail_not_facet.carbon | 87 ++ .../{no_prelude => }/non_generic.carbon | 34 +- toolchain/diagnostics/diagnostic_kind.def | 4 + 10 files changed, 1294 insertions(+), 168 deletions(-) rename toolchain/check/testdata/where_expr/{no_prelude => }/designator.carbon (78%) create mode 100644 toolchain/check/testdata/where_expr/fail_not_facet.carbon rename toolchain/check/testdata/where_expr/{no_prelude => }/non_generic.carbon (65%) diff --git a/toolchain/check/context.cpp b/toolchain/check/context.cpp index 434278d564aa..a7fa94095905 100644 --- a/toolchain/check/context.cpp +++ b/toolchain/check/context.cpp @@ -1192,9 +1192,7 @@ auto Context::GetTypeIdForTypeConstant(SemIR::ConstantId constant_id) auto type_id = insts().Get(constant_values().GetInstId(constant_id)).type_id(); // TODO: For now, we allow values of facet type to be used as types. - CARBON_CHECK(type_id == SemIR::TypeId::TypeType || - types().Is(type_id) || - constant_id == SemIR::ConstantId::Error, + CARBON_CHECK(IsFacetType(type_id) || constant_id == SemIR::ConstantId::Error, "Forming type ID for non-type constant of type {0}", types().GetAsInst(type_id)); diff --git a/toolchain/check/context.h b/toolchain/check/context.h index 960a0c84c39a..e2a5bf7c4a76 100644 --- a/toolchain/check/context.h +++ b/toolchain/check/context.h @@ -324,6 +324,12 @@ class Context { : SemIR::TypeId::Error; } + // Returns whether `type_id` represents a facet type. + auto IsFacetType(SemIR::TypeId type_id) -> bool { + return type_id == SemIR::TypeId::TypeType || + types().Is(type_id); + } + // TODO: Consider moving these `Get*Type` functions to a separate class. // Gets the type for the name of an associated entity. diff --git a/toolchain/check/convert.h b/toolchain/check/convert.h index dc456705b67a..c9abff3ec435 100644 --- a/toolchain/check/convert.h +++ b/toolchain/check/convert.h @@ -15,9 +15,9 @@ namespace Carbon::Check { // Description of the target of a conversion. struct ConversionTarget { enum Kind : int8_t { - // Convert to a value of type `type`. + // Convert to a value of type `type_id`. Value, - // Convert to either a value or a reference of type `type`. + // Convert to either a value or a reference of type `type_id`. ValueOrRef, // Convert for an explicit `as` cast. This allows any expression category // as the result, and uses the `As` interface instead of the `ImplicitAs` diff --git a/toolchain/check/handle_where.cpp b/toolchain/check/handle_where.cpp index 6066f3e4547b..4ce4b8fc833d 100644 --- a/toolchain/check/handle_where.cpp +++ b/toolchain/check/handle_where.cpp @@ -15,8 +15,13 @@ auto HandleParseNode(Context& context, Parse::WhereOperandId node_id) -> bool { // `MyInterface where .Member = i32`. auto [self_node, self_id] = context.node_stack().PopExprWithNodeId(); auto self_type_id = ExprAsType(context, self_node, self_id).type_id; - // TODO: Validate that `self_type_id` represents a facet type. Only facet - // types may have `where` restrictions. + // Only facet types may have `where` restrictions. + if (!context.IsFacetType(self_type_id)) { + CARBON_DIAGNOSTIC(WhereOnNonFacetType, Error, + "left argument of `where` operator must be a facet type"); + context.emitter().Emit(self_node, WhereOnNonFacetType); + self_type_id = SemIR::TypeId::Error; + } // Introduce a name scope so that we can remove the `.Self` entry we are // adding to name lookup at the end of the `where` expression. @@ -55,14 +60,17 @@ auto HandleParseNode(Context& context, Parse::WhereOperandId node_id) -> bool { auto HandleParseNode(Context& context, Parse::RequirementEqualId node_id) -> bool { - auto rhs = context.node_stack().PopExpr(); + auto [rhs_node, rhs_id] = context.node_stack().PopExprWithNodeId(); auto lhs = context.node_stack().PopExpr(); - // TODO: convert rhs to type of lhs + + // Convert rhs to type of lhs. + SemIR::InstId rhs_inst_id = ConvertToValueOfType( + context, rhs_node, rhs_id, context.insts().Get(lhs).type_id()); // Build up the list of arguments for the `WhereExpr` inst. context.args_type_info_stack().AddInstId( context.AddInstInNoBlock( - node_id, {.lhs_id = lhs, .rhs_id = rhs})); + node_id, {.lhs_id = lhs, .rhs_id = rhs_inst_id})); return true; } @@ -70,7 +78,7 @@ auto HandleParseNode(Context& context, Parse::RequirementEqualEqualId node_id) -> bool { auto rhs = context.node_stack().PopExpr(); auto lhs = context.node_stack().PopExpr(); - // TODO: type check lhs and rhs are compatible + // TODO: type check lhs and rhs are comparable // Build up the list of arguments for the `WhereExpr` inst. context.args_type_info_stack().AddInstId( @@ -81,14 +89,26 @@ auto HandleParseNode(Context& context, Parse::RequirementEqualEqualId node_id) auto HandleParseNode(Context& context, Parse::RequirementImplsId node_id) -> bool { - auto rhs = context.node_stack().PopExpr(); - auto lhs = context.node_stack().PopExpr(); - // TODO: check lhs is a facet and rhs is a facet type + auto [rhs_node, rhs_id] = context.node_stack().PopExprWithNodeId(); + auto [lhs_node, lhs_id] = context.node_stack().PopExprWithNodeId(); + + // Check lhs is a facet and rhs is a facet type. + auto lhs_as_type = ExprAsType(context, lhs_node, lhs_id); + auto rhs_as_type = ExprAsType(context, rhs_node, rhs_id); + if (rhs_as_type.type_id != SemIR::TypeId::Error && + !context.IsFacetType(rhs_as_type.type_id)) { + CARBON_DIAGNOSTIC( + ImplsOnNonFacetType, Error, + "right argument of `impls` requirement must be a facet type"); + context.emitter().Emit(rhs_node, ImplsOnNonFacetType); + rhs_as_type.inst_id = SemIR::InstId::BuiltinError; + } // Build up the list of arguments for the `WhereExpr` inst. context.args_type_info_stack().AddInstId( context.AddInstInNoBlock( - node_id, {.lhs_id = lhs, .rhs_id = rhs})); + node_id, + {.lhs_id = lhs_as_type.inst_id, .rhs_id = rhs_as_type.inst_id})); return true; } diff --git a/toolchain/check/testdata/impl/fail_todo_impl_assoc_const.carbon b/toolchain/check/testdata/impl/fail_todo_impl_assoc_const.carbon index 071af998f7ca..fa4418cff1ba 100644 --- a/toolchain/check/testdata/impl/fail_todo_impl_assoc_const.carbon +++ b/toolchain/check/testdata/impl/fail_todo_impl_assoc_const.carbon @@ -10,27 +10,51 @@ interface I { let T:! type; } -// CHECK:STDERR: fail_todo_impl_assoc_const.carbon:[[@LINE+3]]:1: error: semantics TODO: `impl of interface with associated constant` +// CHECK:STDERR: fail_todo_impl_assoc_const.carbon:[[@LINE+10]]:1: error: semantics TODO: `impl of interface with associated constant` // CHECK:STDERR: impl bool as I where .T = bool {} // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// CHECK:STDERR: +// CHECK:STDERR: fail_todo_impl_assoc_const.carbon:[[@LINE+6]]:27: error: cannot implicitly convert from `type` to `` +// CHECK:STDERR: impl bool as I where .T = bool {} +// CHECK:STDERR: ^~~~ +// CHECK:STDERR: fail_todo_impl_assoc_const.carbon:[[@LINE+3]]:27: note: type `type` does not implement interface `ImplicitAs` +// CHECK:STDERR: impl bool as I where .T = bool {} +// CHECK:STDERR: ^~~~ impl bool as I where .T = bool {} // CHECK:STDOUT: --- fail_todo_impl_assoc_const.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %I.type: type = interface_type @I [template] -// CHECK:STDOUT: %Self: %I.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %Self.1: %I.type = bind_symbolic_name Self, 0 [symbolic] // CHECK:STDOUT: %.1: type = assoc_entity_type %I.type, type [template] // CHECK:STDOUT: %.2: %.1 = assoc_entity element0, @I.%T [template] // CHECK:STDOUT: %Bool.type: type = fn_type @Bool [template] // CHECK:STDOUT: %.3: type = tuple_type () [template] // CHECK:STDOUT: %Bool: %Bool.type = struct_value () [template] // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic] +// 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.2: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Self.3: %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.6 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(%.1) [template] +// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(%.1) [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.6 [template] +// CHECK:STDOUT: %.8: %.4 = assoc_entity element0, imports.%import_ref.7 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { -// CHECK:STDOUT: .Bool = %import_ref +// CHECK:STDOUT: .Bool = %import_ref.1 +// CHECK:STDOUT: .ImplicitAs = %import_ref.2 // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/operators // CHECK:STDOUT: import Core//prelude/types @@ -40,7 +64,13 @@ impl bool as I where .T = bool {} // CHECK:STDOUT: import Core//prelude/operators/comparison // CHECK:STDOUT: import Core//prelude/types/bool // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref: %Bool.type = import_ref Core//prelude/types/bool, inst+2, loaded [template = constants.%Bool] +// CHECK:STDOUT: %import_ref.1: %Bool.type = import_ref Core//prelude/types/bool, inst+2, loaded [template = constants.%Bool] +// CHECK:STDOUT: %import_ref.2: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.3 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.4: @ImplicitAs.%.1 (%.4) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.8)] +// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.7 = import_ref Core//prelude/operators/as, inst+56, unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -51,22 +81,28 @@ impl bool as I where .T = bool {} // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %I.decl: type = interface_decl @I [template = constants.%I.type] {} {} // CHECK:STDOUT: impl_decl @impl [template] {} { -// CHECK:STDOUT: %bool.make_type.loc16_6: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc16_6.1: type = value_of_initializer %bool.make_type.loc16_6 [template = bool] -// CHECK:STDOUT: %.loc16_6.2: type = converted %bool.make_type.loc16_6, %.loc16_6.1 [template = bool] +// CHECK:STDOUT: %bool.make_type.loc23_6: init type = call constants.%Bool() [template = bool] +// CHECK:STDOUT: %.loc23_6.1: type = value_of_initializer %bool.make_type.loc23_6 [template = bool] +// CHECK:STDOUT: %.loc23_6.2: type = converted %bool.make_type.loc23_6, %.loc23_6.1 [template = bool] // CHECK:STDOUT: %I.ref: type = name_ref I, file.%I.decl [template = constants.%I.type] // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] // CHECK:STDOUT: %.Self.ref: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self] // CHECK:STDOUT: %T.ref: %.1 = name_ref T, @I.%.loc11 [template = constants.%.2] -// CHECK:STDOUT: %bool.make_type.loc16_27: init type = call constants.%Bool() [template = bool] -// CHECK:STDOUT: %.loc16_16: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_rewrite %T.ref, %bool.make_type.loc16_27 +// CHECK:STDOUT: %bool.make_type.loc23_27: init type = call constants.%Bool() [template = bool] +// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(constants.%.1) [template = constants.%ImplicitAs.type.3] +// CHECK:STDOUT: %.loc23_27.1: %.6 = specific_constant imports.%import_ref.4, @ImplicitAs(constants.%.1) [template = constants.%.7] +// CHECK:STDOUT: %Convert.ref: %.6 = name_ref Convert, %.loc23_27.1 [template = constants.%.7] +// CHECK:STDOUT: %.loc23_27.2: ref type = temporary_storage +// CHECK:STDOUT: %.loc23_27.3: ref type = temporary %.loc23_27.2, %bool.make_type.loc23_27 +// CHECK:STDOUT: %.loc23_27.4: %.1 = converted %bool.make_type.loc23_27, [template = ] +// CHECK:STDOUT: %.loc23_16: type = where_expr %.Self [template = constants.%I.type] { +// CHECK:STDOUT: requirement_rewrite %T.ref, // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: interface @I { -// CHECK:STDOUT: %Self: %I.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self] +// CHECK:STDOUT: %Self: %I.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.1] // CHECK:STDOUT: %T: type = assoc_const_decl T [template] // CHECK:STDOUT: %.loc11: %.1 = assoc_entity element0, %T [template = constants.%.2] // CHECK:STDOUT: @@ -76,10 +112,67 @@ impl bool as I where .T = bool {} // CHECK:STDOUT: witness = (%T) // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: impl @impl: %.loc16_6.2 as %.loc16_16 { +// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// 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.3)] +// 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.6 [symbolic = %.2 (constants.%.5)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%import_ref.3 +// CHECK:STDOUT: .Convert = imports.%import_ref.4 +// CHECK:STDOUT: witness = (imports.%import_ref.5) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: impl @impl: %.loc23_6.2 as %.loc23_16 { // CHECK:STDOUT: !members: // CHECK:STDOUT: witness = // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @Bool() -> type = "bool.make_type"; // CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(constants.%Dest: type, constants.%Self.2: @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.3)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self: @Convert.%Self (%Self.3)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.2) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.2 +// CHECK:STDOUT: %Self => constants.%Self.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%.1) { +// CHECK:STDOUT: %Dest => constants.%.1 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3 +// CHECK:STDOUT: %Self => constants.%Self.3 +// 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/where_expr/constraints.carbon b/toolchain/check/testdata/where_expr/constraints.carbon index 4ef130096e26..0e26b67a260d 100644 --- a/toolchain/check/testdata/where_expr/constraints.carbon +++ b/toolchain/check/testdata/where_expr/constraints.carbon @@ -19,23 +19,102 @@ interface I { let Second:! J; } -fn Equal(T:! I where .Member = {}); - fn EqualEqual(U:! I where .Self == ()); fn Impls(V:! J where .Self impls I); -fn And(W:! I where .Second impls I and .Member = .Second); +fn And(W:! I where .Self impls J and .Member == ()); -// --- todo_check_constraints.carbon +// --- fail_todo_equal_constraint.carbon + +library "[[@TEST_NAME]]"; + +interface N { + let P:! type; +} + +// CHECK:STDERR: fail_todo_equal_constraint.carbon:[[@LINE+7]]:27: error: cannot implicitly convert from `{}` to `` +// CHECK:STDERR: fn Equal(T:! N where .P = {}); +// CHECK:STDERR: ^~ +// CHECK:STDERR: fail_todo_equal_constraint.carbon:[[@LINE+4]]:27: note: type `{}` does not implement interface `ImplicitAs` +// CHECK:STDERR: fn Equal(T:! N where .P = {}); +// CHECK:STDERR: ^~ +// CHECK:STDERR: +fn Equal(T:! N where .P = {}); + +// --- fail_todo_associated_type_impls.carbon + +library "[[@TEST_NAME]]"; + +interface L {} +interface M {} + +interface K { + let Associated:! L; +} + +// CHECK:STDERR: fail_todo_associated_type_impls.carbon:[[@LINE+7]]:36: error: cannot implicitly convert from `` to `type` +// CHECK:STDERR: fn AssociatedTypeImpls(W:! K where .Associated impls M); +// CHECK:STDERR: ^~~~~~~~~~~ +// CHECK:STDERR: fail_todo_associated_type_impls.carbon:[[@LINE+4]]:36: note: type `` does not implement interface `ImplicitAs` +// CHECK:STDERR: fn AssociatedTypeImpls(W:! K where .Associated impls M); +// CHECK:STDERR: ^~~~~~~~~~~ +// CHECK:STDERR: +fn AssociatedTypeImpls(W:! K where .Associated impls M); + +// --- fail_check_rewrite_constraints.carbon library "[[@TEST_NAME]]"; import library "state_constraints"; -// TODO: Should fail since `2` can't be converted to the type of `I.Member`, -// but constraints are not yet type checked. -fn TypeMismatch(X:! I where .Member = 2); +// `2` can't be converted to the type of `I.Member` +// TODO: The diagnostics are wrong since member access into facets isn't +// working properly yet. +// CHECK:STDERR: fail_check_rewrite_constraints.carbon:[[@LINE+7]]:46: error: cannot implicitly convert from `i32` to `` +// CHECK:STDERR: fn RewriteTypeMismatch(X:! I where .Member = 2); +// CHECK:STDERR: ^ +// CHECK:STDERR: fail_check_rewrite_constraints.carbon:[[@LINE+4]]:46: note: type `i32` does not implement interface `ImplicitAs` +// CHECK:STDERR: fn RewriteTypeMismatch(X:! I where .Member = 2); +// CHECK:STDERR: ^ +// CHECK:STDERR: +fn RewriteTypeMismatch(X:! I where .Member = 2); + +// --- fail_left_of_impls_non_type.carbon + +library "[[@TEST_NAME]]"; + +// CHECK:STDERR: fail_left_of_impls_non_type.carbon:[[@LINE+7]]:32: error: cannot implicitly convert from `i32` to `type` +// CHECK:STDERR: fn NonTypeImpls(U:! type where 7 impls type); +// CHECK:STDERR: ^ +// CHECK:STDERR: fail_left_of_impls_non_type.carbon:[[@LINE+4]]:32: note: type `i32` does not implement interface `ImplicitAs` +// CHECK:STDERR: fn NonTypeImpls(U:! type where 7 impls type); +// CHECK:STDERR: ^ +// CHECK:STDERR: +fn NonTypeImpls(U:! type where 7 impls type); + +// --- fail_right_of_impls_non_type.carbon + +library "[[@TEST_NAME]]"; + +// CHECK:STDERR: fail_right_of_impls_non_type.carbon:[[@LINE+7]]:44: error: cannot implicitly convert from `i32` to `type` +// CHECK:STDERR: fn ImplsNonType(U:! type where .Self impls 7); +// CHECK:STDERR: ^ +// CHECK:STDERR: fail_right_of_impls_non_type.carbon:[[@LINE+4]]:44: note: type `i32` does not implement interface `ImplicitAs` +// CHECK:STDERR: fn ImplsNonType(U:! type where .Self impls 7); +// CHECK:STDERR: ^ +// CHECK:STDERR: +fn ImplsNonType(U:! type where .Self impls 7); + +// --- fail_right_of_impls_non_facet_type.carbon + +library "[[@TEST_NAME]]"; + +// CHECK:STDERR: fail_right_of_impls_non_facet_type.carbon:[[@LINE+4]]:51: error: right argument of `impls` requirement must be a facet type +// CHECK:STDERR: fn ImplsOfNonFacetType(U:! type where .Self impls i32); +// CHECK:STDERR: ^~~ +// CHECK:STDERR: +fn ImplsOfNonFacetType(U:! type where .Self impls i32); // --- fail_todo_enforce_constraint.carbon @@ -56,7 +135,7 @@ fn DoesNotImplI() { // CHECK:STDERR: Impls(C); // CHECK:STDERR: ^~~~~~ // CHECK:STDERR: fail_todo_enforce_constraint.carbon:[[@LINE-14]]:1: in import - // CHECK:STDERR: state_constraints.carbon:15:10: note: initializing generic parameter `V` declared here + // CHECK:STDERR: state_constraints.carbon:13:10: note: initializing generic parameter `V` declared here // CHECK:STDERR: fn Impls(V:! J where .Self impls I); // CHECK:STDERR: ^ // CHECK:STDERR: @@ -92,10 +171,6 @@ fn NotEmptyStruct() { // CHECK:STDOUT: %.4: type = assoc_entity_type %I.type, %J.type [template] // CHECK:STDOUT: %.5: %.4 = assoc_entity element1, @I.%Second [template] // CHECK:STDOUT: %.Self.1: %I.type = bind_symbolic_name .Self, 0 [symbolic] -// CHECK:STDOUT: %.6: type = struct_type {} [template] -// CHECK:STDOUT: %T: %I.type = bind_symbolic_name T, 0 [symbolic] -// CHECK:STDOUT: %Equal.type: type = fn_type @Equal [template] -// CHECK:STDOUT: %Equal: %Equal.type = struct_value () [template] // CHECK:STDOUT: %U: %I.type = bind_symbolic_name U, 0 [symbolic] // CHECK:STDOUT: %EqualEqual.type: type = fn_type @EqualEqual [template] // CHECK:STDOUT: %EqualEqual: %EqualEqual.type = struct_value () [template] @@ -126,7 +201,6 @@ fn NotEmptyStruct() { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .J = %J.decl // CHECK:STDOUT: .I = %I.decl -// CHECK:STDOUT: .Equal = %Equal.decl // CHECK:STDOUT: .EqualEqual = %EqualEqual.decl // CHECK:STDOUT: .Impls = %Impls.decl // CHECK:STDOUT: .And = %And.decl @@ -134,32 +208,18 @@ fn NotEmptyStruct() { // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %J.decl: type = interface_decl @J [template = constants.%J.type] {} {} // CHECK:STDOUT: %I.decl: type = interface_decl @I [template = constants.%I.type] {} {} -// CHECK:STDOUT: %Equal.decl: %Equal.type = fn_decl @Equal [template = constants.%Equal] { -// CHECK:STDOUT: %T.patt: %I.type = symbolic_binding_pattern T, 0 -// CHECK:STDOUT: } { -// CHECK:STDOUT: %I.ref: type = name_ref I, file.%I.decl [template = constants.%I.type] -// CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self.1] -// CHECK:STDOUT: %.Self.ref: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] -// CHECK:STDOUT: %Member.ref: %.1 = name_ref Member, @I.%.loc7 [template = constants.%.2] -// CHECK:STDOUT: %.loc11_33: %.6 = struct_literal () -// CHECK:STDOUT: %.loc11_16: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_rewrite %Member.ref, %.loc11_33 -// CHECK:STDOUT: } -// CHECK:STDOUT: %T.param: %I.type = param T, runtime_param -// CHECK:STDOUT: %T.loc11: %I.type = bind_symbolic_name T, 0, %T.param [symbolic = %T.1 (constants.%T)] -// CHECK:STDOUT: } // CHECK:STDOUT: %EqualEqual.decl: %EqualEqual.type = fn_decl @EqualEqual [template = constants.%EqualEqual] { // CHECK:STDOUT: %U.patt: %I.type = symbolic_binding_pattern U, 0 // CHECK:STDOUT: } { // CHECK:STDOUT: %I.ref: type = name_ref I, file.%I.decl [template = constants.%I.type] // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self.1] // CHECK:STDOUT: %.Self.ref: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] -// CHECK:STDOUT: %.loc13_37: %.3 = tuple_literal () -// CHECK:STDOUT: %.loc13_21: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_equivalent %.Self.ref, %.loc13_37 +// CHECK:STDOUT: %.loc11_37: %.3 = tuple_literal () +// CHECK:STDOUT: %.loc11_21: type = where_expr %.Self [template = constants.%I.type] { +// CHECK:STDOUT: requirement_equivalent %.Self.ref, %.loc11_37 // CHECK:STDOUT: } // CHECK:STDOUT: %U.param: %I.type = param U, runtime_param -// CHECK:STDOUT: %U.loc13: %I.type = bind_symbolic_name U, 0, %U.param [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: %U.loc11: %I.type = bind_symbolic_name U, 0, %U.param [symbolic = %U.1 (constants.%U)] // CHECK:STDOUT: } // CHECK:STDOUT: %Impls.decl: %Impls.type = fn_decl @Impls [template = constants.%Impls] { // CHECK:STDOUT: %V.patt: %J.type = symbolic_binding_pattern V, 0 @@ -168,30 +228,32 @@ fn NotEmptyStruct() { // CHECK:STDOUT: %.Self: %J.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self.2] // CHECK:STDOUT: %.Self.ref: %J.type = name_ref .Self, %.Self [symbolic = constants.%.Self.2] // CHECK:STDOUT: %I.ref: type = name_ref I, file.%I.decl [template = constants.%I.type] -// CHECK:STDOUT: %.loc15: type = where_expr %.Self [template = constants.%J.type] { -// CHECK:STDOUT: requirement_impls %.Self.ref, %I.ref +// CHECK:STDOUT: %.loc13_22.1: type = facet_type_access %.Self.ref [symbolic = constants.%.Self.2] +// CHECK:STDOUT: %.loc13_22.2: type = converted %.Self.ref, %.loc13_22.1 [symbolic = constants.%.Self.2] +// CHECK:STDOUT: %.loc13_16: type = where_expr %.Self [template = constants.%J.type] { +// CHECK:STDOUT: requirement_impls %.loc13_22.2, %I.ref // CHECK:STDOUT: } // CHECK:STDOUT: %V.param: %J.type = param V, runtime_param -// CHECK:STDOUT: %V.loc15: %J.type = bind_symbolic_name V, 0, %V.param [symbolic = %V.1 (constants.%V)] +// CHECK:STDOUT: %V.loc13: %J.type = bind_symbolic_name V, 0, %V.param [symbolic = %V.1 (constants.%V)] // CHECK:STDOUT: } // CHECK:STDOUT: %And.decl: %And.type = fn_decl @And [template = constants.%And] { // CHECK:STDOUT: %W.patt: %I.type = symbolic_binding_pattern W, 0 // CHECK:STDOUT: } { -// CHECK:STDOUT: %I.ref.loc17_12: type = name_ref I, file.%I.decl [template = constants.%I.type] +// CHECK:STDOUT: %I.ref: type = name_ref I, file.%I.decl [template = constants.%I.type] // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self.1] -// CHECK:STDOUT: %.Self.ref.loc17_20: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] -// CHECK:STDOUT: %Second.ref.loc17_20: %.4 = name_ref Second, @I.%.loc8 [template = constants.%.5] -// CHECK:STDOUT: %I.ref.loc17_34: type = name_ref I, file.%I.decl [template = constants.%I.type] -// CHECK:STDOUT: %.Self.ref.loc17_40: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] +// CHECK:STDOUT: %.Self.ref.loc15_20: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] +// CHECK:STDOUT: %J.ref: type = name_ref J, file.%J.decl [template = constants.%J.type] +// CHECK:STDOUT: %.loc15_20.1: type = facet_type_access %.Self.ref.loc15_20 [symbolic = constants.%.Self.1] +// CHECK:STDOUT: %.loc15_20.2: type = converted %.Self.ref.loc15_20, %.loc15_20.1 [symbolic = constants.%.Self.1] +// CHECK:STDOUT: %.Self.ref.loc15_38: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] // CHECK:STDOUT: %Member.ref: %.1 = name_ref Member, @I.%.loc7 [template = constants.%.2] -// CHECK:STDOUT: %.Self.ref.loc17_50: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] -// CHECK:STDOUT: %Second.ref.loc17_50: %.4 = name_ref Second, @I.%.loc8 [template = constants.%.5] -// CHECK:STDOUT: %.loc17: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_impls %Second.ref.loc17_20, %I.ref.loc17_34 -// CHECK:STDOUT: requirement_rewrite %Member.ref, %Second.ref.loc17_50 +// CHECK:STDOUT: %.loc15_50: %.3 = tuple_literal () +// CHECK:STDOUT: %.loc15_14: type = where_expr %.Self [template = constants.%I.type] { +// CHECK:STDOUT: requirement_impls %.loc15_20.2, %J.ref +// CHECK:STDOUT: requirement_equivalent %Member.ref, %.loc15_50 // CHECK:STDOUT: } // CHECK:STDOUT: %W.param: %I.type = param W, runtime_param -// CHECK:STDOUT: %W.loc17: %I.type = bind_symbolic_name W, 0, %W.param [symbolic = %W.1 (constants.%W)] +// CHECK:STDOUT: %W.loc15: %I.type = bind_symbolic_name W, 0, %W.param [symbolic = %W.1 (constants.%W)] // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -218,32 +280,22 @@ fn NotEmptyStruct() { // CHECK:STDOUT: witness = (%Member, %Second) // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @Equal(%T.loc11: %I.type) { -// CHECK:STDOUT: %T.1: %I.type = bind_symbolic_name T, 0 [symbolic = %T.1 (constants.%T)] -// CHECK:STDOUT: -// CHECK:STDOUT: fn(%T.loc11: %I.type); -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: generic fn @EqualEqual(%U.loc13: %I.type) { +// CHECK:STDOUT: generic fn @EqualEqual(%U.loc11: %I.type) { // CHECK:STDOUT: %U.1: %I.type = bind_symbolic_name U, 0 [symbolic = %U.1 (constants.%U)] // CHECK:STDOUT: -// CHECK:STDOUT: fn(%U.loc13: %I.type); +// CHECK:STDOUT: fn(%U.loc11: %I.type); // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @Impls(%V.loc15: %J.type) { +// CHECK:STDOUT: generic fn @Impls(%V.loc13: %J.type) { // CHECK:STDOUT: %V.1: %J.type = bind_symbolic_name V, 0 [symbolic = %V.1 (constants.%V)] // CHECK:STDOUT: -// CHECK:STDOUT: fn(%V.loc15: %J.type); +// CHECK:STDOUT: fn(%V.loc13: %J.type); // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @And(%W.loc17: %I.type) { +// CHECK:STDOUT: generic fn @And(%W.loc15: %I.type) { // CHECK:STDOUT: %W.1: %I.type = bind_symbolic_name W, 0 [symbolic = %W.1 (constants.%W)] // CHECK:STDOUT: -// CHECK:STDOUT: fn(%W.loc17: %I.type); -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: specific @Equal(constants.%T) { -// CHECK:STDOUT: %T.1 => constants.%T +// CHECK:STDOUT: fn(%W.loc15: %I.type); // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @EqualEqual(constants.%U) { @@ -258,29 +310,41 @@ fn NotEmptyStruct() { // CHECK:STDOUT: %W.1 => constants.%W // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- todo_check_constraints.carbon +// CHECK:STDOUT: --- fail_todo_equal_constraint.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { -// CHECK:STDOUT: %I.type: type = interface_type @I [template] -// CHECK:STDOUT: %Self: %I.type = bind_symbolic_name Self, 0 [symbolic] -// CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic] -// CHECK:STDOUT: %.1: type = tuple_type () [template] -// CHECK:STDOUT: %.2: type = assoc_entity_type %I.type, type [template] -// CHECK:STDOUT: %.3: %.2 = assoc_entity element0, imports.%import_ref.12 [template] -// CHECK:STDOUT: %.4: i32 = int_literal 2 [template] -// CHECK:STDOUT: %X: %I.type = bind_symbolic_name X, 0 [symbolic] -// CHECK:STDOUT: %TypeMismatch.type: type = fn_type @TypeMismatch [template] -// CHECK:STDOUT: %TypeMismatch: %TypeMismatch.type = struct_value () [template] +// CHECK:STDOUT: %N.type: type = interface_type @N [template] +// CHECK:STDOUT: %Self.1: %N.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %.1: type = assoc_entity_type %N.type, type [template] +// CHECK:STDOUT: %.2: %.1 = assoc_entity element0, @N.%P [template] +// CHECK:STDOUT: %.Self: %N.type = bind_symbolic_name .Self, 0 [symbolic] +// CHECK:STDOUT: %.3: type = tuple_type () [template] +// CHECK:STDOUT: %.4: type = struct_type {} [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.2: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Self.3: %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: %.5: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.1 [symbolic] +// CHECK:STDOUT: %.6: %.5 = assoc_entity element0, imports.%import_ref.5 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(%.1) [template] +// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(%.1) [template] +// CHECK:STDOUT: %Convert.2: %Convert.type.2 = struct_value () [template] +// CHECK:STDOUT: %.7: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.2 [template] +// CHECK:STDOUT: %.8: %.7 = assoc_entity element0, imports.%import_ref.5 [template] +// CHECK:STDOUT: %.9: %.5 = assoc_entity element0, imports.%import_ref.6 [symbolic] +// CHECK:STDOUT: %struct: %.4 = struct_value () [template] +// CHECK:STDOUT: %T: %N.type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %Equal.type: type = fn_type @Equal [template] +// CHECK:STDOUT: %Equal: %Equal.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { -// CHECK:STDOUT: %import_ref.1 = import_ref Main//state_constraints, inst+3, unloaded -// CHECK:STDOUT: %import_ref.2: type = import_ref Main//state_constraints, inst+7, loaded [template = constants.%I.type] -// CHECK:STDOUT: %import_ref.3 = import_ref Main//state_constraints, inst+34, unloaded -// CHECK:STDOUT: %import_ref.4 = import_ref Main//state_constraints, inst+48, unloaded -// CHECK:STDOUT: %import_ref.5 = import_ref Main//state_constraints, inst+63, unloaded -// CHECK:STDOUT: %import_ref.6 = import_ref Main//state_constraints, inst+83, unloaded // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %import_ref.1 // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/operators // CHECK:STDOUT: import Core//prelude/types @@ -290,61 +354,808 @@ fn NotEmptyStruct() { // CHECK:STDOUT: import Core//prelude/operators/comparison // CHECK:STDOUT: import Core//prelude/types/bool // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.7 = import_ref Main//state_constraints, inst+9, unloaded -// CHECK:STDOUT: %import_ref.8: %.2 = import_ref Main//state_constraints, inst+13, loaded [template = constants.%.3] -// CHECK:STDOUT: %import_ref.9 = import_ref Main//state_constraints, inst+19, unloaded -// CHECK:STDOUT: %import_ref.10 = import_ref Main//state_constraints, inst+11, unloaded -// CHECK:STDOUT: %import_ref.11 = import_ref Main//state_constraints, inst+17, unloaded -// CHECK:STDOUT: %import_ref.12 = import_ref Main//state_constraints, inst+11, unloaded +// CHECK:STDOUT: %import_ref.1: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.2 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.3: @ImplicitAs.%.1 (%.5) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.9)] +// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .N = %N.decl +// CHECK:STDOUT: .Equal = %Equal.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %N.decl: type = interface_decl @N [template = constants.%N.type] {} {} +// CHECK:STDOUT: %Equal.decl: %Equal.type = fn_decl @Equal [template = constants.%Equal] { +// CHECK:STDOUT: %T.patt: %N.type = symbolic_binding_pattern T, 0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %N.ref: type = name_ref N, file.%N.decl [template = constants.%N.type] +// CHECK:STDOUT: %.Self: %N.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] +// CHECK:STDOUT: %.Self.ref: %N.type = name_ref .Self, %.Self [symbolic = constants.%.Self] +// CHECK:STDOUT: %P.ref: %.1 = name_ref P, @N.%.loc5 [template = constants.%.2] +// CHECK:STDOUT: %.loc15_28.1: %.4 = struct_literal () +// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(constants.%.1) [template = constants.%ImplicitAs.type.3] +// CHECK:STDOUT: %.loc15_28.2: %.7 = specific_constant imports.%import_ref.3, @ImplicitAs(constants.%.1) [template = constants.%.8] +// CHECK:STDOUT: %Convert.ref: %.7 = name_ref Convert, %.loc15_28.2 [template = constants.%.8] +// CHECK:STDOUT: %struct: %.4 = struct_value () [template = constants.%struct] +// CHECK:STDOUT: %.loc15_28.3: %.4 = converted %.loc15_28.1, %struct [template = constants.%struct] +// CHECK:STDOUT: %.loc15_28.4: %.1 = converted %.loc15_28.1, [template = ] +// CHECK:STDOUT: %.loc15_16: type = where_expr %.Self [template = constants.%N.type] { +// CHECK:STDOUT: requirement_rewrite %P.ref, +// CHECK:STDOUT: } +// CHECK:STDOUT: %T.param: %N.type = param T, runtime_param +// CHECK:STDOUT: %T.loc15: %N.type = bind_symbolic_name T, 0, %T.param [symbolic = %T.1 (constants.%T)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: interface @N { +// CHECK:STDOUT: %Self: %N.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.1] +// CHECK:STDOUT: %P: type = assoc_const_decl P [template] +// CHECK:STDOUT: %.loc5: %.1 = assoc_entity element0, %P [template = constants.%.2] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self +// CHECK:STDOUT: .P = %.loc5 +// CHECK:STDOUT: witness = (%P) +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// 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.3)] +// 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.%.5)] +// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.5) = assoc_entity element0, imports.%import_ref.5 [symbolic = %.2 (constants.%.6)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%import_ref.2 +// CHECK:STDOUT: .Convert = imports.%import_ref.3 +// CHECK:STDOUT: witness = (imports.%import_ref.4) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(constants.%Dest: type, constants.%Self.2: @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.3)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self: @Convert.%Self (%Self.3)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Equal(%T.loc15: %N.type) { +// CHECK:STDOUT: %T.1: %N.type = bind_symbolic_name T, 0 [symbolic = %T.1 (constants.%T)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.loc15: %N.type); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.2) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.2 +// CHECK:STDOUT: %Self => constants.%Self.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%.1) { +// CHECK:STDOUT: %Dest => constants.%.1 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3 +// CHECK:STDOUT: %Self => constants.%Self.3 +// CHECK:STDOUT: %Convert.type => constants.%Convert.type.2 +// CHECK:STDOUT: %Convert => constants.%Convert.2 +// CHECK:STDOUT: %.1 => constants.%.7 +// CHECK:STDOUT: %.2 => constants.%.8 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Equal(constants.%T) { +// CHECK:STDOUT: %T.1 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_todo_associated_type_impls.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %L.type: type = interface_type @L [template] +// CHECK:STDOUT: %Self.1: %L.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %M.type: type = interface_type @M [template] +// CHECK:STDOUT: %Self.2: %M.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %K.type: type = interface_type @K [template] +// CHECK:STDOUT: %Self.3: %K.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %.2: type = assoc_entity_type %K.type, %L.type [template] +// CHECK:STDOUT: %.3: %.2 = assoc_entity element0, @K.%Associated [template] +// CHECK:STDOUT: %.Self: %K.type = bind_symbolic_name .Self, 0 [symbolic] +// 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.4: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Self.5: %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.5 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(type) [template] +// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(type) [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.5 [template] +// CHECK:STDOUT: %.8: %.4 = assoc_entity element0, imports.%import_ref.6 [symbolic] +// CHECK:STDOUT: %W: %K.type = bind_symbolic_name W, 0 [symbolic] +// CHECK:STDOUT: %AssociatedTypeImpls.type: type = fn_type @AssociatedTypeImpls [template] +// CHECK:STDOUT: %AssociatedTypeImpls: %AssociatedTypeImpls.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %import_ref.1 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.1: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.2 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.3: @ImplicitAs.%.1 (%.4) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.8)] +// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .L = %L.decl +// CHECK:STDOUT: .M = %M.decl +// CHECK:STDOUT: .K = %K.decl +// CHECK:STDOUT: .AssociatedTypeImpls = %AssociatedTypeImpls.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %L.decl: type = interface_decl @L [template = constants.%L.type] {} {} +// CHECK:STDOUT: %M.decl: type = interface_decl @M [template = constants.%M.type] {} {} +// CHECK:STDOUT: %K.decl: type = interface_decl @K [template = constants.%K.type] {} {} +// CHECK:STDOUT: %AssociatedTypeImpls.decl: %AssociatedTypeImpls.type = fn_decl @AssociatedTypeImpls [template = constants.%AssociatedTypeImpls] { +// CHECK:STDOUT: %W.patt: %K.type = symbolic_binding_pattern W, 0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %K.ref: type = name_ref K, file.%K.decl [template = constants.%K.type] +// CHECK:STDOUT: %.Self: %K.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] +// CHECK:STDOUT: %.Self.ref: %K.type = name_ref .Self, %.Self [symbolic = constants.%.Self] +// CHECK:STDOUT: %Associated.ref: %.2 = name_ref Associated, @K.%.loc8 [template = constants.%.3] +// CHECK:STDOUT: %M.ref: type = name_ref M, file.%M.decl [template = constants.%M.type] +// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(type) [template = constants.%ImplicitAs.type.3] +// CHECK:STDOUT: %.loc18_36.1: %.6 = specific_constant imports.%import_ref.3, @ImplicitAs(type) [template = constants.%.7] +// CHECK:STDOUT: %Convert.ref: %.6 = name_ref Convert, %.loc18_36.1 [template = constants.%.7] +// CHECK:STDOUT: %.loc18_36.2: type = converted %Associated.ref, [template = ] +// CHECK:STDOUT: %.loc18_30: type = where_expr %.Self [template = constants.%K.type] { +// CHECK:STDOUT: requirement_impls , %M.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: %W.param: %K.type = param W, runtime_param +// CHECK:STDOUT: %W.loc18: %K.type = bind_symbolic_name W, 0, %W.param [symbolic = %W.1 (constants.%W)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: interface @L { +// CHECK:STDOUT: %Self: %L.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.1] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self +// CHECK:STDOUT: witness = () +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: interface @M { +// CHECK:STDOUT: %Self: %M.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.2] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self +// CHECK:STDOUT: witness = () +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: interface @K { +// CHECK:STDOUT: %Self: %K.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.3] +// CHECK:STDOUT: %L.ref: type = name_ref L, file.%L.decl [template = constants.%L.type] +// CHECK:STDOUT: %Associated: %L.type = assoc_const_decl Associated [template] +// CHECK:STDOUT: %.loc8: %.2 = assoc_entity element0, %Associated [template = constants.%.3] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self +// CHECK:STDOUT: .Associated = %.loc8 +// CHECK:STDOUT: witness = (%Associated) +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// 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.5)] +// 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.5 [symbolic = %.2 (constants.%.5)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%import_ref.2 +// CHECK:STDOUT: .Convert = imports.%import_ref.3 +// CHECK:STDOUT: witness = (imports.%import_ref.4) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(constants.%Dest: type, constants.%Self.4: @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.5)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self: @Convert.%Self (%Self.5)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @AssociatedTypeImpls(%W.loc18: %K.type) { +// CHECK:STDOUT: %W.1: %K.type = bind_symbolic_name W, 0 [symbolic = %W.1 (constants.%W)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%W.loc18: %K.type); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.4) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.2 +// CHECK:STDOUT: %Self => constants.%Self.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(type) { +// CHECK:STDOUT: %Dest => type +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3 +// CHECK:STDOUT: %Self => constants.%Self.5 +// 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: +// CHECK:STDOUT: specific @AssociatedTypeImpls(constants.%W) { +// CHECK:STDOUT: %W.1 => constants.%W +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_check_rewrite_constraints.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %I.type: type = interface_type @I [template] +// CHECK:STDOUT: %Self.1: %I.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic] +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %.2: type = assoc_entity_type %I.type, type [template] +// CHECK:STDOUT: %.3: %.2 = assoc_entity element0, imports.%import_ref.11 [template] +// CHECK:STDOUT: %.4: i32 = int_literal 2 [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.2: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.2) = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Self.3: %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: %.5: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.1 [symbolic] +// CHECK:STDOUT: %.6: %.5 = assoc_entity element0, imports.%import_ref.16 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(%.2) [template] +// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(%.2) [template] +// CHECK:STDOUT: %Convert.2: %Convert.type.2 = struct_value () [template] +// CHECK:STDOUT: %.7: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.2 [template] +// CHECK:STDOUT: %.8: %.7 = assoc_entity element0, imports.%import_ref.16 [template] +// CHECK:STDOUT: %.9: %.5 = assoc_entity element0, imports.%import_ref.17 [symbolic] +// CHECK:STDOUT: %X: %I.type = bind_symbolic_name X, 0 [symbolic] +// CHECK:STDOUT: %RewriteTypeMismatch.type: type = fn_type @RewriteTypeMismatch [template] +// CHECK:STDOUT: %RewriteTypeMismatch: %RewriteTypeMismatch.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %import_ref.1 = import_ref Main//state_constraints, inst+3, unloaded +// CHECK:STDOUT: %import_ref.2: type = import_ref Main//state_constraints, inst+7, loaded [template = constants.%I.type] +// CHECK:STDOUT: %import_ref.3 = import_ref Main//state_constraints, inst+32, unloaded +// CHECK:STDOUT: %import_ref.4 = import_ref Main//state_constraints, inst+49, unloaded +// CHECK:STDOUT: %import_ref.5 = import_ref Main//state_constraints, inst+69, unloaded +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %import_ref.12 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.6 = import_ref Main//state_constraints, inst+9, unloaded +// CHECK:STDOUT: %import_ref.7: %.2 = import_ref Main//state_constraints, inst+13, loaded [template = constants.%.3] +// CHECK:STDOUT: %import_ref.8 = import_ref Main//state_constraints, inst+19, unloaded +// CHECK:STDOUT: %import_ref.9 = import_ref Main//state_constraints, inst+11, unloaded +// CHECK:STDOUT: %import_ref.10 = import_ref Main//state_constraints, inst+17, unloaded +// CHECK:STDOUT: %import_ref.11 = import_ref Main//state_constraints, inst+11, unloaded +// CHECK:STDOUT: %import_ref.12: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.13 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.14: @ImplicitAs.%.1 (%.5) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.9)] +// CHECK:STDOUT: %import_ref.15 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.16 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.17 = import_ref Core//prelude/operators/as, inst+56, unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .J = imports.%import_ref.1 // CHECK:STDOUT: .I = imports.%import_ref.2 -// CHECK:STDOUT: .Equal = imports.%import_ref.3 -// CHECK:STDOUT: .EqualEqual = imports.%import_ref.4 -// CHECK:STDOUT: .Impls = imports.%import_ref.5 -// CHECK:STDOUT: .And = imports.%import_ref.6 +// CHECK:STDOUT: .EqualEqual = imports.%import_ref.3 +// CHECK:STDOUT: .Impls = imports.%import_ref.4 +// CHECK:STDOUT: .And = imports.%import_ref.5 // CHECK:STDOUT: .Core = imports.%Core -// CHECK:STDOUT: .TypeMismatch = %TypeMismatch.decl +// CHECK:STDOUT: .RewriteTypeMismatch = %RewriteTypeMismatch.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %default.import = import -// CHECK:STDOUT: %TypeMismatch.decl: %TypeMismatch.type = fn_decl @TypeMismatch [template = constants.%TypeMismatch] { +// CHECK:STDOUT: %RewriteTypeMismatch.decl: %RewriteTypeMismatch.type = fn_decl @RewriteTypeMismatch [template = constants.%RewriteTypeMismatch] { // CHECK:STDOUT: %X.patt: %I.type = symbolic_binding_pattern X, 0 // CHECK:STDOUT: } { // CHECK:STDOUT: %I.ref: type = name_ref I, imports.%import_ref.2 [template = constants.%I.type] // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] // CHECK:STDOUT: %.Self.ref: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self] -// CHECK:STDOUT: %Member.ref: %.2 = name_ref Member, imports.%import_ref.8 [template = constants.%.3] -// CHECK:STDOUT: %.loc8_39: i32 = int_literal 2 [template = constants.%.4] -// CHECK:STDOUT: %.loc8_23: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_rewrite %Member.ref, %.loc8_39 +// CHECK:STDOUT: %Member.ref: %.2 = name_ref Member, imports.%import_ref.7 [template = constants.%.3] +// CHECK:STDOUT: %.loc16_46.1: i32 = int_literal 2 [template = constants.%.4] +// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(constants.%.2) [template = constants.%ImplicitAs.type.3] +// CHECK:STDOUT: %.loc16_46.2: %.7 = specific_constant imports.%import_ref.14, @ImplicitAs(constants.%.2) [template = constants.%.8] +// CHECK:STDOUT: %Convert.ref: %.7 = name_ref Convert, %.loc16_46.2 [template = constants.%.8] +// CHECK:STDOUT: %.loc16_46.3: %.2 = converted %.loc16_46.1, [template = ] +// CHECK:STDOUT: %.loc16_30: type = where_expr %.Self [template = constants.%I.type] { +// CHECK:STDOUT: requirement_rewrite %Member.ref, // CHECK:STDOUT: } // CHECK:STDOUT: %X.param: %I.type = param X, runtime_param -// CHECK:STDOUT: %X.loc8: %I.type = bind_symbolic_name X, 0, %X.param [symbolic = %X.1 (constants.%X)] +// CHECK:STDOUT: %X.loc16: %I.type = bind_symbolic_name X, 0, %X.param [symbolic = %X.1 (constants.%X)] // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: interface @I { // CHECK:STDOUT: !members: -// CHECK:STDOUT: .Self = imports.%import_ref.7 -// CHECK:STDOUT: .Member = imports.%import_ref.8 -// CHECK:STDOUT: .Second = imports.%import_ref.9 -// CHECK:STDOUT: witness = (imports.%import_ref.10, imports.%import_ref.11) +// CHECK:STDOUT: .Self = imports.%import_ref.6 +// CHECK:STDOUT: .Member = imports.%import_ref.7 +// CHECK:STDOUT: .Second = imports.%import_ref.8 +// CHECK:STDOUT: witness = (imports.%import_ref.9, imports.%import_ref.10) // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @TypeMismatch(%X.loc8: %I.type) { +// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// 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.3)] +// 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.%.5)] +// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.5) = assoc_entity element0, imports.%import_ref.16 [symbolic = %.2 (constants.%.6)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%import_ref.13 +// CHECK:STDOUT: .Convert = imports.%import_ref.14 +// CHECK:STDOUT: witness = (imports.%import_ref.15) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(constants.%Dest: type, constants.%Self.2: @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.3)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self: @Convert.%Self (%Self.3)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @RewriteTypeMismatch(%X.loc16: %I.type) { // CHECK:STDOUT: %X.1: %I.type = bind_symbolic_name X, 0 [symbolic = %X.1 (constants.%X)] // CHECK:STDOUT: -// CHECK:STDOUT: fn(%X.loc8: %I.type); +// CHECK:STDOUT: fn(%X.loc16: %I.type); // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: specific @TypeMismatch(constants.%X) { +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.2) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.2 +// CHECK:STDOUT: %Self => constants.%Self.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%.2) { +// CHECK:STDOUT: %Dest => constants.%.2 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.3 +// CHECK:STDOUT: %Self => constants.%Self.3 +// CHECK:STDOUT: %Convert.type => constants.%Convert.type.2 +// CHECK:STDOUT: %Convert => constants.%Convert.2 +// CHECK:STDOUT: %.1 => constants.%.7 +// CHECK:STDOUT: %.2 => constants.%.8 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @RewriteTypeMismatch(constants.%X) { // CHECK:STDOUT: %X.1 => constants.%X // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: --- fail_left_of_impls_non_type.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.Self: type = bind_symbolic_name .Self, 0 [symbolic] +// CHECK:STDOUT: %.1: i32 = int_literal 7 [template] +// CHECK:STDOUT: %ImplicitAs.type.1: type = generic_interface_type @ImplicitAs [template] +// CHECK:STDOUT: %.2: type = tuple_type () [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: %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: %.3: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.1 [symbolic] +// CHECK:STDOUT: %.4: %.3 = assoc_entity element0, imports.%import_ref.5 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(type) [template] +// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(type) [template] +// CHECK:STDOUT: %Convert.2: %Convert.type.2 = struct_value () [template] +// CHECK:STDOUT: %.5: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.2 [template] +// CHECK:STDOUT: %.6: %.5 = assoc_entity element0, imports.%import_ref.5 [template] +// CHECK:STDOUT: %.7: %.3 = assoc_entity element0, imports.%import_ref.6 [symbolic] +// CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic] +// CHECK:STDOUT: %NonTypeImpls.type: type = fn_type @NonTypeImpls [template] +// CHECK:STDOUT: %NonTypeImpls: %NonTypeImpls.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %import_ref.1 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.1: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.2 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.3: @ImplicitAs.%.1 (%.3) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.7)] +// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .NonTypeImpls = %NonTypeImpls.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %NonTypeImpls.decl: %NonTypeImpls.type = fn_decl @NonTypeImpls [template = constants.%NonTypeImpls] { +// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %.Self: type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] +// CHECK:STDOUT: %.loc11_32.1: i32 = int_literal 7 [template = constants.%.1] +// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(type) [template = constants.%ImplicitAs.type.3] +// CHECK:STDOUT: %.loc11_32.2: %.5 = specific_constant imports.%import_ref.3, @ImplicitAs(type) [template = constants.%.6] +// CHECK:STDOUT: %Convert.ref: %.5 = name_ref Convert, %.loc11_32.2 [template = constants.%.6] +// CHECK:STDOUT: %.loc11_32.3: type = converted %.loc11_32.1, [template = ] +// CHECK:STDOUT: %.loc11_26: type = where_expr %.Self [template = type] { +// CHECK:STDOUT: requirement_impls , type +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.param: type = param U, runtime_param +// CHECK:STDOUT: %U.loc11: type = bind_symbolic_name U, 0, %U.param [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// 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.%.3)] +// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.3) = assoc_entity element0, imports.%import_ref.5 [symbolic = %.2 (constants.%.4)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%import_ref.2 +// CHECK:STDOUT: .Convert = imports.%import_ref.3 +// CHECK:STDOUT: witness = (imports.%import_ref.4) +// CHECK:STDOUT: } +// 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: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @NonTypeImpls(%U.loc11: type) { +// CHECK:STDOUT: %U.1: type = bind_symbolic_name U, 0 [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%U.loc11: type); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) { +// CHECK:STDOUT: %Dest => 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(type) { +// CHECK:STDOUT: %Dest => type +// 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.%.5 +// CHECK:STDOUT: %.2 => constants.%.6 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @NonTypeImpls(constants.%U) { +// CHECK:STDOUT: %U.1 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_right_of_impls_non_type.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.Self: type = bind_symbolic_name .Self, 0 [symbolic] +// CHECK:STDOUT: %.1: i32 = int_literal 7 [template] +// CHECK:STDOUT: %ImplicitAs.type.1: type = generic_interface_type @ImplicitAs [template] +// CHECK:STDOUT: %.2: type = tuple_type () [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: %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: %.3: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.1 [symbolic] +// CHECK:STDOUT: %.4: %.3 = assoc_entity element0, imports.%import_ref.5 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(type) [template] +// CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(type) [template] +// CHECK:STDOUT: %Convert.2: %Convert.type.2 = struct_value () [template] +// CHECK:STDOUT: %.5: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.2 [template] +// CHECK:STDOUT: %.6: %.5 = assoc_entity element0, imports.%import_ref.5 [template] +// CHECK:STDOUT: %.7: %.3 = assoc_entity element0, imports.%import_ref.6 [symbolic] +// CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic] +// CHECK:STDOUT: %ImplsNonType.type: type = fn_type @ImplsNonType [template] +// CHECK:STDOUT: %ImplsNonType: %ImplsNonType.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %import_ref.1 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.1: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.2 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.3: @ImplicitAs.%.1 (%.3) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.7)] +// CHECK:STDOUT: %import_ref.4 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.5 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: %import_ref.6 = import_ref Core//prelude/operators/as, inst+56, unloaded +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .ImplsNonType = %ImplsNonType.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %ImplsNonType.decl: %ImplsNonType.type = fn_decl @ImplsNonType [template = constants.%ImplsNonType] { +// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %.Self: type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] +// CHECK:STDOUT: %.Self.ref: type = name_ref .Self, %.Self [symbolic = constants.%.Self] +// CHECK:STDOUT: %.loc11_44.1: i32 = int_literal 7 [template = constants.%.1] +// CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(type) [template = constants.%ImplicitAs.type.3] +// CHECK:STDOUT: %.loc11_44.2: %.5 = specific_constant imports.%import_ref.3, @ImplicitAs(type) [template = constants.%.6] +// CHECK:STDOUT: %Convert.ref: %.5 = name_ref Convert, %.loc11_44.2 [template = constants.%.6] +// CHECK:STDOUT: %.loc11_44.3: type = converted %.loc11_44.1, [template = ] +// CHECK:STDOUT: %.loc11_26: type = where_expr %.Self [template = type] { +// CHECK:STDOUT: requirement_impls %.Self.ref, +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.param: type = param U, runtime_param +// CHECK:STDOUT: %U.loc11: type = bind_symbolic_name U, 0, %U.param [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(constants.%Dest: type) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// 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.%.3)] +// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.3) = assoc_entity element0, imports.%import_ref.5 [symbolic = %.2 (constants.%.4)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%import_ref.2 +// CHECK:STDOUT: .Convert = imports.%import_ref.3 +// CHECK:STDOUT: witness = (imports.%import_ref.4) +// CHECK:STDOUT: } +// 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: @Convert.%Self (%Self.2)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @ImplsNonType(%U.loc11: type) { +// CHECK:STDOUT: %U.1: type = bind_symbolic_name U, 0 [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%U.loc11: type); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@ImplicitAs.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) { +// CHECK:STDOUT: %Dest => 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(type) { +// CHECK:STDOUT: %Dest => type +// 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.%.5 +// CHECK:STDOUT: %.2 => constants.%.6 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplsNonType(constants.%U) { +// CHECK:STDOUT: %U.1 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_right_of_impls_non_facet_type.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %.Self: type = bind_symbolic_name .Self, 0 [symbolic] +// CHECK:STDOUT: %Int32.type: type = fn_type @Int32 [template] +// CHECK:STDOUT: %.1: type = tuple_type () [template] +// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template] +// CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic] +// CHECK:STDOUT: %ImplsOfNonFacetType.type: type = fn_type @ImplsOfNonFacetType [template] +// CHECK:STDOUT: %ImplsOfNonFacetType: %ImplsOfNonFacetType.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int32 = %import_ref +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref: %Int32.type = import_ref Core//prelude/types, inst+4, loaded [template = constants.%Int32] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .ImplsOfNonFacetType = %ImplsOfNonFacetType.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %ImplsOfNonFacetType.decl: %ImplsOfNonFacetType.type = fn_decl @ImplsOfNonFacetType [template = constants.%ImplsOfNonFacetType] { +// CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %.Self: type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] +// CHECK:STDOUT: %.Self.ref: type = name_ref .Self, %.Self [symbolic = constants.%.Self] +// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc8_51.1: type = value_of_initializer %int.make_type_32 [template = i32] +// CHECK:STDOUT: %.loc8_51.2: type = converted %int.make_type_32, %.loc8_51.1 [template = i32] +// CHECK:STDOUT: %.loc8_33: type = where_expr %.Self [template = type] { +// CHECK:STDOUT: requirement_impls %.Self.ref, +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.param: type = param U, runtime_param +// CHECK:STDOUT: %U.loc8: type = bind_symbolic_name U, 0, %U.param [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @ImplsOfNonFacetType(%U.loc8: type) { +// CHECK:STDOUT: %U.1: type = bind_symbolic_name U, 0 [symbolic = %U.1 (constants.%U)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%U.loc8: type); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplsOfNonFacetType(constants.%U) { +// CHECK:STDOUT: %U.1 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_enforce_constraint.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -369,13 +1180,13 @@ fn NotEmptyStruct() { // CHECK:STDOUT: %Convert.type.1: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic] // CHECK:STDOUT: %Convert.1: %Convert.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %.5: type = assoc_entity_type %ImplicitAs.type.2, %Convert.type.1 [symbolic] -// CHECK:STDOUT: %.6: %.5 = assoc_entity element0, imports.%import_ref.12 [symbolic] +// CHECK:STDOUT: %.6: %.5 = assoc_entity element0, imports.%import_ref.11 [symbolic] // CHECK:STDOUT: %ImplicitAs.type.3: type = interface_type @ImplicitAs, @ImplicitAs(%J.type) [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert, @ImplicitAs(%J.type) [template] // CHECK:STDOUT: %Convert.2: %Convert.type.2 = struct_value () [template] // CHECK:STDOUT: %.7: type = assoc_entity_type %ImplicitAs.type.3, %Convert.type.2 [template] -// CHECK:STDOUT: %.8: %.7 = assoc_entity element0, imports.%import_ref.12 [template] -// CHECK:STDOUT: %.9: %.5 = assoc_entity element0, imports.%import_ref.13 [symbolic] +// CHECK:STDOUT: %.8: %.7 = assoc_entity element0, imports.%import_ref.11 [template] +// CHECK:STDOUT: %.9: %.5 = assoc_entity element0, imports.%import_ref.12 [symbolic] // CHECK:STDOUT: %.Self: %J.type = bind_symbolic_name .Self, 0 [symbolic] // CHECK:STDOUT: %Y: %J.type = bind_symbolic_name Y, 0 [symbolic] // CHECK:STDOUT: %EmptyStruct.type: type = fn_type @EmptyStruct [template] @@ -387,12 +1198,11 @@ fn NotEmptyStruct() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %import_ref.1: type = import_ref Main//state_constraints, inst+3, loaded [template = constants.%J.type] // CHECK:STDOUT: %import_ref.2 = import_ref Main//state_constraints, inst+7, unloaded -// CHECK:STDOUT: %import_ref.3 = import_ref Main//state_constraints, inst+34, unloaded -// CHECK:STDOUT: %import_ref.4 = import_ref Main//state_constraints, inst+48, unloaded -// CHECK:STDOUT: %import_ref.5: %Impls.type = import_ref Main//state_constraints, inst+63, loaded [template = constants.%Impls] -// CHECK:STDOUT: %import_ref.6 = import_ref Main//state_constraints, inst+83, unloaded +// CHECK:STDOUT: %import_ref.3 = import_ref Main//state_constraints, inst+32, unloaded +// CHECK:STDOUT: %import_ref.4: %Impls.type = import_ref Main//state_constraints, inst+49, loaded [template = constants.%Impls] +// CHECK:STDOUT: %import_ref.5 = import_ref Main//state_constraints, inst+69, unloaded // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { -// CHECK:STDOUT: .ImplicitAs = %import_ref.8 +// CHECK:STDOUT: .ImplicitAs = %import_ref.7 // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/operators // CHECK:STDOUT: import Core//prelude/types @@ -402,23 +1212,22 @@ fn NotEmptyStruct() { // CHECK:STDOUT: import Core//prelude/operators/comparison // CHECK:STDOUT: import Core//prelude/types/bool // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.7 = import_ref Main//state_constraints, inst+5, unloaded -// CHECK:STDOUT: %import_ref.8: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] -// CHECK:STDOUT: %import_ref.9 = import_ref Core//prelude/operators/as, inst+45, unloaded -// CHECK:STDOUT: %import_ref.10: @ImplicitAs.%.1 (%.5) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.9)] +// CHECK:STDOUT: %import_ref.6 = import_ref Main//state_constraints, inst+5, unloaded +// CHECK:STDOUT: %import_ref.7: %ImplicitAs.type.1 = import_ref Core//prelude/operators/as, inst+40, loaded [template = constants.%ImplicitAs] +// CHECK:STDOUT: %import_ref.8 = import_ref Core//prelude/operators/as, inst+45, unloaded +// CHECK:STDOUT: %import_ref.9: @ImplicitAs.%.1 (%.5) = import_ref Core//prelude/operators/as, inst+63, loaded [symbolic = @ImplicitAs.%.2 (constants.%.9)] +// CHECK:STDOUT: %import_ref.10 = import_ref Core//prelude/operators/as, inst+56, unloaded // CHECK:STDOUT: %import_ref.11 = import_ref Core//prelude/operators/as, inst+56, unloaded // CHECK:STDOUT: %import_ref.12 = import_ref Core//prelude/operators/as, inst+56, unloaded -// CHECK:STDOUT: %import_ref.13 = import_ref Core//prelude/operators/as, inst+56, unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .J = imports.%import_ref.1 // CHECK:STDOUT: .I = imports.%import_ref.2 -// CHECK:STDOUT: .Equal = imports.%import_ref.3 -// CHECK:STDOUT: .EqualEqual = imports.%import_ref.4 -// CHECK:STDOUT: .Impls = imports.%import_ref.5 -// CHECK:STDOUT: .And = imports.%import_ref.6 +// CHECK:STDOUT: .EqualEqual = imports.%import_ref.3 +// CHECK:STDOUT: .Impls = imports.%import_ref.4 +// CHECK:STDOUT: .And = imports.%import_ref.5 // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: .DoesNotImplI = %DoesNotImplI.decl @@ -451,7 +1260,7 @@ fn NotEmptyStruct() { // CHECK:STDOUT: // CHECK:STDOUT: interface @J { // CHECK:STDOUT: !members: -// CHECK:STDOUT: .Self = imports.%import_ref.7 +// CHECK:STDOUT: .Self = imports.%import_ref.6 // CHECK:STDOUT: witness = () // CHECK:STDOUT: } // CHECK:STDOUT: @@ -464,13 +1273,13 @@ fn NotEmptyStruct() { // 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.%.5)] -// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.5) = assoc_entity element0, imports.%import_ref.12 [symbolic = %.2 (constants.%.6)] +// CHECK:STDOUT: %.2: @ImplicitAs.%.1 (%.5) = assoc_entity element0, imports.%import_ref.11 [symbolic = %.2 (constants.%.6)] // CHECK:STDOUT: // CHECK:STDOUT: interface { // CHECK:STDOUT: !members: -// CHECK:STDOUT: .Self = imports.%import_ref.9 -// CHECK:STDOUT: .Convert = imports.%import_ref.10 -// CHECK:STDOUT: witness = (imports.%import_ref.11) +// CHECK:STDOUT: .Self = imports.%import_ref.8 +// CHECK:STDOUT: .Convert = imports.%import_ref.9 +// CHECK:STDOUT: witness = (imports.%import_ref.10) // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -490,10 +1299,10 @@ fn NotEmptyStruct() { // CHECK:STDOUT: // CHECK:STDOUT: fn @DoesNotImplI() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Impls.ref: %Impls.type = name_ref Impls, imports.%import_ref.5 [template = constants.%Impls] +// CHECK:STDOUT: %Impls.ref: %Impls.type = name_ref Impls, imports.%import_ref.4 [template = constants.%Impls] // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] // CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(constants.%J.type) [template = constants.%ImplicitAs.type.3] -// CHECK:STDOUT: %.loc23_8.1: %.7 = specific_constant imports.%import_ref.10, @ImplicitAs(constants.%J.type) [template = constants.%.8] +// CHECK:STDOUT: %.loc23_8.1: %.7 = specific_constant imports.%import_ref.9, @ImplicitAs(constants.%J.type) [template = constants.%.8] // CHECK:STDOUT: %Convert.ref: %.7 = name_ref Convert, %.loc23_8.1 [template = constants.%.8] // CHECK:STDOUT: %.loc23_8.2: %J.type = converted %C.ref, [template = ] // CHECK:STDOUT: return @@ -524,7 +1333,7 @@ fn NotEmptyStruct() { // CHECK:STDOUT: %EmptyStruct.ref: %EmptyStruct.type = name_ref EmptyStruct, file.%EmptyStruct.decl [template = constants.%EmptyStruct] // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] // CHECK:STDOUT: %ImplicitAs.type: type = interface_type @ImplicitAs, @ImplicitAs(constants.%J.type) [template = constants.%ImplicitAs.type.3] -// CHECK:STDOUT: %.loc39_14.1: %.7 = specific_constant imports.%import_ref.10, @ImplicitAs(constants.%J.type) [template = constants.%.8] +// CHECK:STDOUT: %.loc39_14.1: %.7 = specific_constant imports.%import_ref.9, @ImplicitAs(constants.%J.type) [template = constants.%.8] // CHECK:STDOUT: %Convert.ref: %.7 = name_ref Convert, %.loc39_14.1 [template = constants.%.8] // CHECK:STDOUT: %.loc39_14.2: %J.type = converted %C.ref, [template = ] // CHECK:STDOUT: return diff --git a/toolchain/check/testdata/where_expr/no_prelude/designator.carbon b/toolchain/check/testdata/where_expr/designator.carbon similarity index 78% rename from toolchain/check/testdata/where_expr/no_prelude/designator.carbon rename to toolchain/check/testdata/where_expr/designator.carbon index bc985aa13e7e..51dfd474272f 100644 --- a/toolchain/check/testdata/where_expr/no_prelude/designator.carbon +++ b/toolchain/check/testdata/where_expr/designator.carbon @@ -4,9 +4,9 @@ // // AUTOUPDATE // TIP: To test this file alone, run: -// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/where_expr/no_prelude/designator.carbon +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/where_expr/designator.carbon // TIP: To dump output, run: -// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/where_expr/no_prelude/designator.carbon +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/where_expr/designator.carbon // --- success.carbon @@ -18,7 +18,7 @@ interface I { fn PeriodSelf(T:! I where .Self == ()); -fn PeriodMember(U:! I where .Member = {}); +fn PeriodMember(U:! I where .Member == ()); fn TypeSelfImpls(V:! type where .Self impls I); @@ -98,7 +98,6 @@ class D { // CHECK:STDOUT: %T: %I.type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %PeriodSelf.type: type = fn_type @PeriodSelf [template] // CHECK:STDOUT: %PeriodSelf: %PeriodSelf.type = struct_value () [template] -// CHECK:STDOUT: %.4: type = struct_type {} [template] // CHECK:STDOUT: %U: %I.type = bind_symbolic_name U, 0 [symbolic] // CHECK:STDOUT: %PeriodMember.type: type = fn_type @PeriodMember [template] // CHECK:STDOUT: %PeriodMember: %PeriodMember.type = struct_value () [template] @@ -108,13 +107,28 @@ class D { // CHECK:STDOUT: %TypeSelfImpls: %TypeSelfImpls.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .I = %I.decl // CHECK:STDOUT: .PeriodSelf = %PeriodSelf.decl // CHECK:STDOUT: .PeriodMember = %PeriodMember.decl // CHECK:STDOUT: .TypeSelfImpls = %TypeSelfImpls.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %I.decl: type = interface_decl @I [template = constants.%I.type] {} {} // CHECK:STDOUT: %PeriodSelf.decl: %PeriodSelf.type = fn_decl @PeriodSelf [template = constants.%PeriodSelf] { // CHECK:STDOUT: %T.patt: %I.type = symbolic_binding_pattern T, 0 @@ -136,9 +150,9 @@ class D { // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self.1] // CHECK:STDOUT: %.Self.ref: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self.1] // CHECK:STDOUT: %Member.ref: %.1 = name_ref Member, @I.%.loc5 [template = constants.%.2] -// CHECK:STDOUT: %.loc10_40: %.4 = struct_literal () +// CHECK:STDOUT: %.loc10_41: %.3 = tuple_literal () // CHECK:STDOUT: %.loc10_23: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_rewrite %Member.ref, %.loc10_40 +// CHECK:STDOUT: requirement_equivalent %Member.ref, %.loc10_41 // CHECK:STDOUT: } // CHECK:STDOUT: %U.param: %I.type = param U, runtime_param // CHECK:STDOUT: %U.loc10: %I.type = bind_symbolic_name U, 0, %U.param [symbolic = %U.1 (constants.%U)] @@ -213,11 +227,26 @@ class D { // CHECK:STDOUT: %PeriodMismatch: %PeriodMismatch.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .J = %J.decl // CHECK:STDOUT: .PeriodMismatch = %PeriodMismatch.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %J.decl: type = interface_decl @J [template = constants.%J.type] {} {} // CHECK:STDOUT: %PeriodMismatch.decl: %PeriodMismatch.type = fn_decl @PeriodMismatch [template = constants.%PeriodMismatch] { // CHECK:STDOUT: %W.patt: %J.type = symbolic_binding_pattern W, 0 @@ -228,7 +257,7 @@ class D { // CHECK:STDOUT: %Mismatch.ref: = name_ref Mismatch, [template = ] // CHECK:STDOUT: %.loc12_44: %.4 = struct_literal () // CHECK:STDOUT: %.loc12_25: type = where_expr %.Self [template = constants.%J.type] { -// CHECK:STDOUT: requirement_rewrite %Mismatch.ref, %.loc12_44 +// CHECK:STDOUT: requirement_rewrite %Mismatch.ref, // CHECK:STDOUT: } // CHECK:STDOUT: %W.param: %J.type = param W, runtime_param // CHECK:STDOUT: %W.loc12: %J.type = bind_symbolic_name W, 0, %W.param [symbolic = %W.1 (constants.%W)] @@ -264,10 +293,25 @@ class D { // CHECK:STDOUT: %Foo: %Foo.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Foo = %Foo.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Foo.decl: %Foo.type = fn_decl @Foo [template = constants.%Foo] {} { // CHECK:STDOUT: %.loc4_14.1: %.1 = tuple_literal () // CHECK:STDOUT: %.loc4_14.2: type = converted %.loc4_14.1, constants.%.1 [template = constants.%.1] @@ -293,10 +337,25 @@ class D { // CHECK:STDOUT: %Bar: %Bar.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .Bar = %Bar.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Bar.decl: %Bar.type = fn_decl @Bar [template = constants.%Bar] {} { // CHECK:STDOUT: %.loc4_14.1: %.1 = tuple_literal () // CHECK:STDOUT: %.loc4_14.2: type = converted %.loc4_14.1, constants.%.1 [template = constants.%.1] @@ -322,10 +381,25 @@ class D { // CHECK:STDOUT: %.4: type = ptr_type %.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {} // CHECK:STDOUT: } // CHECK:STDOUT: @@ -358,10 +432,25 @@ class D { // CHECK:STDOUT: %.3: = complete_type_witness %.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .D = %D.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %D.decl: type = class_decl @D [template = constants.%D] {} {} // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/where_expr/fail_not_facet.carbon b/toolchain/check/testdata/where_expr/fail_not_facet.carbon new file mode 100644 index 000000000000..31df1480c59a --- /dev/null +++ b/toolchain/check/testdata/where_expr/fail_not_facet.carbon @@ -0,0 +1,87 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/where_expr/fail_not_facet.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/where_expr/fail_not_facet.carbon + +// --- fail_left_where_not_facet.carbon + +library "[[@TEST_NAME]]"; + +// CHECK:STDERR: fail_left_where_not_facet.carbon:[[@LINE+3]]:10: error: left argument of `where` operator must be a facet type +// CHECK:STDERR: fn F(T:! i32 where .Self == bool); +// CHECK:STDERR: ^~~ +fn F(T:! i32 where .Self == bool); + +// CHECK:STDOUT: --- fail_left_where_not_facet.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// 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: %.Self: = bind_symbolic_name .Self, 0 [symbolic] +// CHECK:STDOUT: %Bool.type: type = fn_type @Bool [template] +// CHECK:STDOUT: %Bool: %Bool.type = struct_value () [template] +// CHECK:STDOUT: %T: = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int32 = %import_ref.1 +// CHECK:STDOUT: .Bool = %import_ref.2 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.1: %Int32.type = import_ref Core//prelude/types, inst+4, loaded [template = constants.%Int32] +// CHECK:STDOUT: %import_ref.2: %Bool.type = import_ref Core//prelude/types/bool, inst+2, loaded [template = constants.%Bool] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %T.patt: = symbolic_binding_pattern T, 0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc7_10.1: type = value_of_initializer %int.make_type_32 [template = i32] +// CHECK:STDOUT: %.loc7_10.2: type = converted %int.make_type_32, %.loc7_10.1 [template = i32] +// CHECK:STDOUT: %.Self: = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] +// CHECK:STDOUT: %.Self.ref: = name_ref .Self, %.Self [symbolic = constants.%.Self] +// CHECK:STDOUT: %bool.make_type: init type = call constants.%Bool() [template = bool] +// CHECK:STDOUT: %.loc7_14: type = where_expr %.Self [template = ] { +// CHECK:STDOUT: requirement_equivalent %.Self.ref, %bool.make_type +// CHECK:STDOUT: } +// CHECK:STDOUT: %T.param: = param T, runtime_param +// CHECK:STDOUT: %T.loc7: = bind_symbolic_name T, 0, %T.param [symbolic = %T.1 (constants.%T)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Bool() -> type = "bool.make_type"; +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%T.loc7: ) { +// CHECK:STDOUT: %T.1: = bind_symbolic_name T, 0 [symbolic = %T.1 (constants.%T)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.loc7: ); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%T) { +// CHECK:STDOUT: %T.1 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/where_expr/no_prelude/non_generic.carbon b/toolchain/check/testdata/where_expr/non_generic.carbon similarity index 65% rename from toolchain/check/testdata/where_expr/no_prelude/non_generic.carbon rename to toolchain/check/testdata/where_expr/non_generic.carbon index f85818cce67d..37cf9064dd26 100644 --- a/toolchain/check/testdata/where_expr/no_prelude/non_generic.carbon +++ b/toolchain/check/testdata/where_expr/non_generic.carbon @@ -4,14 +4,14 @@ // // AUTOUPDATE // TIP: To test this file alone, run: -// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/where_expr/no_prelude/non_generic.carbon +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/where_expr/non_generic.carbon // TIP: To dump output, run: -// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/where_expr/no_prelude/non_generic.carbon +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/where_expr/non_generic.carbon interface I { let T:! type; } // Ensure that we don't crash when checking this `where` in a non-generic context. -fn NotGenericF(U: I where .T = {}) {} +fn NotGenericF(U: I where .T == i32) {} // CHECK:STDOUT: --- non_generic.carbon // CHECK:STDOUT: @@ -22,16 +22,34 @@ fn NotGenericF(U: I where .T = {}) {} // CHECK:STDOUT: %.2: %.1 = assoc_entity element0, @I.%T [template] // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic] // CHECK:STDOUT: %.3: type = tuple_type () [template] -// CHECK:STDOUT: %.4: type = struct_type {} [template] +// CHECK:STDOUT: %Int32.type: type = fn_type @Int32 [template] +// CHECK:STDOUT: %Int32: %Int32.type = struct_value () [template] // CHECK:STDOUT: %NotGenericF.type: type = fn_type @NotGenericF [template] // CHECK:STDOUT: %NotGenericF: %NotGenericF.type = struct_value () [template] // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int32 = %import_ref +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/operators +// CHECK:STDOUT: import Core//prelude/types +// CHECK:STDOUT: import Core//prelude/operators/arithmetic +// CHECK:STDOUT: import Core//prelude/operators/as +// CHECK:STDOUT: import Core//prelude/operators/bitwise +// CHECK:STDOUT: import Core//prelude/operators/comparison +// CHECK:STDOUT: import Core//prelude/types/bool +// CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref: %Int32.type = import_ref Core//prelude/types, inst+4, loaded [template = constants.%Int32] +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: file { // CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .I = %I.decl // CHECK:STDOUT: .NotGenericF = %NotGenericF.decl // CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %I.decl: type = interface_decl @I [template = constants.%I.type] {} {} // CHECK:STDOUT: %NotGenericF.decl: %NotGenericF.type = fn_decl @NotGenericF [template = constants.%NotGenericF] { // CHECK:STDOUT: %U.patt: %I.type = binding_pattern U @@ -40,9 +58,9 @@ fn NotGenericF(U: I where .T = {}) {} // CHECK:STDOUT: %.Self: %I.type = bind_symbolic_name .Self, 0 [symbolic = constants.%.Self] // CHECK:STDOUT: %.Self.ref: %I.type = name_ref .Self, %.Self [symbolic = constants.%.Self] // CHECK:STDOUT: %T.ref: %.1 = name_ref T, @I.%.loc11 [template = constants.%.2] -// CHECK:STDOUT: %.loc14_33: %.4 = struct_literal () -// CHECK:STDOUT: %.loc14_21: type = where_expr %.Self [template = constants.%I.type] { -// CHECK:STDOUT: requirement_rewrite %T.ref, %.loc14_33 +// CHECK:STDOUT: %int.make_type_32: init type = call constants.%Int32() [template = i32] +// CHECK:STDOUT: %.loc14: type = where_expr %.Self [template = constants.%I.type] { +// CHECK:STDOUT: requirement_equivalent %T.ref, %int.make_type_32 // CHECK:STDOUT: } // CHECK:STDOUT: %U.param: %I.type = param U, runtime_param0 // CHECK:STDOUT: %U: %I.type = bind_name U, %U.param @@ -60,6 +78,8 @@ fn NotGenericF(U: I where .T = {}) {} // CHECK:STDOUT: witness = (%T) // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: fn @Int32() -> type = "int.make_type_32"; +// CHECK:STDOUT: // CHECK:STDOUT: fn @NotGenericF(%U: %I.type) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: return diff --git a/toolchain/diagnostics/diagnostic_kind.def b/toolchain/diagnostics/diagnostic_kind.def index 22b39fee2bfc..a134c0054123 100644 --- a/toolchain/diagnostics/diagnostic_kind.def +++ b/toolchain/diagnostics/diagnostic_kind.def @@ -368,6 +368,10 @@ CARBON_DIAGNOSTIC_KIND(ClassInvalidMemberAccess) // Alias diagnostics. CARBON_DIAGNOSTIC_KIND(AliasRequiresNameRef) +// Where operator and its requirements. +CARBON_DIAGNOSTIC_KIND(ImplsOnNonFacetType) +CARBON_DIAGNOSTIC_KIND(WhereOnNonFacetType) + // ============================================================================ // Other diagnostics // ============================================================================