diff --git a/toolchain/check/deduce.cpp b/toolchain/check/deduce.cpp index 89a015a67769..896c603d6f75 100644 --- a/toolchain/check/deduce.cpp +++ b/toolchain/check/deduce.cpp @@ -10,6 +10,7 @@ #include "toolchain/check/convert.h" #include "toolchain/check/generic.h" #include "toolchain/check/subst.h" +#include "toolchain/diagnostics/diagnostic.h" #include "toolchain/sem_ir/ids.h" #include "toolchain/sem_ir/impl.h" #include "toolchain/sem_ir/typed_insts.h" @@ -225,6 +226,19 @@ class DeductionContext { auto MakeSpecific() -> SemIR::SpecificId; private: + void NoteInitializingParam(SemIR::InstId param_id, auto& builder) { + if (auto param = context().insts().TryGetAs( + param_id)) { + CARBON_DIAGNOSTIC(InitializingGenericParam, Note, + "initializing generic parameter `{0}` declared here", + SemIR::NameId); + builder.Note(param_id, InitializingGenericParam, + context().entity_names().Get(param->entity_name_id).name_id); + } else { + NoteGenericHere(context(), generic_id_, builder); + } + } + Context* context_; SemIR::LocId loc_id_; SemIR::GenericId generic_id_; @@ -277,7 +291,7 @@ DeductionContext::DeductionContext(Context& context, SemIR::LocId loc_id, // TODO: Subst is linear in the length of the substitutions list. Change // it so we can pass in an array mapping indexes to substitutions instead. - substitutions_.reserve(args.size()); + substitutions_.reserve(args.size() + result_arg_ids_.size()); for (auto [i, subst_inst_id] : llvm::enumerate(args)) { substitutions_.push_back( {.bind_id = SemIR::CompileTimeBindIndex(i), @@ -304,36 +318,23 @@ auto DeductionContext::Deduce() -> bool { while (!worklist_.Done()) { auto [param_id, arg_id, needs_substitution] = worklist_.PopNext(); - auto note_initializing_param = [&](auto& builder) { - if (auto param = - context().insts().TryGetAs( - param_id)) { - CARBON_DIAGNOSTIC(InitializingGenericParam, Note, - "initializing generic parameter `{0}` declared here", - SemIR::NameId); - builder.Note( - param_id, InitializingGenericParam, - context().entity_names().Get(param->entity_name_id).name_id); - } else { - NoteGenericHere(context(), generic_id_, builder); - } - }; - // TODO: Bail out if there's nothing to deduce: if we're not in a pattern // and the parameter doesn't have a symbolic constant value. - // If the parameter has a symbolic type, deduce against that. auto param_type_id = context().insts().Get(param_id).type_id(); + // If the parameter has a symbolic type, deduce against that. if (param_type_id.AsConstantId().is_symbolic()) { Add(context().types().GetInstId(param_type_id), context().types().GetInstId(context().insts().Get(arg_id).type_id()), needs_substitution); } else { - // The argument needs to have the same type as the parameter. - // TODO: Suppress diagnostics here if diagnose_ is false. - // TODO: Only do this when deducing against a symbolic pattern. - DiagnosticAnnotationScope annotate_diagnostics(&context().emitter(), - note_initializing_param); + // The argument (e.g. a TupleLiteral of types) may be convertible to a + // compile-time value (e.g. TupleType) that we can decompose further. + // So we do this conversion here, even though we will later try convert + // again when we have deduced all of the bindings. + DiagnosticAnnotationScope annotate_diagnostics( + &context().emitter(), + [&](auto& builder) { NoteInitializingParam(param_id, builder); }); arg_id = ConvertToValueOfType(context(), loc_id_, arg_id, param_type_id); if (arg_id == SemIR::ErrorInst::SingletonInstId) { return false; @@ -375,7 +376,7 @@ auto DeductionContext::Deduce() -> bool { "compile-time constant"); auto diag = context().emitter().Build(loc_id_, CompTimeArgumentNotConstant); - note_initializing_param(diag); + NoteInitializingParam(param_id, diag); diag.Emit(); } return false; @@ -483,15 +484,17 @@ auto DeductionContext::Deduce() -> bool { } auto DeductionContext::CheckDeductionIsComplete() -> bool { - // Check we deduced an argument value for every parameter. - for (auto [i, deduced_arg_id] : - llvm::enumerate(llvm::ArrayRef(result_arg_ids_) + // Check we deduced an argument value for every parameter, and convert each + // argument to match the final parameter type after substituting any deduced + // types it depends on. + for (auto&& [i, deduced_arg_id] : + llvm::enumerate(llvm::MutableArrayRef(result_arg_ids_) .drop_front(first_deduced_index_.index))) { + auto binding_index = first_deduced_index_.index + i; + auto binding_id = context().inst_blocks().Get( + context().generics().Get(generic_id_).bindings_id)[binding_index]; if (!deduced_arg_id.has_value()) { if (diagnose_) { - auto binding_index = first_deduced_index_.index + i; - auto binding_id = context().inst_blocks().Get( - context().generics().Get(generic_id_).bindings_id)[binding_index]; auto entity_name_id = context() .insts() .GetAs(binding_id) @@ -507,8 +510,61 @@ auto DeductionContext::CheckDeductionIsComplete() -> bool { } return false; } - } + // If the binding is symbolic it can refer to other earlier bindings in the + // same generic, or from an enclosing specific. Substitute to replace those + // and get a non-symbolic type in order for us to know the final type that + // the argument needs to be converted to. + // + // Note that when typechecking a checked generic, the arguments can + // still be symbolic, so the substitution would also be symbolic. We are + // unable to get the final type for symbolic bindings until deducing with + // non-symbolic arguments. + // + // TODO: If arguments of different values, but that _convert to_ the same + // value, are deduced for the same symbolic binding, then we will fail + // typechecking in Deduce() with conflicting types via the + // `DeductionInconsistent` diagnostic. If we defer that check until after + // all conversions are done (after the code below) then we won't diagnose + // that incorrectly. + auto arg_type_id = context().insts().Get(deduced_arg_id).type_id(); + auto binding_type_id = context().insts().Get(binding_id).type_id(); + if (!arg_type_id.AsConstantId().is_symbolic() && + binding_type_id.AsConstantId().is_symbolic()) { + auto param_type_const_id = SubstConstant( + context(), binding_type_id.AsConstantId(), substitutions_); + CARBON_CHECK(param_type_const_id.has_value()); + CARBON_CHECK(!param_type_const_id.is_symbolic()); + binding_type_id = context().GetTypeIdForTypeConstant(param_type_const_id); + + // TODO: Suppress diagnostics here if `diagnose_` is false. + DiagnosticAnnotationScope annotate_diagnostics( + &context().emitter(), + [&](auto& builder) { NoteInitializingParam(binding_id, builder); }); + auto converted_arg_id = ConvertToValueOfType( + context(), loc_id_, deduced_arg_id, binding_type_id); + // Replace the deduced arg with its value converted to the parameter + // type. The conversion of the argument type must produce a constant value + // to be used in deduction. + if (context().constant_values().Get(converted_arg_id).is_constant()) { + deduced_arg_id = converted_arg_id; + } else { + CARBON_DIAGNOSTIC(RuntimeConversionDuringCompTimeDeduction, Error, + "compile-time value requires runtime conversion, " + "constructing value of type {0}", + SemIR::TypeId); + auto diag = context().emitter().Build( + loc_id_, RuntimeConversionDuringCompTimeDeduction, binding_type_id); + NoteGenericHere(context(), generic_id_, diag); + diag.Emit(); + deduced_arg_id = SemIR::ErrorInst::SingletonInstId; + } + } + + substitutions_.push_back( + {.bind_id = SemIR::CompileTimeBindIndex(binding_index), + .replacement_id = context().constant_values().Get(deduced_arg_id)}); + } return true; } diff --git a/toolchain/check/testdata/builtin_conversions/no_prelude/convert_class_type_to_generic_facet_value.carbon b/toolchain/check/testdata/builtin_conversions/no_prelude/convert_class_type_to_generic_facet_value.carbon new file mode 100644 index 000000000000..3aa1d4a6050f --- /dev/null +++ b/toolchain/check/testdata/builtin_conversions/no_prelude/convert_class_type_to_generic_facet_value.carbon @@ -0,0 +1,349 @@ +// 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/builtin_conversions/no_prelude/convert_class_type_to_generic_facet_value.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/builtin_conversions/no_prelude/convert_class_type_to_generic_facet_value.carbon + +interface Generic(Scalar:! type) { + fn F(); +} + +class GenericParam {} + +class ImplsGeneric {} +impl ImplsGeneric as Generic(GenericParam) { + fn F() {} +} + +fn CallGenericMethod(T:! type, U:! Generic(T)) {} + +fn G() { + CallGenericMethod(GenericParam, ImplsGeneric); +} + +fn PassThroughToGenericMethod(T:! type, U:! Generic(T)) { + CallGenericMethod(T, U); +} + +fn H() { + PassThroughToGenericMethod(GenericParam, ImplsGeneric); +} + +// CHECK:STDOUT: --- convert_class_type_to_generic_facet_value.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Scalar: type = bind_symbolic_name Scalar, 0 [symbolic] +// CHECK:STDOUT: %Scalar.patt: type = symbolic_binding_pattern Scalar, 0 [symbolic] +// CHECK:STDOUT: %Generic.type.c21: type = generic_interface_type @Generic [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %Generic.generic: %Generic.type.c21 = struct_value () [template] +// CHECK:STDOUT: %Generic.type.91ccba.1: type = facet_type <@Generic, @Generic(%Scalar)> [symbolic] +// CHECK:STDOUT: %Self: %Generic.type.91ccba.1 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %F.type.f43: type = fn_type @F.1, @Generic(%Scalar) [symbolic] +// CHECK:STDOUT: %F.8a2: %F.type.f43 = struct_value () [symbolic] +// CHECK:STDOUT: %Generic.assoc_type.de9: type = assoc_entity_type %Generic.type.91ccba.1 [symbolic] +// CHECK:STDOUT: %assoc0.29c: %Generic.assoc_type.de9 = assoc_entity element0, @Generic.%F.decl [symbolic] +// CHECK:STDOUT: %GenericParam: type = class_type @GenericParam [template] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %ImplsGeneric: type = class_type @ImplsGeneric [template] +// CHECK:STDOUT: %Generic.type.769: type = facet_type <@Generic, @Generic(%GenericParam)> [template] +// CHECK:STDOUT: %F.type.4cf: type = fn_type @F.1, @Generic(%GenericParam) [template] +// CHECK:STDOUT: %F.118: %F.type.4cf = struct_value () [template] +// CHECK:STDOUT: %Generic.assoc_type.9f1: type = assoc_entity_type %Generic.type.769 [template] +// CHECK:STDOUT: %assoc0.9b7: %Generic.assoc_type.9f1 = assoc_entity element0, @Generic.%F.decl [template] +// CHECK:STDOUT: %impl_witness: = impl_witness (@impl.%F.decl) [template] +// CHECK:STDOUT: %F.type.17b: type = fn_type @F.2 [template] +// CHECK:STDOUT: %F.a56: %F.type.17b = struct_value () [template] +// CHECK:STDOUT: %Generic.facet: %Generic.type.769 = facet_value %ImplsGeneric, %impl_witness [template] +// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %Generic.type.91ccba.2: type = facet_type <@Generic, @Generic(%T)> [symbolic] +// CHECK:STDOUT: %U: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic] +// CHECK:STDOUT: %U.patt: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic] +// CHECK:STDOUT: %CallGenericMethod.type: type = fn_type @CallGenericMethod [template] +// CHECK:STDOUT: %CallGenericMethod: %CallGenericMethod.type = struct_value () [template] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %CallGenericMethod.specific_fn.d8c: = specific_function %CallGenericMethod, @CallGenericMethod(%GenericParam, %Generic.facet) [template] +// CHECK:STDOUT: %PassThroughToGenericMethod.type: type = fn_type @PassThroughToGenericMethod [template] +// CHECK:STDOUT: %PassThroughToGenericMethod: %PassThroughToGenericMethod.type = struct_value () [template] +// CHECK:STDOUT: %CallGenericMethod.specific_fn.a24: = specific_function %CallGenericMethod, @CallGenericMethod(%T, %U) [symbolic] +// CHECK:STDOUT: %H.type: type = fn_type @H [template] +// CHECK:STDOUT: %H: %H.type = struct_value () [template] +// CHECK:STDOUT: %PassThroughToGenericMethod.specific_fn: = specific_function %PassThroughToGenericMethod, @PassThroughToGenericMethod(%GenericParam, %Generic.facet) [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Generic = %Generic.decl +// CHECK:STDOUT: .GenericParam = %GenericParam.decl +// CHECK:STDOUT: .ImplsGeneric = %ImplsGeneric.decl +// CHECK:STDOUT: .CallGenericMethod = %CallGenericMethod.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: .PassThroughToGenericMethod = %PassThroughToGenericMethod.decl +// CHECK:STDOUT: .H = %H.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Generic.decl: %Generic.type.c21 = interface_decl @Generic [template = constants.%Generic.generic] { +// CHECK:STDOUT: %Scalar.patt.loc11_19.1: type = symbolic_binding_pattern Scalar, 0 [symbolic = %Scalar.patt.loc11_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: %Scalar.param_patt: type = value_param_pattern %Scalar.patt.loc11_19.1, runtime_param [symbolic = %Scalar.patt.loc11_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Scalar.param: type = value_param runtime_param +// CHECK:STDOUT: %Scalar.loc11_19.1: type = bind_symbolic_name Scalar, 0, %Scalar.param [symbolic = %Scalar.loc11_19.2 (constants.%Scalar)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %GenericParam.decl: type = class_decl @GenericParam [template = constants.%GenericParam] {} {} +// CHECK:STDOUT: %ImplsGeneric.decl: type = class_decl @ImplsGeneric [template = constants.%ImplsGeneric] {} {} +// CHECK:STDOUT: impl_decl @impl [template] {} { +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %GenericParam.ref: type = name_ref GenericParam, file.%GenericParam.decl [template = constants.%GenericParam] +// CHECK:STDOUT: %Generic.type: type = facet_type <@Generic, @Generic(constants.%GenericParam)> [template = constants.%Generic.type.769] +// CHECK:STDOUT: } +// CHECK:STDOUT: %impl_witness: = impl_witness (@impl.%F.decl) [template = constants.%impl_witness] +// CHECK:STDOUT: %CallGenericMethod.decl: %CallGenericMethod.type = fn_decl @CallGenericMethod [template = constants.%CallGenericMethod] { +// CHECK:STDOUT: %T.patt.loc22_22.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc22_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc22_22.1, runtime_param [symbolic = %T.patt.loc22_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %U.patt.loc22_32.1: @CallGenericMethod.%Generic.type.loc22_45.2 (%Generic.type.91ccba.2) = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc22_32.2 (constants.%U.patt)] +// CHECK:STDOUT: %U.param_patt: @CallGenericMethod.%Generic.type.loc22_45.2 (%Generic.type.91ccba.2) = value_param_pattern %U.patt.loc22_32.1, runtime_param [symbolic = %U.patt.loc22_32.2 (constants.%U.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc22_22.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc22_22.2 (constants.%T)] +// CHECK:STDOUT: %U.param: @CallGenericMethod.%Generic.type.loc22_45.2 (%Generic.type.91ccba.2) = value_param runtime_param +// CHECK:STDOUT: %.loc22: type = splice_block %Generic.type.loc22_45.1 [symbolic = %Generic.type.loc22_45.2 (constants.%Generic.type.91ccba.2)] { +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc22_22.1 [symbolic = %T.loc22_22.2 (constants.%T)] +// CHECK:STDOUT: %Generic.type.loc22_45.1: type = facet_type <@Generic, @Generic(constants.%T)> [symbolic = %Generic.type.loc22_45.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.loc22_32.1: @CallGenericMethod.%Generic.type.loc22_45.2 (%Generic.type.91ccba.2) = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc22_32.2 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {} {} +// CHECK:STDOUT: %PassThroughToGenericMethod.decl: %PassThroughToGenericMethod.type = fn_decl @PassThroughToGenericMethod [template = constants.%PassThroughToGenericMethod] { +// CHECK:STDOUT: %T.patt.loc28_31.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc28_31.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc28_31.1, runtime_param [symbolic = %T.patt.loc28_31.2 (constants.%T.patt)] +// CHECK:STDOUT: %U.patt.loc28_41.1: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2) = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc28_41.2 (constants.%U.patt)] +// CHECK:STDOUT: %U.param_patt: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2) = value_param_pattern %U.patt.loc28_41.1, runtime_param [symbolic = %U.patt.loc28_41.2 (constants.%U.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc28_31.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc28_31.2 (constants.%T)] +// CHECK:STDOUT: %U.param: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2) = value_param runtime_param +// CHECK:STDOUT: %.loc28: type = splice_block %Generic.type.loc28_54.1 [symbolic = %Generic.type.loc28_54.2 (constants.%Generic.type.91ccba.2)] { +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %T.ref.loc28: type = name_ref T, %T.loc28_31.1 [symbolic = %T.loc28_31.2 (constants.%T)] +// CHECK:STDOUT: %Generic.type.loc28_54.1: type = facet_type <@Generic, @Generic(constants.%T)> [symbolic = %Generic.type.loc28_54.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.loc28_41.1: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2) = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc28_41.2 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %H.decl: %H.type = fn_decl @H [template = constants.%H] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @Generic(%Scalar.loc11_19.1: type) { +// CHECK:STDOUT: %Scalar.loc11_19.2: type = bind_symbolic_name Scalar, 0 [symbolic = %Scalar.loc11_19.2 (constants.%Scalar)] +// CHECK:STDOUT: %Scalar.patt.loc11_19.2: type = symbolic_binding_pattern Scalar, 0 [symbolic = %Scalar.patt.loc11_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type: type = facet_type <@Generic, @Generic(%Scalar.loc11_19.2)> [symbolic = %Generic.type (constants.%Generic.type.91ccba.1)] +// CHECK:STDOUT: %Self.2: %Generic.type.91ccba.1 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %F.type: type = fn_type @F.1, @Generic(%Scalar.loc11_19.2) [symbolic = %F.type (constants.%F.type.f43)] +// CHECK:STDOUT: %F: @Generic.%F.type (%F.type.f43) = struct_value () [symbolic = %F (constants.%F.8a2)] +// CHECK:STDOUT: %Generic.assoc_type: type = assoc_entity_type @Generic.%Generic.type (%Generic.type.91ccba.1) [symbolic = %Generic.assoc_type (constants.%Generic.assoc_type.de9)] +// CHECK:STDOUT: %assoc0.loc12_9.2: @Generic.%Generic.assoc_type (%Generic.assoc_type.de9) = assoc_entity element0, %F.decl [symbolic = %assoc0.loc12_9.2 (constants.%assoc0.29c)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: %Self.1: @Generic.%Generic.type (%Generic.type.91ccba.1) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %F.decl: @Generic.%F.type (%F.type.f43) = fn_decl @F.1 [symbolic = @Generic.%F (constants.%F.8a2)] {} {} +// CHECK:STDOUT: %assoc0.loc12_9.1: @Generic.%Generic.assoc_type (%Generic.assoc_type.de9) = assoc_entity element0, %F.decl [symbolic = %assoc0.loc12_9.2 (constants.%assoc0.29c)] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self.1 +// CHECK:STDOUT: .F = %assoc0.loc12_9.1 +// CHECK:STDOUT: witness = (%F.decl) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: impl @impl: %ImplsGeneric.ref as %Generic.type { +// CHECK:STDOUT: %F.decl: %F.type.17b = fn_decl @F.2 [template = constants.%F.a56] {} {} +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: witness = file.%impl_witness +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @GenericParam { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%GenericParam +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @ImplsGeneric { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%ImplsGeneric +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F.1(@Generic.%Scalar.loc11_19.1: type, @Generic.%Self.1: @Generic.%Generic.type (%Generic.type.91ccba.1)) { +// CHECK:STDOUT: fn(); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F.2() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @CallGenericMethod(%T.loc22_22.1: type, %U.loc22_32.1: @CallGenericMethod.%Generic.type.loc22_45.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: %T.loc22_22.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc22_22.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc22_22.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc22_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %Generic.type.loc22_45.2: type = facet_type <@Generic, @Generic(%T.loc22_22.2)> [symbolic = %Generic.type.loc22_45.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: %U.loc22_32.2: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic = %U.loc22_32.2 (constants.%U)] +// CHECK:STDOUT: %U.patt.loc22_32.2: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc22_32.2 (constants.%U.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: @CallGenericMethod.%Generic.type.loc22_45.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %CallGenericMethod.ref: %CallGenericMethod.type = name_ref CallGenericMethod, file.%CallGenericMethod.decl [template = constants.%CallGenericMethod] +// CHECK:STDOUT: %GenericParam.ref: type = name_ref GenericParam, file.%GenericParam.decl [template = constants.%GenericParam] +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Generic.facet: %Generic.type.769 = facet_value constants.%ImplsGeneric, constants.%impl_witness [template = constants.%Generic.facet] +// CHECK:STDOUT: %.loc25: %Generic.type.769 = converted constants.%ImplsGeneric, %Generic.facet [template = constants.%Generic.facet] +// CHECK:STDOUT: %CallGenericMethod.specific_fn: = specific_function %CallGenericMethod.ref, @CallGenericMethod(constants.%GenericParam, %.loc25) [template = constants.%CallGenericMethod.specific_fn.d8c] +// CHECK:STDOUT: %CallGenericMethod.call: init %empty_tuple.type = call %CallGenericMethod.specific_fn() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @PassThroughToGenericMethod(%T.loc28_31.1: type, %U.loc28_41.1: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: %T.loc28_31.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc28_31.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc28_31.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc28_31.2 (constants.%T.patt)] +// CHECK:STDOUT: %Generic.type.loc28_54.2: type = facet_type <@Generic, @Generic(%T.loc28_31.2)> [symbolic = %Generic.type.loc28_54.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: %U.loc28_41.2: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic = %U.loc28_41.2 (constants.%U)] +// CHECK:STDOUT: %U.patt.loc28_41.2: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc28_41.2 (constants.%U.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %CallGenericMethod.specific_fn.loc29_3.2: = specific_function constants.%CallGenericMethod, @CallGenericMethod(%T.loc28_31.2, %U.loc28_41.2) [symbolic = %CallGenericMethod.specific_fn.loc29_3.2 (constants.%CallGenericMethod.specific_fn.a24)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %CallGenericMethod.ref: %CallGenericMethod.type = name_ref CallGenericMethod, file.%CallGenericMethod.decl [template = constants.%CallGenericMethod] +// CHECK:STDOUT: %T.ref.loc29: type = name_ref T, %T.loc28_31.1 [symbolic = %T.loc28_31.2 (constants.%T)] +// CHECK:STDOUT: %U.ref: @PassThroughToGenericMethod.%Generic.type.loc28_54.2 (%Generic.type.91ccba.2) = name_ref U, %U.loc28_41.1 [symbolic = %U.loc28_41.2 (constants.%U)] +// CHECK:STDOUT: %CallGenericMethod.specific_fn.loc29_3.1: = specific_function %CallGenericMethod.ref, @CallGenericMethod(constants.%T, constants.%U) [symbolic = %CallGenericMethod.specific_fn.loc29_3.2 (constants.%CallGenericMethod.specific_fn.a24)] +// CHECK:STDOUT: %CallGenericMethod.call: init %empty_tuple.type = call %CallGenericMethod.specific_fn.loc29_3.1() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @H() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %PassThroughToGenericMethod.ref: %PassThroughToGenericMethod.type = name_ref PassThroughToGenericMethod, file.%PassThroughToGenericMethod.decl [template = constants.%PassThroughToGenericMethod] +// CHECK:STDOUT: %GenericParam.ref: type = name_ref GenericParam, file.%GenericParam.decl [template = constants.%GenericParam] +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Generic.facet: %Generic.type.769 = facet_value constants.%ImplsGeneric, constants.%impl_witness [template = constants.%Generic.facet] +// CHECK:STDOUT: %.loc33: %Generic.type.769 = converted constants.%ImplsGeneric, %Generic.facet [template = constants.%Generic.facet] +// CHECK:STDOUT: %PassThroughToGenericMethod.specific_fn: = specific_function %PassThroughToGenericMethod.ref, @PassThroughToGenericMethod(constants.%GenericParam, %.loc33) [template = constants.%PassThroughToGenericMethod.specific_fn] +// CHECK:STDOUT: %PassThroughToGenericMethod.call: init %empty_tuple.type = call %PassThroughToGenericMethod.specific_fn() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%Scalar) { +// CHECK:STDOUT: %Scalar.loc11_19.2 => constants.%Scalar +// CHECK:STDOUT: %Scalar.patt.loc11_19.2 => constants.%Scalar +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%Scalar, constants.%Self) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(%Scalar.loc11_19.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%GenericParam) { +// CHECK:STDOUT: %Scalar.loc11_19.2 => constants.%GenericParam +// CHECK:STDOUT: %Scalar.patt.loc11_19.2 => constants.%GenericParam +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type => constants.%Generic.type.769 +// CHECK:STDOUT: %Self.2 => constants.%Self +// CHECK:STDOUT: %F.type => constants.%F.type.4cf +// CHECK:STDOUT: %F => constants.%F.118 +// CHECK:STDOUT: %Generic.assoc_type => constants.%Generic.assoc_type.9f1 +// CHECK:STDOUT: %assoc0.loc12_9.2 => constants.%assoc0.9b7 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%GenericParam, constants.%Generic.facet) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%T) { +// CHECK:STDOUT: %Scalar.loc11_19.2 => constants.%T +// CHECK:STDOUT: %Scalar.patt.loc11_19.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%T, constants.%U) { +// CHECK:STDOUT: %T.loc22_22.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc22_22.2 => constants.%T +// CHECK:STDOUT: %Generic.type.loc22_45.2 => constants.%Generic.type.91ccba.2 +// CHECK:STDOUT: %U.loc22_32.2 => constants.%U +// CHECK:STDOUT: %U.patt.loc22_32.2 => constants.%U +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(@CallGenericMethod.%T.loc22_22.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%GenericParam, @G.%.loc25) { +// CHECK:STDOUT: %T.loc22_22.2 => constants.%GenericParam +// CHECK:STDOUT: %T.patt.loc22_22.2 => constants.%GenericParam +// CHECK:STDOUT: %Generic.type.loc22_45.2 => constants.%Generic.type.769 +// CHECK:STDOUT: %U.loc22_32.2 => constants.%Generic.facet +// CHECK:STDOUT: %U.patt.loc22_32.2 => constants.%Generic.facet +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%GenericParam, constants.%Generic.facet) { +// CHECK:STDOUT: %T.loc22_22.2 => constants.%GenericParam +// CHECK:STDOUT: %T.patt.loc22_22.2 => constants.%GenericParam +// CHECK:STDOUT: %Generic.type.loc22_45.2 => constants.%Generic.type.769 +// CHECK:STDOUT: %U.loc22_32.2 => constants.%Generic.facet +// CHECK:STDOUT: %U.patt.loc22_32.2 => constants.%Generic.facet +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @PassThroughToGenericMethod(constants.%T, constants.%U) { +// CHECK:STDOUT: %T.loc28_31.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc28_31.2 => constants.%T +// CHECK:STDOUT: %Generic.type.loc28_54.2 => constants.%Generic.type.91ccba.2 +// CHECK:STDOUT: %U.loc28_41.2 => constants.%U +// CHECK:STDOUT: %U.patt.loc28_41.2 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(@PassThroughToGenericMethod.%T.loc28_31.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(@PassThroughToGenericMethod.%T.loc28_31.2, @PassThroughToGenericMethod.%U.loc28_41.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @PassThroughToGenericMethod(constants.%GenericParam, @H.%.loc33) { +// CHECK:STDOUT: %T.loc28_31.2 => constants.%GenericParam +// CHECK:STDOUT: %T.patt.loc28_31.2 => constants.%GenericParam +// CHECK:STDOUT: %Generic.type.loc28_54.2 => constants.%Generic.type.769 +// CHECK:STDOUT: %U.loc28_41.2 => constants.%Generic.facet +// CHECK:STDOUT: %U.patt.loc28_41.2 => constants.%Generic.facet +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %CallGenericMethod.specific_fn.loc29_3.2 => constants.%CallGenericMethod.specific_fn.d8c +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @PassThroughToGenericMethod(constants.%GenericParam, constants.%Generic.facet) { +// CHECK:STDOUT: %T.loc28_31.2 => constants.%GenericParam +// CHECK:STDOUT: %T.patt.loc28_31.2 => constants.%GenericParam +// CHECK:STDOUT: %Generic.type.loc28_54.2 => constants.%Generic.type.769 +// CHECK:STDOUT: %U.loc28_41.2 => constants.%Generic.facet +// CHECK:STDOUT: %U.patt.loc28_41.2 => constants.%Generic.facet +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtin_conversions/no_prelude/fail_convert_class_type_to_generic_facet_value.carbon b/toolchain/check/testdata/builtin_conversions/no_prelude/fail_convert_class_type_to_generic_facet_value.carbon new file mode 100644 index 000000000000..3840971794d5 --- /dev/null +++ b/toolchain/check/testdata/builtin_conversions/no_prelude/fail_convert_class_type_to_generic_facet_value.carbon @@ -0,0 +1,464 @@ +// 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/builtin_conversions/no_prelude/fail_convert_class_type_to_generic_facet_value.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/builtin_conversions/no_prelude/fail_convert_class_type_to_generic_facet_value.carbon + +// --- core.carbon + +package Core; + +interface ImplicitAs(Dest:! type) { + fn Convert[self: Self]() -> Dest; +} + +// --- fail_convert_class_type_to_generic_facet_value.carbon + +import Core; + +interface Generic(Scalar:! type) { + fn F(); +} + +class GenericParam {} +class WrongGenericParam {} + +class ImplsGeneric {} +impl ImplsGeneric as Generic(GenericParam) { + fn F() {} +} + +fn CallGenericMethod(T:! type, U:! Generic(T)) {} + +fn G() { + // CHECK:STDERR: fail_convert_class_type_to_generic_facet_value.carbon:[[@LINE+10]]:3: error: cannot implicitly convert from `type` to `Generic(WrongGenericParam)` [ImplicitAsConversionFailure] + // CHECK:STDERR: CallGenericMethod(WrongGenericParam, ImplsGeneric); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_convert_class_type_to_generic_facet_value.carbon:[[@LINE+7]]:3: note: type `type` does not implement interface `Core.ImplicitAs(Generic(WrongGenericParam))` [MissingImplInMemberAccessNote] + // CHECK:STDERR: CallGenericMethod(WrongGenericParam, ImplsGeneric); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_convert_class_type_to_generic_facet_value.carbon:[[@LINE-9]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] + // CHECK:STDERR: fn CallGenericMethod(T:! type, U:! Generic(T)) {} + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + CallGenericMethod(WrongGenericParam, ImplsGeneric); +} + +// CHECK:STDOUT: --- core.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic] +// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.96f: type = generic_interface_type @ImplicitAs [template] +// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.96f = struct_value () [template] +// CHECK:STDOUT: %ImplicitAs.type.07f: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic] +// CHECK:STDOUT: %Self: %ImplicitAs.type.07f = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Self.as_type: type = facet_access_type %Self [symbolic] +// CHECK:STDOUT: %Convert.type: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic] +// CHECK:STDOUT: %Convert: %Convert.type = struct_value () [symbolic] +// CHECK:STDOUT: %ImplicitAs.assoc_type: type = assoc_entity_type %ImplicitAs.type.07f [symbolic] +// CHECK:STDOUT: %assoc0: %ImplicitAs.assoc_type = assoc_entity element0, @ImplicitAs.%Convert.decl [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .ImplicitAs = %ImplicitAs.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %ImplicitAs.decl: %ImplicitAs.type.96f = interface_decl @ImplicitAs [template = constants.%ImplicitAs.generic] { +// CHECK:STDOUT: %Dest.patt.loc4_22.1: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt.loc4_22.2 (constants.%Dest.patt)] +// CHECK:STDOUT: %Dest.param_patt: type = value_param_pattern %Dest.patt.loc4_22.1, runtime_param [symbolic = %Dest.patt.loc4_22.2 (constants.%Dest.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Dest.param: type = value_param runtime_param +// CHECK:STDOUT: %Dest.loc4_22.1: type = bind_symbolic_name Dest, 0, %Dest.param [symbolic = %Dest.loc4_22.2 (constants.%Dest)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(%Dest.loc4_22.1: type) { +// CHECK:STDOUT: %Dest.loc4_22.2: type = bind_symbolic_name Dest, 0 [symbolic = %Dest.loc4_22.2 (constants.%Dest)] +// CHECK:STDOUT: %Dest.patt.loc4_22.2: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt.loc4_22.2 (constants.%Dest.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest.loc4_22.2)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.07f)] +// CHECK:STDOUT: %Self.2: %ImplicitAs.type.07f = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %Convert.type: type = fn_type @Convert, @ImplicitAs(%Dest.loc4_22.2) [symbolic = %Convert.type (constants.%Convert.type)] +// CHECK:STDOUT: %Convert: @ImplicitAs.%Convert.type (%Convert.type) = struct_value () [symbolic = %Convert (constants.%Convert)] +// CHECK:STDOUT: %ImplicitAs.assoc_type: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.07f) [symbolic = %ImplicitAs.assoc_type (constants.%ImplicitAs.assoc_type)] +// CHECK:STDOUT: %assoc0.loc5_35.2: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type) = assoc_entity element0, %Convert.decl [symbolic = %assoc0.loc5_35.2 (constants.%assoc0)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: %Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.07f) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %Convert.decl: @ImplicitAs.%Convert.type (%Convert.type) = fn_decl @Convert [symbolic = @ImplicitAs.%Convert (constants.%Convert)] { +// CHECK:STDOUT: %self.patt: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = binding_pattern self +// CHECK:STDOUT: %self.param_patt: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = value_param_pattern %self.patt, runtime_param0 +// CHECK:STDOUT: %return.patt: @Convert.%Dest (%Dest) = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: @Convert.%Dest (%Dest) = out_param_pattern %return.patt, runtime_param1 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, @ImplicitAs.%Dest.loc4_22.1 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %self.param: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = value_param runtime_param0 +// CHECK:STDOUT: %.loc5_20.1: type = splice_block %.loc5_20.3 [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] { +// CHECK:STDOUT: %.loc5_20.2: @Convert.%ImplicitAs.type (%ImplicitAs.type.07f) = specific_constant @ImplicitAs.%Self.1, @ImplicitAs(constants.%Dest) [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.ref: @Convert.%ImplicitAs.type (%ImplicitAs.type.07f) = name_ref Self, %.loc5_20.2 [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.as_type.loc5_20.2: type = facet_access_type %Self.ref [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] +// CHECK:STDOUT: %.loc5_20.3: type = converted %Self.ref, %Self.as_type.loc5_20.2 [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %self: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = bind_name self, %self.param +// CHECK:STDOUT: %return.param: ref @Convert.%Dest (%Dest) = out_param runtime_param1 +// CHECK:STDOUT: %return: ref @Convert.%Dest (%Dest) = return_slot %return.param +// CHECK:STDOUT: } +// CHECK:STDOUT: %assoc0.loc5_35.1: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type) = assoc_entity element0, %Convert.decl [symbolic = %assoc0.loc5_35.2 (constants.%assoc0)] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self.1 +// CHECK:STDOUT: .Convert = %assoc0.loc5_35.1 +// CHECK:STDOUT: witness = (%Convert.decl) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(@ImplicitAs.%Dest.loc4_22.1: type, @ImplicitAs.%Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.07f)) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.07f)] +// CHECK:STDOUT: %Self: %ImplicitAs.type.07f = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.as_type.loc5_20.1: type = facet_access_type %Self [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self.param_patt: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest.loc4_22.2 => constants.%Dest +// CHECK:STDOUT: %Dest.patt.loc4_22.2 => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.07f +// CHECK:STDOUT: %Self => constants.%Self +// CHECK:STDOUT: %Self.as_type.loc5_20.1 => constants.%Self.as_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(%Dest.loc4_22.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_convert_class_type_to_generic_facet_value.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Scalar: type = bind_symbolic_name Scalar, 0 [symbolic] +// CHECK:STDOUT: %Scalar.patt: type = symbolic_binding_pattern Scalar, 0 [symbolic] +// CHECK:STDOUT: %Generic.type.c21: type = generic_interface_type @Generic [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %Generic.generic: %Generic.type.c21 = struct_value () [template] +// CHECK:STDOUT: %Generic.type.91ccba.1: type = facet_type <@Generic, @Generic(%Scalar)> [symbolic] +// CHECK:STDOUT: %Self.dee: %Generic.type.91ccba.1 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %F.type.f43: type = fn_type @F.1, @Generic(%Scalar) [symbolic] +// CHECK:STDOUT: %F.8a2: %F.type.f43 = struct_value () [symbolic] +// CHECK:STDOUT: %Generic.assoc_type.de9: type = assoc_entity_type %Generic.type.91ccba.1 [symbolic] +// CHECK:STDOUT: %assoc0.29c: %Generic.assoc_type.de9 = assoc_entity element0, @Generic.%F.decl [symbolic] +// CHECK:STDOUT: %GenericParam: type = class_type @GenericParam [template] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %WrongGenericParam: type = class_type @WrongGenericParam [template] +// CHECK:STDOUT: %ImplsGeneric: type = class_type @ImplsGeneric [template] +// CHECK:STDOUT: %Generic.type.769: type = facet_type <@Generic, @Generic(%GenericParam)> [template] +// CHECK:STDOUT: %F.type.4cf: type = fn_type @F.1, @Generic(%GenericParam) [template] +// CHECK:STDOUT: %F.118: %F.type.4cf = struct_value () [template] +// CHECK:STDOUT: %Generic.assoc_type.9f1: type = assoc_entity_type %Generic.type.769 [template] +// CHECK:STDOUT: %assoc0.9b7: %Generic.assoc_type.9f1 = assoc_entity element0, @Generic.%F.decl [template] +// CHECK:STDOUT: %impl_witness: = impl_witness (@impl.%F.decl) [template] +// CHECK:STDOUT: %F.type.17b: type = fn_type @F.2 [template] +// CHECK:STDOUT: %F.a56: %F.type.17b = struct_value () [template] +// CHECK:STDOUT: %Generic.facet: %Generic.type.769 = facet_value %ImplsGeneric, %impl_witness [template] +// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %Generic.type.91ccba.2: type = facet_type <@Generic, @Generic(%T)> [symbolic] +// CHECK:STDOUT: %U: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic] +// CHECK:STDOUT: %U.patt: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic] +// CHECK:STDOUT: %CallGenericMethod.type: type = fn_type @CallGenericMethod [template] +// CHECK:STDOUT: %CallGenericMethod: %CallGenericMethod.type = struct_value () [template] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %Generic.type.c3b: type = facet_type <@Generic, @Generic(%WrongGenericParam)> [template] +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.d62: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic] +// CHECK:STDOUT: %Self.519: %ImplicitAs.type.d62 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic] +// CHECK:STDOUT: %Convert.type.275: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic] +// CHECK:STDOUT: %Convert.42e: %Convert.type.275 = struct_value () [symbolic] +// CHECK:STDOUT: %Self.as_type: type = facet_access_type %Self.519 [symbolic] +// CHECK:STDOUT: %ImplicitAs.assoc_type.837: type = assoc_entity_type %ImplicitAs.type.d62 [symbolic] +// CHECK:STDOUT: %assoc0.43db8b.1: %ImplicitAs.assoc_type.837 = assoc_entity element0, imports.%Core.import_ref.207961.1 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.7f5: type = facet_type <@ImplicitAs, @ImplicitAs(%Generic.type.c3b)> [template] +// CHECK:STDOUT: %Convert.type.a2c: type = fn_type @Convert, @ImplicitAs(%Generic.type.c3b) [template] +// CHECK:STDOUT: %Convert.3cc: %Convert.type.a2c = struct_value () [template] +// CHECK:STDOUT: %ImplicitAs.assoc_type.237: type = assoc_entity_type %ImplicitAs.type.7f5 [template] +// CHECK:STDOUT: %assoc0.c5b: %ImplicitAs.assoc_type.237 = assoc_entity element0, imports.%Core.import_ref.207961.1 [template] +// CHECK:STDOUT: %assoc0.43db8b.2: %ImplicitAs.assoc_type.837 = assoc_entity element0, imports.%Core.import_ref.207961.2 [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs +// CHECK:STDOUT: import Core//default +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import_ref.ffd566.1: type = import_ref Core//default, loc4_22, loaded [symbolic = @ImplicitAs.%Dest (constants.%Dest)] +// CHECK:STDOUT: %Core.import_ref.ff5 = import_ref Core//default, inst26 [no loc], unloaded +// CHECK:STDOUT: %Core.import_ref.630: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type.837) = import_ref Core//default, loc5_35, loaded [symbolic = @ImplicitAs.%assoc0 (constants.%assoc0.43db8b.2)] +// CHECK:STDOUT: %Core.Convert = import_ref Core//default, Convert, unloaded +// CHECK:STDOUT: %Core.import_ref.ffd566.2: type = import_ref Core//default, loc4_22, loaded [symbolic = @ImplicitAs.%Dest (constants.%Dest)] +// CHECK:STDOUT: %Core.import_ref.ce1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.d62) = import_ref Core//default, inst26 [no loc], loaded [symbolic = @ImplicitAs.%Self (constants.%Self.519)] +// CHECK:STDOUT: %Core.import_ref.207961.1 = import_ref Core//default, loc5_35, unloaded +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .Generic = %Generic.decl +// CHECK:STDOUT: .GenericParam = %GenericParam.decl +// CHECK:STDOUT: .WrongGenericParam = %WrongGenericParam.decl +// CHECK:STDOUT: .ImplsGeneric = %ImplsGeneric.decl +// CHECK:STDOUT: .CallGenericMethod = %CallGenericMethod.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %Generic.decl: %Generic.type.c21 = interface_decl @Generic [template = constants.%Generic.generic] { +// CHECK:STDOUT: %Scalar.patt.loc4_19.1: type = symbolic_binding_pattern Scalar, 0 [symbolic = %Scalar.patt.loc4_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: %Scalar.param_patt: type = value_param_pattern %Scalar.patt.loc4_19.1, runtime_param [symbolic = %Scalar.patt.loc4_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Scalar.param: type = value_param runtime_param +// CHECK:STDOUT: %Scalar.loc4_19.1: type = bind_symbolic_name Scalar, 0, %Scalar.param [symbolic = %Scalar.loc4_19.2 (constants.%Scalar)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %GenericParam.decl: type = class_decl @GenericParam [template = constants.%GenericParam] {} {} +// CHECK:STDOUT: %WrongGenericParam.decl: type = class_decl @WrongGenericParam [template = constants.%WrongGenericParam] {} {} +// CHECK:STDOUT: %ImplsGeneric.decl: type = class_decl @ImplsGeneric [template = constants.%ImplsGeneric] {} {} +// CHECK:STDOUT: impl_decl @impl [template] {} { +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %GenericParam.ref: type = name_ref GenericParam, file.%GenericParam.decl [template = constants.%GenericParam] +// CHECK:STDOUT: %Generic.type: type = facet_type <@Generic, @Generic(constants.%GenericParam)> [template = constants.%Generic.type.769] +// CHECK:STDOUT: } +// CHECK:STDOUT: %impl_witness: = impl_witness (@impl.%F.decl) [template = constants.%impl_witness] +// CHECK:STDOUT: %CallGenericMethod.decl: %CallGenericMethod.type = fn_decl @CallGenericMethod [template = constants.%CallGenericMethod] { +// CHECK:STDOUT: %T.patt.loc16_22.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc16_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc16_22.1, runtime_param [symbolic = %T.patt.loc16_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %U.patt.loc16_32.1: @CallGenericMethod.%Generic.type.loc16_45.2 (%Generic.type.91ccba.2) = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc16_32.2 (constants.%U.patt)] +// CHECK:STDOUT: %U.param_patt: @CallGenericMethod.%Generic.type.loc16_45.2 (%Generic.type.91ccba.2) = value_param_pattern %U.patt.loc16_32.1, runtime_param [symbolic = %U.patt.loc16_32.2 (constants.%U.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc16_22.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc16_22.2 (constants.%T)] +// CHECK:STDOUT: %U.param: @CallGenericMethod.%Generic.type.loc16_45.2 (%Generic.type.91ccba.2) = value_param runtime_param +// CHECK:STDOUT: %.loc16: type = splice_block %Generic.type.loc16_45.1 [symbolic = %Generic.type.loc16_45.2 (constants.%Generic.type.91ccba.2)] { +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc16_22.1 [symbolic = %T.loc16_22.2 (constants.%T)] +// CHECK:STDOUT: %Generic.type.loc16_45.1: type = facet_type <@Generic, @Generic(constants.%T)> [symbolic = %Generic.type.loc16_45.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.loc16_32.1: @CallGenericMethod.%Generic.type.loc16_45.2 (%Generic.type.91ccba.2) = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc16_32.2 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @Generic(%Scalar.loc4_19.1: type) { +// CHECK:STDOUT: %Scalar.loc4_19.2: type = bind_symbolic_name Scalar, 0 [symbolic = %Scalar.loc4_19.2 (constants.%Scalar)] +// CHECK:STDOUT: %Scalar.patt.loc4_19.2: type = symbolic_binding_pattern Scalar, 0 [symbolic = %Scalar.patt.loc4_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type: type = facet_type <@Generic, @Generic(%Scalar.loc4_19.2)> [symbolic = %Generic.type (constants.%Generic.type.91ccba.1)] +// CHECK:STDOUT: %Self.2: %Generic.type.91ccba.1 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.dee)] +// CHECK:STDOUT: %F.type: type = fn_type @F.1, @Generic(%Scalar.loc4_19.2) [symbolic = %F.type (constants.%F.type.f43)] +// CHECK:STDOUT: %F: @Generic.%F.type (%F.type.f43) = struct_value () [symbolic = %F (constants.%F.8a2)] +// CHECK:STDOUT: %Generic.assoc_type: type = assoc_entity_type @Generic.%Generic.type (%Generic.type.91ccba.1) [symbolic = %Generic.assoc_type (constants.%Generic.assoc_type.de9)] +// CHECK:STDOUT: %assoc0.loc5_9.2: @Generic.%Generic.assoc_type (%Generic.assoc_type.de9) = assoc_entity element0, %F.decl [symbolic = %assoc0.loc5_9.2 (constants.%assoc0.29c)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: %Self.1: @Generic.%Generic.type (%Generic.type.91ccba.1) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.dee)] +// CHECK:STDOUT: %F.decl: @Generic.%F.type (%F.type.f43) = fn_decl @F.1 [symbolic = @Generic.%F (constants.%F.8a2)] {} {} +// CHECK:STDOUT: %assoc0.loc5_9.1: @Generic.%Generic.assoc_type (%Generic.assoc_type.de9) = assoc_entity element0, %F.decl [symbolic = %assoc0.loc5_9.2 (constants.%assoc0.29c)] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self.1 +// CHECK:STDOUT: .F = %assoc0.loc5_9.1 +// CHECK:STDOUT: witness = (%F.decl) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(imports.%Core.import_ref.ffd566.1: type) [from "core.carbon"] { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt (constants.%Dest.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.d62)] +// CHECK:STDOUT: %Self: %ImplicitAs.type.d62 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.519)] +// CHECK:STDOUT: %Convert.type: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic = %Convert.type (constants.%Convert.type.275)] +// CHECK:STDOUT: %Convert: @ImplicitAs.%Convert.type (%Convert.type.275) = struct_value () [symbolic = %Convert (constants.%Convert.42e)] +// CHECK:STDOUT: %ImplicitAs.assoc_type: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.d62) [symbolic = %ImplicitAs.assoc_type (constants.%ImplicitAs.assoc_type.837)] +// CHECK:STDOUT: %assoc0: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type.837) = assoc_entity element0, imports.%Core.import_ref.207961.1 [symbolic = %assoc0 (constants.%assoc0.43db8b.1)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%Core.import_ref.ff5 +// CHECK:STDOUT: .Convert = imports.%Core.import_ref.630 +// CHECK:STDOUT: witness = (imports.%Core.Convert) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: impl @impl: %ImplsGeneric.ref as %Generic.type { +// CHECK:STDOUT: %F.decl: %F.type.17b = fn_decl @F.2 [template = constants.%F.a56] {} {} +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: witness = file.%impl_witness +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @GenericParam { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%GenericParam +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @WrongGenericParam { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%WrongGenericParam +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @ImplsGeneric { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%ImplsGeneric +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F.1(@Generic.%Scalar.loc4_19.1: type, @Generic.%Self.1: @Generic.%Generic.type (%Generic.type.91ccba.1)) { +// CHECK:STDOUT: fn(); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F.2() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @CallGenericMethod(%T.loc16_22.1: type, %U.loc16_32.1: @CallGenericMethod.%Generic.type.loc16_45.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: %T.loc16_22.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc16_22.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc16_22.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc16_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %Generic.type.loc16_45.2: type = facet_type <@Generic, @Generic(%T.loc16_22.2)> [symbolic = %Generic.type.loc16_45.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: %U.loc16_32.2: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic = %U.loc16_32.2 (constants.%U)] +// CHECK:STDOUT: %U.patt.loc16_32.2: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc16_32.2 (constants.%U.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: @CallGenericMethod.%Generic.type.loc16_45.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %CallGenericMethod.ref: %CallGenericMethod.type = name_ref CallGenericMethod, file.%CallGenericMethod.decl [template = constants.%CallGenericMethod] +// CHECK:STDOUT: %WrongGenericParam.ref: type = name_ref WrongGenericParam, file.%WrongGenericParam.decl [template = constants.%WrongGenericParam] +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %.loc29: %Generic.type.c3b = converted constants.%ImplsGeneric, [template = ] +// CHECK:STDOUT: %CallGenericMethod.specific_fn: = specific_function %CallGenericMethod.ref, @CallGenericMethod(constants.%WrongGenericParam, ) [template = ] +// CHECK:STDOUT: %CallGenericMethod.call: init %empty_tuple.type = call %CallGenericMethod.specific_fn() [template = ] +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(imports.%Core.import_ref.ffd566.2: type, imports.%Core.import_ref.ce1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.d62)) [from "core.carbon"] { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.d62)] +// CHECK:STDOUT: %Self: %ImplicitAs.type.d62 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self.519)] +// CHECK:STDOUT: %Self.as_type: type = facet_access_type %Self [symbolic = %Self.as_type (constants.%Self.as_type)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self.param_patt: @Convert.%Self.as_type (%Self.as_type)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%Scalar) { +// CHECK:STDOUT: %Scalar.loc4_19.2 => constants.%Scalar +// CHECK:STDOUT: %Scalar.patt.loc4_19.2 => constants.%Scalar +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%Scalar, constants.%Self.dee) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(%Scalar.loc4_19.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%GenericParam) { +// CHECK:STDOUT: %Scalar.loc4_19.2 => constants.%GenericParam +// CHECK:STDOUT: %Scalar.patt.loc4_19.2 => constants.%GenericParam +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type => constants.%Generic.type.769 +// CHECK:STDOUT: %Self.2 => constants.%Self.dee +// CHECK:STDOUT: %F.type => constants.%F.type.4cf +// CHECK:STDOUT: %F => constants.%F.118 +// CHECK:STDOUT: %Generic.assoc_type => constants.%Generic.assoc_type.9f1 +// CHECK:STDOUT: %assoc0.loc5_9.2 => constants.%assoc0.9b7 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%GenericParam, constants.%Generic.facet) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%T) { +// CHECK:STDOUT: %Scalar.loc4_19.2 => constants.%T +// CHECK:STDOUT: %Scalar.patt.loc4_19.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%T, constants.%U) { +// CHECK:STDOUT: %T.loc16_22.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc16_22.2 => constants.%T +// CHECK:STDOUT: %Generic.type.loc16_45.2 => constants.%Generic.type.91ccba.2 +// CHECK:STDOUT: %U.loc16_32.2 => constants.%U +// CHECK:STDOUT: %U.patt.loc16_32.2 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(@CallGenericMethod.%T.loc16_22.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%WrongGenericParam) { +// CHECK:STDOUT: %Scalar.loc4_19.2 => constants.%WrongGenericParam +// CHECK:STDOUT: %Scalar.patt.loc4_19.2 => constants.%WrongGenericParam +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %Dest.patt => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(%Dest) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self.519) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.d62 +// CHECK:STDOUT: %Self => constants.%Self.519 +// CHECK:STDOUT: %Self.as_type => constants.%Self.as_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Generic.type.c3b) { +// CHECK:STDOUT: %Dest => constants.%Generic.type.c3b +// CHECK:STDOUT: %Dest.patt => constants.%Generic.type.c3b +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.7f5 +// CHECK:STDOUT: %Self => constants.%Self.519 +// CHECK:STDOUT: %Convert.type => constants.%Convert.type.a2c +// CHECK:STDOUT: %Convert => constants.%Convert.3cc +// CHECK:STDOUT: %ImplicitAs.assoc_type => constants.%ImplicitAs.assoc_type.237 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.c5b +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%WrongGenericParam, ) { +// CHECK:STDOUT: %T.loc16_22.2 => constants.%WrongGenericParam +// CHECK:STDOUT: %T.patt.loc16_22.2 => constants.%WrongGenericParam +// CHECK:STDOUT: %Generic.type.loc16_45.2 => constants.%Generic.type.c3b +// CHECK:STDOUT: %U.loc16_32.2 => +// CHECK:STDOUT: %U.patt.loc16_32.2 => +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/builtin_conversions/no_prelude/fail_deduction_uses_runtime_type_conversion.carbon b/toolchain/check/testdata/builtin_conversions/no_prelude/fail_deduction_uses_runtime_type_conversion.carbon new file mode 100644 index 000000000000..c430603b35bd --- /dev/null +++ b/toolchain/check/testdata/builtin_conversions/no_prelude/fail_deduction_uses_runtime_type_conversion.carbon @@ -0,0 +1,498 @@ +// 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/builtin_conversions/no_prelude/fail_deduction_uses_runtime_type_conversion.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/builtin_conversions/no_prelude/fail_deduction_uses_runtime_type_conversion.carbon + +// --- core.carbon + +package Core; + +interface ImplicitAs(Dest:! type) { + fn Convert[self: Self]() -> Dest; +} + +// --- fail_deduction_uses_runtime_type_conversion.carbon + +import Core; + +// Uses a tuple to allow using the inner type as a type that isn't directly +// deducible, without deducing through HoldsType. +class HoldsType(T:! (type, )) {} + +class RuntimeConvertFrom {} +class RuntimeConvertTo {} + +impl RuntimeConvertFrom as Core.ImplicitAs(RuntimeConvertTo) { + // Runtime conversion function + fn Convert[self: Self]() -> RuntimeConvertTo { return {}; } +} + +fn F[T:! (type, )](A:! T.0, x: HoldsType(T)) {} + +fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { + let from:! RuntimeConvertFrom = {} as RuntimeConvertFrom; + // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE+10]]:3: error: compile-time value requires runtime conversion, constructing value of type `RuntimeConvertTo` [RuntimeConversionDuringCompTimeDeduction] + // CHECK:STDERR: F(from, holds_to); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE-7]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] + // CHECK:STDERR: fn F[T:! (type, )](A:! T.0, x: HoldsType(T)) {} + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE-10]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] + // CHECK:STDERR: fn F[T:! (type, )](A:! T.0, x: HoldsType(T)) {} + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: + F(from, holds_to); +} + +// CHECK:STDOUT: --- core.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic] +// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.96f: type = generic_interface_type @ImplicitAs [template] +// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.96f = struct_value () [template] +// CHECK:STDOUT: %ImplicitAs.type.07f: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic] +// CHECK:STDOUT: %Self: %ImplicitAs.type.07f = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Self.as_type: type = facet_access_type %Self [symbolic] +// CHECK:STDOUT: %Convert.type: type = fn_type @Convert, @ImplicitAs(%Dest) [symbolic] +// CHECK:STDOUT: %Convert: %Convert.type = struct_value () [symbolic] +// CHECK:STDOUT: %ImplicitAs.assoc_type: type = assoc_entity_type %ImplicitAs.type.07f [symbolic] +// CHECK:STDOUT: %assoc0: %ImplicitAs.assoc_type = assoc_entity element0, @ImplicitAs.%Convert.decl [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .ImplicitAs = %ImplicitAs.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %ImplicitAs.decl: %ImplicitAs.type.96f = interface_decl @ImplicitAs [template = constants.%ImplicitAs.generic] { +// CHECK:STDOUT: %Dest.patt.loc4_22.1: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt.loc4_22.2 (constants.%Dest.patt)] +// CHECK:STDOUT: %Dest.param_patt: type = value_param_pattern %Dest.patt.loc4_22.1, runtime_param [symbolic = %Dest.patt.loc4_22.2 (constants.%Dest.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Dest.param: type = value_param runtime_param +// CHECK:STDOUT: %Dest.loc4_22.1: type = bind_symbolic_name Dest, 0, %Dest.param [symbolic = %Dest.loc4_22.2 (constants.%Dest)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(%Dest.loc4_22.1: type) { +// CHECK:STDOUT: %Dest.loc4_22.2: type = bind_symbolic_name Dest, 0 [symbolic = %Dest.loc4_22.2 (constants.%Dest)] +// CHECK:STDOUT: %Dest.patt.loc4_22.2: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt.loc4_22.2 (constants.%Dest.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest.loc4_22.2)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.07f)] +// CHECK:STDOUT: %Self.2: %ImplicitAs.type.07f = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %Convert.type: type = fn_type @Convert, @ImplicitAs(%Dest.loc4_22.2) [symbolic = %Convert.type (constants.%Convert.type)] +// CHECK:STDOUT: %Convert: @ImplicitAs.%Convert.type (%Convert.type) = struct_value () [symbolic = %Convert (constants.%Convert)] +// CHECK:STDOUT: %ImplicitAs.assoc_type: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.07f) [symbolic = %ImplicitAs.assoc_type (constants.%ImplicitAs.assoc_type)] +// CHECK:STDOUT: %assoc0.loc5_35.2: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type) = assoc_entity element0, %Convert.decl [symbolic = %assoc0.loc5_35.2 (constants.%assoc0)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: %Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.07f) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %Convert.decl: @ImplicitAs.%Convert.type (%Convert.type) = fn_decl @Convert [symbolic = @ImplicitAs.%Convert (constants.%Convert)] { +// CHECK:STDOUT: %self.patt: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = binding_pattern self +// CHECK:STDOUT: %self.param_patt: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = value_param_pattern %self.patt, runtime_param0 +// CHECK:STDOUT: %return.patt: @Convert.%Dest (%Dest) = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: @Convert.%Dest (%Dest) = out_param_pattern %return.patt, runtime_param1 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, @ImplicitAs.%Dest.loc4_22.1 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %self.param: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = value_param runtime_param0 +// CHECK:STDOUT: %.loc5_20.1: type = splice_block %.loc5_20.3 [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] { +// CHECK:STDOUT: %.loc5_20.2: @Convert.%ImplicitAs.type (%ImplicitAs.type.07f) = specific_constant @ImplicitAs.%Self.1, @ImplicitAs(constants.%Dest) [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.ref: @Convert.%ImplicitAs.type (%ImplicitAs.type.07f) = name_ref Self, %.loc5_20.2 [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.as_type.loc5_20.2: type = facet_access_type %Self.ref [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] +// CHECK:STDOUT: %.loc5_20.3: type = converted %Self.ref, %Self.as_type.loc5_20.2 [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %self: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type) = bind_name self, %self.param +// CHECK:STDOUT: %return.param: ref @Convert.%Dest (%Dest) = out_param runtime_param1 +// CHECK:STDOUT: %return: ref @Convert.%Dest (%Dest) = return_slot %return.param +// CHECK:STDOUT: } +// CHECK:STDOUT: %assoc0.loc5_35.1: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type) = assoc_entity element0, %Convert.decl [symbolic = %assoc0.loc5_35.2 (constants.%assoc0)] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self.1 +// CHECK:STDOUT: .Convert = %assoc0.loc5_35.1 +// CHECK:STDOUT: witness = (%Convert.decl) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert(@ImplicitAs.%Dest.loc4_22.1: type, @ImplicitAs.%Self.1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.07f)) { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.07f)] +// CHECK:STDOUT: %Self: %ImplicitAs.type.07f = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.as_type.loc5_20.1: type = facet_access_type %Self [symbolic = %Self.as_type.loc5_20.1 (constants.%Self.as_type)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self.param_patt: @Convert.%Self.as_type.loc5_20.1 (%Self.as_type)]() -> @Convert.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest.loc4_22.2 => constants.%Dest +// CHECK:STDOUT: %Dest.patt.loc4_22.2 => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert(constants.%Dest, constants.%Self) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.07f +// CHECK:STDOUT: %Self => constants.%Self +// CHECK:STDOUT: %Self.as_type.loc5_20.1 => constants.%Self.as_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.%Dest) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(%Dest.loc4_22.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_deduction_uses_runtime_type_conversion.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %tuple.type: type = tuple_type (type) [template] +// CHECK:STDOUT: %T: %tuple.type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: %tuple.type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %HoldsType.type: type = generic_class_type @HoldsType [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %HoldsType.generic: %HoldsType.type = struct_value () [template] +// CHECK:STDOUT: %HoldsType.cc9: type = class_type @HoldsType, @HoldsType(%T) [symbolic] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %RuntimeConvertFrom: type = class_type @RuntimeConvertFrom [template] +// CHECK:STDOUT: %RuntimeConvertTo: type = class_type @RuntimeConvertTo [template] +// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [template] +// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [template] +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.d62: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic] +// CHECK:STDOUT: %Self: %ImplicitAs.type.d62 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic] +// CHECK:STDOUT: %Convert.type.275: type = fn_type @Convert.1, @ImplicitAs(%Dest) [symbolic] +// CHECK:STDOUT: %Convert.42e: %Convert.type.275 = struct_value () [symbolic] +// CHECK:STDOUT: %Self.as_type: type = facet_access_type %Self [symbolic] +// CHECK:STDOUT: %ImplicitAs.assoc_type.837: type = assoc_entity_type %ImplicitAs.type.d62 [symbolic] +// CHECK:STDOUT: %assoc0.02f: %ImplicitAs.assoc_type.837 = assoc_entity element0, imports.%Core.import_ref.1c7 [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.580: type = facet_type <@ImplicitAs, @ImplicitAs(%RuntimeConvertTo)> [template] +// CHECK:STDOUT: %Convert.type.50a: type = fn_type @Convert.1, @ImplicitAs(%RuntimeConvertTo) [template] +// CHECK:STDOUT: %Convert.993: %Convert.type.50a = struct_value () [template] +// CHECK:STDOUT: %ImplicitAs.assoc_type.46b: type = assoc_entity_type %ImplicitAs.type.580 [template] +// CHECK:STDOUT: %assoc0.322: %ImplicitAs.assoc_type.46b = assoc_entity element0, imports.%Core.import_ref.1c7 [template] +// CHECK:STDOUT: %impl_witness: = impl_witness (@impl.%Convert.decl) [template] +// CHECK:STDOUT: %Convert.type.e8b: type = fn_type @Convert.2 [template] +// CHECK:STDOUT: %Convert.e81: %Convert.type.e8b = struct_value () [template] +// CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.580 = facet_value %RuntimeConvertFrom, %impl_witness [template] +// CHECK:STDOUT: %RuntimeConvertTo.val: %RuntimeConvertTo = struct_value () [template] +// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] +// CHECK:STDOUT: %tuple.elem0: type = tuple_access %T, element0 [symbolic] +// CHECK:STDOUT: %A: %tuple.elem0 = bind_symbolic_name A, 1 [symbolic] +// CHECK:STDOUT: %A.patt: %tuple.elem0 = symbolic_binding_pattern A, 1 [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %HoldsType.cc9 [symbolic] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%RuntimeConvertTo) [template] +// CHECK:STDOUT: %HoldsType.066: type = class_type @HoldsType, @HoldsType(%tuple) [template] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %from: %RuntimeConvertFrom = bind_symbolic_name from, 0 [symbolic] +// CHECK:STDOUT: %from.patt: %RuntimeConvertFrom = symbolic_binding_pattern from, 0 [symbolic] +// CHECK:STDOUT: %RuntimeConvertFrom.val: %RuntimeConvertFrom = struct_value () [template] +// CHECK:STDOUT: %assoc0.43d: %ImplicitAs.assoc_type.837 = assoc_entity element0, imports.%Core.import_ref.207 [symbolic] +// CHECK:STDOUT: %.ff1: type = fn_type_with_self_type %Convert.type.50a, %ImplicitAs.facet [template] +// CHECK:STDOUT: %Convert.bound: = bound_method %from, %Convert.e81 [symbolic] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs +// CHECK:STDOUT: import Core//default +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//default, ImplicitAs, loaded [template = constants.%ImplicitAs.generic] +// CHECK:STDOUT: %Core.import_ref.ffd566.1: type = import_ref Core//default, loc4_22, loaded [symbolic = @ImplicitAs.%Dest (constants.%Dest)] +// CHECK:STDOUT: %Core.import_ref.ff5 = import_ref Core//default, inst26 [no loc], unloaded +// CHECK:STDOUT: %Core.import_ref.630: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type.837) = import_ref Core//default, loc5_35, loaded [symbolic = @ImplicitAs.%assoc0 (constants.%assoc0.43d)] +// CHECK:STDOUT: %Core.Convert: @ImplicitAs.%Convert.type (%Convert.type.275) = import_ref Core//default, Convert, loaded [symbolic = @ImplicitAs.%Convert (constants.%Convert.42e)] +// CHECK:STDOUT: %Core.import_ref.ffd566.2: type = import_ref Core//default, loc4_22, loaded [symbolic = @ImplicitAs.%Dest (constants.%Dest)] +// CHECK:STDOUT: %Core.import_ref.ce1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.d62) = import_ref Core//default, inst26 [no loc], loaded [symbolic = @ImplicitAs.%Self (constants.%Self)] +// CHECK:STDOUT: %Core.import_ref.1c7: @ImplicitAs.%Convert.type (%Convert.type.275) = import_ref Core//default, loc5_35, loaded [symbolic = @ImplicitAs.%Convert (constants.%Convert.42e)] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .HoldsType = %HoldsType.decl +// CHECK:STDOUT: .RuntimeConvertFrom = %RuntimeConvertFrom.decl +// CHECK:STDOUT: .RuntimeConvertTo = %RuntimeConvertTo.decl +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %HoldsType.decl: %HoldsType.type = class_decl @HoldsType [template = constants.%HoldsType.generic] { +// CHECK:STDOUT: %T.patt.loc6_17.1: %tuple.type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_17.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: %tuple.type = value_param_pattern %T.patt.loc6_17.1, runtime_param [symbolic = %T.patt.loc6_17.2 (constants.%T.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: %tuple.type = value_param runtime_param +// CHECK:STDOUT: %.loc6_28.1: type = splice_block %.loc6_28.3 [template = constants.%tuple.type] { +// CHECK:STDOUT: %.loc6_28.2: %tuple.type = tuple_literal (type) +// CHECK:STDOUT: %.loc6_28.3: type = converted %.loc6_28.2, constants.%tuple.type [template = constants.%tuple.type] +// CHECK:STDOUT: } +// CHECK:STDOUT: %T.loc6_17.1: %tuple.type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_17.2 (constants.%T)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %RuntimeConvertFrom.decl: type = class_decl @RuntimeConvertFrom [template = constants.%RuntimeConvertFrom] {} {} +// CHECK:STDOUT: %RuntimeConvertTo.decl: type = class_decl @RuntimeConvertTo [template = constants.%RuntimeConvertTo] {} {} +// CHECK:STDOUT: impl_decl @impl [template] {} { +// CHECK:STDOUT: %RuntimeConvertFrom.ref: type = name_ref RuntimeConvertFrom, file.%RuntimeConvertFrom.decl [template = constants.%RuntimeConvertFrom] +// CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [template = imports.%Core] +// CHECK:STDOUT: %ImplicitAs.ref: %ImplicitAs.type.cc7 = name_ref ImplicitAs, imports.%Core.ImplicitAs [template = constants.%ImplicitAs.generic] +// CHECK:STDOUT: %RuntimeConvertTo.ref: type = name_ref RuntimeConvertTo, file.%RuntimeConvertTo.decl [template = constants.%RuntimeConvertTo] +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(constants.%RuntimeConvertTo)> [template = constants.%ImplicitAs.type.580] +// CHECK:STDOUT: } +// CHECK:STDOUT: %impl_witness: = impl_witness (@impl.%Convert.decl) [template = constants.%impl_witness] +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %T.patt.loc16_6.1: %tuple.type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc16_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: %tuple.type = value_param_pattern %T.patt.loc16_6.1, runtime_param [symbolic = %T.patt.loc16_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %A.patt.loc16_20.1: @F.%tuple.elem0.loc16_25.2 (%tuple.elem0) = symbolic_binding_pattern A, 1 [symbolic = %A.patt.loc16_20.2 (constants.%A.patt)] +// CHECK:STDOUT: %A.param_patt: @F.%tuple.elem0.loc16_25.2 (%tuple.elem0) = value_param_pattern %A.patt.loc16_20.1, runtime_param [symbolic = %A.patt.loc16_20.2 (constants.%A.patt)] +// CHECK:STDOUT: %x.patt: @F.%HoldsType.loc16_43.2 (%HoldsType.cc9) = binding_pattern x +// CHECK:STDOUT: %x.param_patt: @F.%HoldsType.loc16_43.2 (%HoldsType.cc9) = value_param_pattern %x.patt, runtime_param0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: %tuple.type = value_param runtime_param +// CHECK:STDOUT: %.loc16_17.1: type = splice_block %.loc16_17.3 [template = constants.%tuple.type] { +// CHECK:STDOUT: %.loc16_17.2: %tuple.type = tuple_literal (type) +// CHECK:STDOUT: %.loc16_17.3: type = converted %.loc16_17.2, constants.%tuple.type [template = constants.%tuple.type] +// CHECK:STDOUT: } +// CHECK:STDOUT: %T.loc16_6.1: %tuple.type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc16_6.2 (constants.%T)] +// CHECK:STDOUT: %A.param: @F.%tuple.elem0.loc16_25.2 (%tuple.elem0) = value_param runtime_param +// CHECK:STDOUT: %.loc16_25: type = splice_block %tuple.elem0.loc16_25.1 [symbolic = %tuple.elem0.loc16_25.2 (constants.%tuple.elem0)] { +// CHECK:STDOUT: %T.ref.loc16_24: %tuple.type = name_ref T, %T.loc16_6.1 [symbolic = %T.loc16_6.2 (constants.%T)] +// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0] +// CHECK:STDOUT: %tuple.elem0.loc16_25.1: type = tuple_access %T.ref.loc16_24, element0 [symbolic = %tuple.elem0.loc16_25.2 (constants.%tuple.elem0)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %A.loc16_20.1: @F.%tuple.elem0.loc16_25.2 (%tuple.elem0) = bind_symbolic_name A, 1, %A.param [symbolic = %A.loc16_20.2 (constants.%A)] +// CHECK:STDOUT: %x.param: @F.%HoldsType.loc16_43.2 (%HoldsType.cc9) = value_param runtime_param0 +// CHECK:STDOUT: %.loc16_43: type = splice_block %HoldsType.loc16_43.1 [symbolic = %HoldsType.loc16_43.2 (constants.%HoldsType.cc9)] { +// CHECK:STDOUT: %HoldsType.ref: %HoldsType.type = name_ref HoldsType, file.%HoldsType.decl [template = constants.%HoldsType.generic] +// CHECK:STDOUT: %T.ref.loc16_42: %tuple.type = name_ref T, %T.loc16_6.1 [symbolic = %T.loc16_6.2 (constants.%T)] +// CHECK:STDOUT: %HoldsType.loc16_43.1: type = class_type @HoldsType, @HoldsType(constants.%T) [symbolic = %HoldsType.loc16_43.2 (constants.%HoldsType.cc9)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %x: @F.%HoldsType.loc16_43.2 (%HoldsType.cc9) = bind_name x, %x.param +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { +// CHECK:STDOUT: %holds_to.patt: %HoldsType.066 = binding_pattern holds_to +// CHECK:STDOUT: %holds_to.param_patt: %HoldsType.066 = value_param_pattern %holds_to.patt, runtime_param0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %holds_to.param: %HoldsType.066 = value_param runtime_param0 +// CHECK:STDOUT: %.loc18_46.1: type = splice_block %HoldsType [template = constants.%HoldsType.066] { +// CHECK:STDOUT: %HoldsType.ref: %HoldsType.type = name_ref HoldsType, file.%HoldsType.decl [template = constants.%HoldsType.generic] +// CHECK:STDOUT: %RuntimeConvertTo.ref: type = name_ref RuntimeConvertTo, file.%RuntimeConvertTo.decl [template = constants.%RuntimeConvertTo] +// CHECK:STDOUT: %.loc18_45: %tuple.type = tuple_literal (%RuntimeConvertTo.ref) +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%RuntimeConvertTo.ref) [template = constants.%tuple] +// CHECK:STDOUT: %.loc18_46.2: %tuple.type = converted %.loc18_45, %tuple [template = constants.%tuple] +// CHECK:STDOUT: %HoldsType: type = class_type @HoldsType, @HoldsType(constants.%tuple) [template = constants.%HoldsType.066] +// CHECK:STDOUT: } +// CHECK:STDOUT: %holds_to: %HoldsType.066 = bind_name holds_to, %holds_to.param +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @ImplicitAs(imports.%Core.import_ref.ffd566.1: type) [from "core.carbon"] { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %Dest.patt: type = symbolic_binding_pattern Dest, 0 [symbolic = %Dest.patt (constants.%Dest.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.d62)] +// CHECK:STDOUT: %Self: %ImplicitAs.type.d62 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Convert.type: type = fn_type @Convert.1, @ImplicitAs(%Dest) [symbolic = %Convert.type (constants.%Convert.type.275)] +// CHECK:STDOUT: %Convert: @ImplicitAs.%Convert.type (%Convert.type.275) = struct_value () [symbolic = %Convert (constants.%Convert.42e)] +// CHECK:STDOUT: %ImplicitAs.assoc_type: type = assoc_entity_type @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.d62) [symbolic = %ImplicitAs.assoc_type (constants.%ImplicitAs.assoc_type.837)] +// CHECK:STDOUT: %assoc0: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type.837) = assoc_entity element0, imports.%Core.import_ref.1c7 [symbolic = %assoc0 (constants.%assoc0.02f)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = imports.%Core.import_ref.ff5 +// CHECK:STDOUT: .Convert = imports.%Core.import_ref.630 +// CHECK:STDOUT: witness = (imports.%Core.Convert) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: impl @impl: %RuntimeConvertFrom.ref as %ImplicitAs.type { +// CHECK:STDOUT: %Convert.decl: %Convert.type.e8b = fn_decl @Convert.2 [template = constants.%Convert.e81] { +// CHECK:STDOUT: %self.patt: %RuntimeConvertFrom = binding_pattern self +// CHECK:STDOUT: %self.param_patt: %RuntimeConvertFrom = value_param_pattern %self.patt, runtime_param0 +// CHECK:STDOUT: %return.patt: %RuntimeConvertTo = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: %RuntimeConvertTo = out_param_pattern %return.patt, runtime_param1 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %RuntimeConvertTo.ref: type = name_ref RuntimeConvertTo, file.%RuntimeConvertTo.decl [template = constants.%RuntimeConvertTo] +// CHECK:STDOUT: %self.param: %RuntimeConvertFrom = value_param runtime_param0 +// CHECK:STDOUT: %Self.ref: type = name_ref Self, @impl.%RuntimeConvertFrom.ref [template = constants.%RuntimeConvertFrom] +// CHECK:STDOUT: %self: %RuntimeConvertFrom = bind_name self, %self.param +// CHECK:STDOUT: %return.param: ref %RuntimeConvertTo = out_param runtime_param1 +// CHECK:STDOUT: %return: ref %RuntimeConvertTo = return_slot %return.param +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Convert = %Convert.decl +// CHECK:STDOUT: witness = file.%impl_witness +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic class @HoldsType(%T.loc6_17.1: %tuple.type) { +// CHECK:STDOUT: %T.loc6_17.2: %tuple.type = bind_symbolic_name T, 0 [symbolic = %T.loc6_17.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc6_17.2: %tuple.type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_17.2 (constants.%T.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: class { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%HoldsType.cc9 +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @RuntimeConvertFrom { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%RuntimeConvertFrom +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @RuntimeConvertTo { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%RuntimeConvertTo +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @Convert.1(imports.%Core.import_ref.ffd566.2: type, imports.%Core.import_ref.ce1: @ImplicitAs.%ImplicitAs.type (%ImplicitAs.type.d62)) [from "core.carbon"] { +// CHECK:STDOUT: %Dest: type = bind_symbolic_name Dest, 0 [symbolic = %Dest (constants.%Dest)] +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Dest)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.d62)] +// CHECK:STDOUT: %Self: %ImplicitAs.type.d62 = bind_symbolic_name Self, 1 [symbolic = %Self (constants.%Self)] +// CHECK:STDOUT: %Self.as_type: type = facet_access_type %Self [symbolic = %Self.as_type (constants.%Self.as_type)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%self.param_patt: @Convert.1.%Self.as_type (%Self.as_type)]() -> @Convert.1.%Dest (%Dest); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Convert.2[%self.param_patt: %RuntimeConvertFrom]() -> %return.param_patt: %RuntimeConvertTo { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %.loc13_58.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc13_58.2: init %RuntimeConvertTo = class_init (), %return [template = constants.%RuntimeConvertTo.val] +// CHECK:STDOUT: %.loc13_59: init %RuntimeConvertTo = converted %.loc13_58.1, %.loc13_58.2 [template = constants.%RuntimeConvertTo.val] +// CHECK:STDOUT: return %.loc13_59 to %return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%T.loc16_6.1: %tuple.type, %A.loc16_20.1: @F.%tuple.elem0.loc16_25.2 (%tuple.elem0)) { +// CHECK:STDOUT: %T.loc16_6.2: %tuple.type = bind_symbolic_name T, 0 [symbolic = %T.loc16_6.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc16_6.2: %tuple.type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc16_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %tuple.elem0.loc16_25.2: type = tuple_access %T.loc16_6.2, element0 [symbolic = %tuple.elem0.loc16_25.2 (constants.%tuple.elem0)] +// CHECK:STDOUT: %A.loc16_20.2: %tuple.elem0 = bind_symbolic_name A, 1 [symbolic = %A.loc16_20.2 (constants.%A)] +// CHECK:STDOUT: %A.patt.loc16_20.2: %tuple.elem0 = symbolic_binding_pattern A, 1 [symbolic = %A.patt.loc16_20.2 (constants.%A.patt)] +// CHECK:STDOUT: %HoldsType.loc16_43.2: type = class_type @HoldsType, @HoldsType(%T.loc16_6.2) [symbolic = %HoldsType.loc16_43.2 (constants.%HoldsType.cc9)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%HoldsType.loc16_43.2 (%HoldsType.cc9) [symbolic = %require_complete (constants.%require_complete)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%T.param_patt: %tuple.type](%A.param_patt: @F.%tuple.elem0.loc16_25.2 (%tuple.elem0), %x.param_patt: @F.%HoldsType.loc16_43.2 (%HoldsType.cc9)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G(%holds_to.param_patt: %HoldsType.066) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %from.patt: %RuntimeConvertFrom = symbolic_binding_pattern from, 0 [symbolic = constants.%from.patt] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc19_36.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %RuntimeConvertFrom.ref.loc19_41: type = name_ref RuntimeConvertFrom, file.%RuntimeConvertFrom.decl [template = constants.%RuntimeConvertFrom] +// CHECK:STDOUT: %.loc19_36.2: ref %RuntimeConvertFrom = temporary_storage +// CHECK:STDOUT: %.loc19_36.3: init %RuntimeConvertFrom = class_init (), %.loc19_36.2 [template = constants.%RuntimeConvertFrom.val] +// CHECK:STDOUT: %.loc19_36.4: ref %RuntimeConvertFrom = temporary %.loc19_36.2, %.loc19_36.3 +// CHECK:STDOUT: %.loc19_38: ref %RuntimeConvertFrom = converted %.loc19_36.1, %.loc19_36.4 +// CHECK:STDOUT: %RuntimeConvertFrom.ref.loc19_14: type = name_ref RuntimeConvertFrom, file.%RuntimeConvertFrom.decl [template = constants.%RuntimeConvertFrom] +// CHECK:STDOUT: %from: %RuntimeConvertFrom = bind_symbolic_name from, 0, %.loc19_38 [symbolic = constants.%from] +// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] +// CHECK:STDOUT: %from.ref: %RuntimeConvertFrom = name_ref from, %from [symbolic = constants.%from] +// CHECK:STDOUT: %holds_to.ref: %HoldsType.066 = name_ref holds_to, %holds_to +// CHECK:STDOUT: %impl.elem0: %.ff1 = impl_witness_access constants.%impl_witness, element0 [template = constants.%Convert.e81] +// CHECK:STDOUT: %bound_method: = bound_method constants.%from, %impl.elem0 [symbolic = constants.%Convert.bound] +// CHECK:STDOUT: %.loc30_19.1: ref %RuntimeConvertTo = temporary_storage +// CHECK:STDOUT: %Convert.call: init %RuntimeConvertTo = call %bound_method(constants.%from) to %.loc30_19.1 +// CHECK:STDOUT: %.loc30_19.2: init %RuntimeConvertTo = converted constants.%from, %Convert.call +// CHECK:STDOUT: %.loc30_19.3: ref %RuntimeConvertTo = temporary %.loc30_19.1, %.loc30_19.2 +// CHECK:STDOUT: %.loc30_19.4: %RuntimeConvertTo = bind_value %.loc30_19.3 +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%tuple, ) [template = ] +// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn(%holds_to.ref) +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @HoldsType(constants.%T) { +// CHECK:STDOUT: %T.loc6_17.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc6_17.2 => constants.%T +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%Dest) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %Dest.patt => constants.%Dest +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(%Dest) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(@Convert.1.%Dest) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert.1(constants.%Dest, constants.%Self) { +// CHECK:STDOUT: %Dest => constants.%Dest +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.d62 +// CHECK:STDOUT: %Self => constants.%Self +// CHECK:STDOUT: %Self.as_type => constants.%Self.as_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ImplicitAs(constants.%RuntimeConvertTo) { +// CHECK:STDOUT: %Dest => constants.%RuntimeConvertTo +// CHECK:STDOUT: %Dest.patt => constants.%RuntimeConvertTo +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.580 +// CHECK:STDOUT: %Self => constants.%Self +// CHECK:STDOUT: %Convert.type => constants.%Convert.type.50a +// CHECK:STDOUT: %Convert => constants.%Convert.993 +// CHECK:STDOUT: %ImplicitAs.assoc_type => constants.%ImplicitAs.assoc_type.46b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.322 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Convert.1(constants.%RuntimeConvertTo, constants.%ImplicitAs.facet) { +// CHECK:STDOUT: %Dest => constants.%RuntimeConvertTo +// CHECK:STDOUT: %ImplicitAs.type => constants.%ImplicitAs.type.580 +// CHECK:STDOUT: %Self => constants.%ImplicitAs.facet +// CHECK:STDOUT: %Self.as_type => constants.%RuntimeConvertFrom +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%T, constants.%A) { +// CHECK:STDOUT: %T.loc16_6.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc16_6.2 => constants.%T +// CHECK:STDOUT: %tuple.elem0.loc16_25.2 => constants.%tuple.elem0 +// CHECK:STDOUT: %A.loc16_20.2 => constants.%A +// CHECK:STDOUT: %A.patt.loc16_20.2 => constants.%A +// CHECK:STDOUT: %HoldsType.loc16_43.2 => constants.%HoldsType.cc9 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @HoldsType(@F.%T.loc16_6.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @HoldsType(constants.%tuple) { +// CHECK:STDOUT: %T.loc6_17.2 => constants.%tuple +// CHECK:STDOUT: %T.patt.loc6_17.2 => constants.%tuple +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%tuple, ) { +// CHECK:STDOUT: %T.loc16_6.2 => constants.%tuple +// CHECK:STDOUT: %T.patt.loc16_6.2 => constants.%tuple +// CHECK:STDOUT: %tuple.elem0.loc16_25.2 => constants.%RuntimeConvertTo +// CHECK:STDOUT: %A.loc16_20.2 => +// CHECK:STDOUT: %A.patt.loc16_20.2 => +// CHECK:STDOUT: %HoldsType.loc16_43.2 => constants.%HoldsType.066 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/call_method_on_generic_facet.carbon b/toolchain/check/testdata/function/generic/call_method_on_generic_facet.carbon new file mode 100644 index 000000000000..31ff5bf97965 --- /dev/null +++ b/toolchain/check/testdata/function/generic/call_method_on_generic_facet.carbon @@ -0,0 +1,369 @@ +// 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/function/generic/call_method_on_generic_facet.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/function/generic/call_method_on_generic_facet.carbon + +interface Generic(Scalar:! type) { + fn F(); +} + +class GenericParam {} + +class ImplsGeneric {} +impl ImplsGeneric as Generic(GenericParam) { + fn F() {} +} + +interface Other { + fn G(); +} +impl ImplsGeneric as Other { + fn G(); +} + +fn CallGenericMethod(T:! type, U:! Generic(T)) { + U.F(); +} + +fn G() { + CallGenericMethod(GenericParam, ImplsGeneric); +} + +// CHECK:STDOUT: --- call_method_on_generic_facet.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Scalar: type = bind_symbolic_name Scalar, 0 [symbolic] +// CHECK:STDOUT: %Scalar.patt: type = symbolic_binding_pattern Scalar, 0 [symbolic] +// CHECK:STDOUT: %Generic.type.c21: type = generic_interface_type @Generic [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %Generic.generic: %Generic.type.c21 = struct_value () [template] +// CHECK:STDOUT: %Generic.type.91ccba.1: type = facet_type <@Generic, @Generic(%Scalar)> [symbolic] +// CHECK:STDOUT: %Self.dee: %Generic.type.91ccba.1 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %F.type.f439a9.1: type = fn_type @F.1, @Generic(%Scalar) [symbolic] +// CHECK:STDOUT: %F.8a2d67.1: %F.type.f439a9.1 = struct_value () [symbolic] +// CHECK:STDOUT: %Generic.assoc_type.de973d.1: type = assoc_entity_type %Generic.type.91ccba.1 [symbolic] +// CHECK:STDOUT: %assoc0.29ce53.1: %Generic.assoc_type.de973d.1 = assoc_entity element0, @Generic.%F.decl [symbolic] +// CHECK:STDOUT: %GenericParam: type = class_type @GenericParam [template] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %ImplsGeneric: type = class_type @ImplsGeneric [template] +// CHECK:STDOUT: %Generic.type.769: type = facet_type <@Generic, @Generic(%GenericParam)> [template] +// CHECK:STDOUT: %F.type.4cf: type = fn_type @F.1, @Generic(%GenericParam) [template] +// CHECK:STDOUT: %F.118: %F.type.4cf = struct_value () [template] +// CHECK:STDOUT: %Generic.assoc_type.9f1: type = assoc_entity_type %Generic.type.769 [template] +// CHECK:STDOUT: %assoc0.9b7: %Generic.assoc_type.9f1 = assoc_entity element0, @Generic.%F.decl [template] +// CHECK:STDOUT: %impl_witness.b42: = impl_witness (@impl.1.%F.decl) [template] +// CHECK:STDOUT: %F.type.17b: type = fn_type @F.2 [template] +// CHECK:STDOUT: %F.a56: %F.type.17b = struct_value () [template] +// CHECK:STDOUT: %Generic.facet.b0a: %Generic.type.769 = facet_value %ImplsGeneric, %impl_witness.b42 [template] +// CHECK:STDOUT: %Other.type: type = facet_type <@Other> [template] +// CHECK:STDOUT: %Self.807: %Other.type = bind_symbolic_name Self, 0 [symbolic] +// CHECK:STDOUT: %G.type.0c6: type = fn_type @G.1 [template] +// CHECK:STDOUT: %G.17f: %G.type.0c6 = struct_value () [template] +// CHECK:STDOUT: %Other.assoc_type: type = assoc_entity_type %Other.type [template] +// CHECK:STDOUT: %assoc0.5ce: %Other.assoc_type = assoc_entity element0, @Other.%G.decl [template] +// CHECK:STDOUT: %impl_witness.51c: = impl_witness (@impl.2.%G.decl) [template] +// CHECK:STDOUT: %G.type.58d: type = fn_type @G.2 [template] +// CHECK:STDOUT: %G.b67: %G.type.58d = struct_value () [template] +// CHECK:STDOUT: %Other.facet: %Other.type = facet_value %ImplsGeneric, %impl_witness.51c [template] +// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %Generic.type.91ccba.2: type = facet_type <@Generic, @Generic(%T)> [symbolic] +// CHECK:STDOUT: %U: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic] +// CHECK:STDOUT: %U.patt: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic] +// CHECK:STDOUT: %CallGenericMethod.type: type = fn_type @CallGenericMethod [template] +// CHECK:STDOUT: %CallGenericMethod: %CallGenericMethod.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %Generic.type.91ccba.2 [symbolic] +// CHECK:STDOUT: %F.type.f439a9.2: type = fn_type @F.1, @Generic(%T) [symbolic] +// CHECK:STDOUT: %F.8a2d67.2: %F.type.f439a9.2 = struct_value () [symbolic] +// CHECK:STDOUT: %Generic.assoc_type.de973d.2: type = assoc_entity_type %Generic.type.91ccba.2 [symbolic] +// CHECK:STDOUT: %assoc0.29ce53.2: %Generic.assoc_type.de973d.2 = assoc_entity element0, @Generic.%F.decl [symbolic] +// CHECK:STDOUT: %U.as_type: type = facet_access_type %U [symbolic] +// CHECK:STDOUT: %U.as_wit: = facet_access_witness %U [symbolic] +// CHECK:STDOUT: %Generic.facet.2ea: %Generic.type.91ccba.2 = facet_value %U.as_type, %U.as_wit [symbolic] +// CHECK:STDOUT: %.da8: type = fn_type_with_self_type %F.type.f439a9.2, %Generic.facet.2ea [symbolic] +// CHECK:STDOUT: %impl.elem0: %.da8 = impl_witness_access %U.as_wit, element0 [symbolic] +// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @F.1(%T, %Generic.facet.2ea) [symbolic] +// CHECK:STDOUT: %G.type.9f9: type = fn_type @G.3 [template] +// CHECK:STDOUT: %G.57b: %G.type.9f9 = struct_value () [template] +// CHECK:STDOUT: %CallGenericMethod.specific_fn: = specific_function %CallGenericMethod, @CallGenericMethod(%GenericParam, %Generic.facet.b0a) [template] +// CHECK:STDOUT: %complete_type.997: = complete_type_witness %Generic.type.769 [template] +// CHECK:STDOUT: %.db1: type = fn_type_with_self_type %F.type.4cf, %Generic.facet.b0a [template] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.a56, @F.1(%GenericParam, %Generic.facet.b0a) [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/... +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .Generic = %Generic.decl +// CHECK:STDOUT: .GenericParam = %GenericParam.decl +// CHECK:STDOUT: .ImplsGeneric = %ImplsGeneric.decl +// CHECK:STDOUT: .Other = %Other.decl +// CHECK:STDOUT: .CallGenericMethod = %CallGenericMethod.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %Generic.decl: %Generic.type.c21 = interface_decl @Generic [template = constants.%Generic.generic] { +// CHECK:STDOUT: %Scalar.patt.loc11_19.1: type = symbolic_binding_pattern Scalar, 0 [symbolic = %Scalar.patt.loc11_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: %Scalar.param_patt: type = value_param_pattern %Scalar.patt.loc11_19.1, runtime_param [symbolic = %Scalar.patt.loc11_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %Scalar.param: type = value_param runtime_param +// CHECK:STDOUT: %Scalar.loc11_19.1: type = bind_symbolic_name Scalar, 0, %Scalar.param [symbolic = %Scalar.loc11_19.2 (constants.%Scalar)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %GenericParam.decl: type = class_decl @GenericParam [template = constants.%GenericParam] {} {} +// CHECK:STDOUT: %ImplsGeneric.decl: type = class_decl @ImplsGeneric [template = constants.%ImplsGeneric] {} {} +// CHECK:STDOUT: impl_decl @impl.1 [template] {} { +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %GenericParam.ref: type = name_ref GenericParam, file.%GenericParam.decl [template = constants.%GenericParam] +// CHECK:STDOUT: %Generic.type: type = facet_type <@Generic, @Generic(constants.%GenericParam)> [template = constants.%Generic.type.769] +// CHECK:STDOUT: } +// CHECK:STDOUT: %impl_witness.loc18: = impl_witness (@impl.1.%F.decl) [template = constants.%impl_witness.b42] +// CHECK:STDOUT: %Other.decl: type = interface_decl @Other [template = constants.%Other.type] {} {} +// CHECK:STDOUT: impl_decl @impl.2 [template] {} { +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Other.ref: type = name_ref Other, file.%Other.decl [template = constants.%Other.type] +// CHECK:STDOUT: } +// CHECK:STDOUT: %impl_witness.loc25: = impl_witness (@impl.2.%G.decl) [template = constants.%impl_witness.51c] +// CHECK:STDOUT: %CallGenericMethod.decl: %CallGenericMethod.type = fn_decl @CallGenericMethod [template = constants.%CallGenericMethod] { +// CHECK:STDOUT: %T.patt.loc29_22.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc29_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc29_22.1, runtime_param [symbolic = %T.patt.loc29_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %U.patt.loc29_32.1: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc29_32.2 (constants.%U.patt)] +// CHECK:STDOUT: %U.param_patt: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) = value_param_pattern %U.patt.loc29_32.1, runtime_param [symbolic = %U.patt.loc29_32.2 (constants.%U.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc29_22.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc29_22.2 (constants.%T)] +// CHECK:STDOUT: %U.param: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) = value_param runtime_param +// CHECK:STDOUT: %.loc29: type = splice_block %Generic.type.loc29_45.1 [symbolic = %Generic.type.loc29_45.2 (constants.%Generic.type.91ccba.2)] { +// CHECK:STDOUT: %Generic.ref: %Generic.type.c21 = name_ref Generic, file.%Generic.decl [template = constants.%Generic.generic] +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc29_22.1 [symbolic = %T.loc29_22.2 (constants.%T)] +// CHECK:STDOUT: %Generic.type.loc29_45.1: type = facet_type <@Generic, @Generic(constants.%T)> [symbolic = %Generic.type.loc29_45.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %U.loc29_32.1: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc29_32.2 (constants.%U)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type.9f9 = fn_decl @G.3 [template = constants.%G.57b] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic interface @Generic(%Scalar.loc11_19.1: type) { +// CHECK:STDOUT: %Scalar.loc11_19.2: type = bind_symbolic_name Scalar, 0 [symbolic = %Scalar.loc11_19.2 (constants.%Scalar)] +// CHECK:STDOUT: %Scalar.patt.loc11_19.2: type = symbolic_binding_pattern Scalar, 0 [symbolic = %Scalar.patt.loc11_19.2 (constants.%Scalar.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type: type = facet_type <@Generic, @Generic(%Scalar.loc11_19.2)> [symbolic = %Generic.type (constants.%Generic.type.91ccba.1)] +// CHECK:STDOUT: %Self.2: %Generic.type.91ccba.1 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.dee)] +// CHECK:STDOUT: %F.type: type = fn_type @F.1, @Generic(%Scalar.loc11_19.2) [symbolic = %F.type (constants.%F.type.f439a9.1)] +// CHECK:STDOUT: %F: @Generic.%F.type (%F.type.f439a9.1) = struct_value () [symbolic = %F (constants.%F.8a2d67.1)] +// CHECK:STDOUT: %Generic.assoc_type: type = assoc_entity_type @Generic.%Generic.type (%Generic.type.91ccba.1) [symbolic = %Generic.assoc_type (constants.%Generic.assoc_type.de973d.1)] +// CHECK:STDOUT: %assoc0.loc12_9.2: @Generic.%Generic.assoc_type (%Generic.assoc_type.de973d.1) = assoc_entity element0, %F.decl [symbolic = %assoc0.loc12_9.2 (constants.%assoc0.29ce53.1)] +// CHECK:STDOUT: +// CHECK:STDOUT: interface { +// CHECK:STDOUT: %Self.1: @Generic.%Generic.type (%Generic.type.91ccba.1) = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self.dee)] +// CHECK:STDOUT: %F.decl: @Generic.%F.type (%F.type.f439a9.1) = fn_decl @F.1 [symbolic = @Generic.%F (constants.%F.8a2d67.1)] {} {} +// CHECK:STDOUT: %assoc0.loc12_9.1: @Generic.%Generic.assoc_type (%Generic.assoc_type.de973d.1) = assoc_entity element0, %F.decl [symbolic = %assoc0.loc12_9.2 (constants.%assoc0.29ce53.1)] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self.1 +// CHECK:STDOUT: .F = %assoc0.loc12_9.1 +// CHECK:STDOUT: witness = (%F.decl) +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: interface @Other { +// CHECK:STDOUT: %Self: %Other.type = bind_symbolic_name Self, 0 [symbolic = constants.%Self.807] +// CHECK:STDOUT: %G.decl: %G.type.0c6 = fn_decl @G.1 [template = constants.%G.17f] {} {} +// CHECK:STDOUT: %assoc0: %Other.assoc_type = assoc_entity element0, %G.decl [template = constants.%assoc0.5ce] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = %Self +// CHECK:STDOUT: .G = %assoc0 +// CHECK:STDOUT: witness = (%G.decl) +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: impl @impl.1: %ImplsGeneric.ref as %Generic.type { +// CHECK:STDOUT: %F.decl: %F.type.17b = fn_decl @F.2 [template = constants.%F.a56] {} {} +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: witness = file.%impl_witness.loc18 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: impl @impl.2: %ImplsGeneric.ref as %Other.ref { +// CHECK:STDOUT: %G.decl: %G.type.58d = fn_decl @G.2 [template = constants.%G.b67] {} {} +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: witness = file.%impl_witness.loc25 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @GenericParam { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.357] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%GenericParam +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @ImplsGeneric { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.357] +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%ImplsGeneric +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F.1(@Generic.%Scalar.loc11_19.1: type, @Generic.%Self.1: @Generic.%Generic.type (%Generic.type.91ccba.1)) { +// CHECK:STDOUT: fn(); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F.2() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @G.1(@Other.%Self: %Other.type) { +// CHECK:STDOUT: fn(); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G.2(); +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @CallGenericMethod(%T.loc29_22.1: type, %U.loc29_32.1: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: %T.loc29_22.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc29_22.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc29_22.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc29_22.2 (constants.%T.patt)] +// CHECK:STDOUT: %Generic.type.loc29_45.2: type = facet_type <@Generic, @Generic(%T.loc29_22.2)> [symbolic = %Generic.type.loc29_45.2 (constants.%Generic.type.91ccba.2)] +// CHECK:STDOUT: %U.loc29_32.2: %Generic.type.91ccba.2 = bind_symbolic_name U, 1 [symbolic = %U.loc29_32.2 (constants.%U)] +// CHECK:STDOUT: %U.patt.loc29_32.2: %Generic.type.91ccba.2 = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc29_32.2 (constants.%U.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) [symbolic = %require_complete (constants.%require_complete)] +// CHECK:STDOUT: %Generic.assoc_type: type = assoc_entity_type @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) [symbolic = %Generic.assoc_type (constants.%Generic.assoc_type.de973d.2)] +// CHECK:STDOUT: %assoc0: @CallGenericMethod.%Generic.assoc_type (%Generic.assoc_type.de973d.2) = assoc_entity element0, @Generic.%F.decl [symbolic = %assoc0 (constants.%assoc0.29ce53.2)] +// CHECK:STDOUT: %U.as_type.loc30_4.2: type = facet_access_type %U.loc29_32.2 [symbolic = %U.as_type.loc30_4.2 (constants.%U.as_type)] +// CHECK:STDOUT: %U.as_wit.loc30_4.2: = facet_access_witness %U.loc29_32.2 [symbolic = %U.as_wit.loc30_4.2 (constants.%U.as_wit)] +// CHECK:STDOUT: %F.type: type = fn_type @F.1, @Generic(%T.loc29_22.2) [symbolic = %F.type (constants.%F.type.f439a9.2)] +// CHECK:STDOUT: %Generic.facet: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) = facet_value %U.as_type.loc30_4.2, %U.as_wit.loc30_4.2 [symbolic = %Generic.facet (constants.%Generic.facet.2ea)] +// CHECK:STDOUT: %.loc30_4.3: type = fn_type_with_self_type %F.type, %Generic.facet [symbolic = %.loc30_4.3 (constants.%.da8)] +// CHECK:STDOUT: %impl.elem0.loc30_4.2: @CallGenericMethod.%.loc30_4.3 (%.da8) = impl_witness_access %U.as_wit.loc30_4.2, element0 [symbolic = %impl.elem0.loc30_4.2 (constants.%impl.elem0)] +// CHECK:STDOUT: %specific_fn.loc30_4.2: = specific_function %impl.elem0.loc30_4.2, @F.1(%T.loc29_22.2, %Generic.facet) [symbolic = %specific_fn.loc30_4.2 (constants.%specific_fn)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %U.ref: @CallGenericMethod.%Generic.type.loc29_45.2 (%Generic.type.91ccba.2) = name_ref U, %U.loc29_32.1 [symbolic = %U.loc29_32.2 (constants.%U)] +// CHECK:STDOUT: %.loc30_4.1: @CallGenericMethod.%Generic.assoc_type (%Generic.assoc_type.de973d.2) = specific_constant @Generic.%assoc0.loc12_9.1, @Generic(constants.%T) [symbolic = %assoc0 (constants.%assoc0.29ce53.2)] +// CHECK:STDOUT: %F.ref: @CallGenericMethod.%Generic.assoc_type (%Generic.assoc_type.de973d.2) = name_ref F, %.loc30_4.1 [symbolic = %assoc0 (constants.%assoc0.29ce53.2)] +// CHECK:STDOUT: %U.as_type.loc30_4.1: type = facet_access_type %U.ref [symbolic = %U.as_type.loc30_4.2 (constants.%U.as_type)] +// CHECK:STDOUT: %.loc30_4.2: type = converted %U.ref, %U.as_type.loc30_4.1 [symbolic = %U.as_type.loc30_4.2 (constants.%U.as_type)] +// CHECK:STDOUT: %U.as_wit.loc30_4.1: = facet_access_witness %U.ref [symbolic = %U.as_wit.loc30_4.2 (constants.%U.as_wit)] +// CHECK:STDOUT: %impl.elem0.loc30_4.1: @CallGenericMethod.%.loc30_4.3 (%.da8) = impl_witness_access %U.as_wit.loc30_4.1, element0 [symbolic = %impl.elem0.loc30_4.2 (constants.%impl.elem0)] +// CHECK:STDOUT: %specific_fn.loc30_4.1: = specific_function %impl.elem0.loc30_4.1, @F.1(constants.%T, constants.%Generic.facet.2ea) [symbolic = %specific_fn.loc30_4.2 (constants.%specific_fn)] +// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %specific_fn.loc30_4.1() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G.3() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %CallGenericMethod.ref: %CallGenericMethod.type = name_ref CallGenericMethod, file.%CallGenericMethod.decl [template = constants.%CallGenericMethod] +// CHECK:STDOUT: %GenericParam.ref: type = name_ref GenericParam, file.%GenericParam.decl [template = constants.%GenericParam] +// CHECK:STDOUT: %ImplsGeneric.ref: type = name_ref ImplsGeneric, file.%ImplsGeneric.decl [template = constants.%ImplsGeneric] +// CHECK:STDOUT: %Generic.facet: %Generic.type.769 = facet_value constants.%ImplsGeneric, constants.%impl_witness.b42 [template = constants.%Generic.facet.b0a] +// CHECK:STDOUT: %.loc34: %Generic.type.769 = converted constants.%ImplsGeneric, %Generic.facet [template = constants.%Generic.facet.b0a] +// CHECK:STDOUT: %CallGenericMethod.specific_fn: = specific_function %CallGenericMethod.ref, @CallGenericMethod(constants.%GenericParam, %.loc34) [template = constants.%CallGenericMethod.specific_fn] +// CHECK:STDOUT: %CallGenericMethod.call: init %empty_tuple.type = call %CallGenericMethod.specific_fn() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%Scalar) { +// CHECK:STDOUT: %Scalar.loc11_19.2 => constants.%Scalar +// CHECK:STDOUT: %Scalar.patt.loc11_19.2 => constants.%Scalar +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%Scalar, constants.%Self.dee) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(%Scalar.loc11_19.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%GenericParam) { +// CHECK:STDOUT: %Scalar.loc11_19.2 => constants.%GenericParam +// CHECK:STDOUT: %Scalar.patt.loc11_19.2 => constants.%GenericParam +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type => constants.%Generic.type.769 +// CHECK:STDOUT: %Self.2 => constants.%Self.dee +// CHECK:STDOUT: %F.type => constants.%F.type.4cf +// CHECK:STDOUT: %F => constants.%F.118 +// CHECK:STDOUT: %Generic.assoc_type => constants.%Generic.assoc_type.9f1 +// CHECK:STDOUT: %assoc0.loc12_9.2 => constants.%assoc0.9b7 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%GenericParam, constants.%Generic.facet.b0a) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @G.1(constants.%Self.807) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @G.1(constants.%Other.facet) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(constants.%T) { +// CHECK:STDOUT: %Scalar.loc11_19.2 => constants.%T +// CHECK:STDOUT: %Scalar.patt.loc11_19.2 => constants.%T +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Generic.type => constants.%Generic.type.91ccba.2 +// CHECK:STDOUT: %Self.2 => constants.%Self.dee +// CHECK:STDOUT: %F.type => constants.%F.type.f439a9.2 +// CHECK:STDOUT: %F => constants.%F.8a2d67.2 +// CHECK:STDOUT: %Generic.assoc_type => constants.%Generic.assoc_type.de973d.2 +// CHECK:STDOUT: %assoc0.loc12_9.2 => constants.%assoc0.29ce53.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%T, constants.%U) { +// CHECK:STDOUT: %T.loc29_22.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc29_22.2 => constants.%T +// CHECK:STDOUT: %Generic.type.loc29_45.2 => constants.%Generic.type.91ccba.2 +// CHECK:STDOUT: %U.loc29_32.2 => constants.%U +// CHECK:STDOUT: %U.patt.loc29_32.2 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @Generic(@CallGenericMethod.%T.loc29_22.2) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(constants.%T, constants.%Generic.facet.2ea) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F.1(@CallGenericMethod.%T.loc29_22.2, @CallGenericMethod.%Generic.facet) {} +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%GenericParam, @G.3.%.loc34) { +// CHECK:STDOUT: %T.loc29_22.2 => constants.%GenericParam +// CHECK:STDOUT: %T.patt.loc29_22.2 => constants.%GenericParam +// CHECK:STDOUT: %Generic.type.loc29_45.2 => constants.%Generic.type.769 +// CHECK:STDOUT: %U.loc29_32.2 => constants.%Generic.facet.b0a +// CHECK:STDOUT: %U.patt.loc29_32.2 => constants.%Generic.facet.b0a +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.997 +// CHECK:STDOUT: %Generic.assoc_type => constants.%Generic.assoc_type.9f1 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.9b7 +// CHECK:STDOUT: %U.as_type.loc30_4.2 => constants.%ImplsGeneric +// CHECK:STDOUT: %U.as_wit.loc30_4.2 => constants.%impl_witness.b42 +// CHECK:STDOUT: %F.type => constants.%F.type.4cf +// CHECK:STDOUT: %Generic.facet => constants.%Generic.facet.b0a +// CHECK:STDOUT: %.loc30_4.3 => constants.%.db1 +// CHECK:STDOUT: %impl.elem0.loc30_4.2 => constants.%F.a56 +// CHECK:STDOUT: %specific_fn.loc30_4.2 => constants.%F.specific_fn +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @CallGenericMethod(constants.%GenericParam, constants.%Generic.facet.b0a) { +// CHECK:STDOUT: %T.loc29_22.2 => constants.%GenericParam +// CHECK:STDOUT: %T.patt.loc29_22.2 => constants.%GenericParam +// CHECK:STDOUT: %Generic.type.loc29_45.2 => constants.%Generic.type.769 +// CHECK:STDOUT: %U.loc29_32.2 => constants.%Generic.facet.b0a +// CHECK:STDOUT: %U.patt.loc29_32.2 => constants.%Generic.facet.b0a +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/diagnostics/diagnostic_kind.def b/toolchain/diagnostics/diagnostic_kind.def index d93e41732496..ecb4ecb25746 100644 --- a/toolchain/diagnostics/diagnostic_kind.def +++ b/toolchain/diagnostics/diagnostic_kind.def @@ -257,6 +257,7 @@ CARBON_DIAGNOSTIC_KIND(DeductionInconsistent) CARBON_DIAGNOSTIC_KIND(DeductionGenericHere) CARBON_DIAGNOSTIC_KIND(InitializingGenericParam) CARBON_DIAGNOSTIC_KIND(CompTimeArgumentNotConstant) +CARBON_DIAGNOSTIC_KIND(RuntimeConversionDuringCompTimeDeduction) // Export checking. CARBON_DIAGNOSTIC_KIND(ExportNotImportedEntity)